Lines Matching refs:lp
111 fmd_log_write(fmd_log_t *lp, const void *buf, size_t n)
116 ASSERT(MUTEX_HELD(&lp->log_lock));
119 if ((len = write(lp->log_fd, buf, resid)) <= 0)
133 fmd_log_write_hdr(fmd_log_t *lp, const char *tag)
144 (void) fmd_conf_getprop(fmd.d_conf, "uuidlen", &lp->log_uuidlen);
146 lp->log_uuid = fmd_zalloc(lp->log_uuidlen + 1, FMD_SLEEP);
148 uuid_unparse(uuid, lp->log_uuid);
158 err |= ea_set_item(&i5, CAT_FMA_UUID, lp->log_uuid, 0);
179 if ((lp->log_off = lseek64(lp->log_fd, 0, SEEK_END)) == -1L)
180 fmd_panic("failed to seek log %s", lp->log_name);
182 if (fmd_log_write(lp, buf, size) != size)
187 lp->log_toc = lp->log_off + hdr_size;
188 lp->log_beg = lp->log_off + hdr_size + toc_size;
189 lp->log_off = lp->log_off + hdr_size + toc_size;
191 if (lp->log_off != lseek64(lp->log_fd, 0, SEEK_END))
192 fmd_panic("eof off != log_off 0x%llx\n", lp->log_off);
208 fmd_log_check_err(fmd_log_t *lp, int err, const char *msg)
214 lp->log_name, msg, eaerr != EXR_OK ?
222 fmd_log_check_hdr(fmd_log_t *lp, const char *tag)
230 ea_clear(&lp->log_ea); /* resync exacct file */
232 if ((hdr_off = lseek64(lp->log_fd, 0, SEEK_CUR)) == -1L)
233 fmd_panic("failed to seek log %s", lp->log_name);
240 if ((grp = ea_get_object_tree(&lp->log_ea, 1)) == NULL ||
243 return (fmd_log_check_err(lp, EFMD_LOG_INVAL,
269 lp->log_name, obj->eo_item.ei_string);
281 lp->log_name, obj->eo_item.ei_string, tag);
288 lp->log_uuid = fmd_strdup(obj->eo_item.ei_string,
290 lp->log_uuidlen = strlen(lp->log_uuid);
300 "include mandatory version and/or label\n", lp->log_name);
309 if ((grp = ea_get_object_tree(&lp->log_ea, 1)) == NULL ||
313 return (fmd_log_check_err(lp, EFMD_LOG_INVAL,
317 lp->log_toc = hdr_off + hdr_size;
318 lp->log_beg = hdr_off + hdr_size + ea_pack_object(grp, NULL, 0);
319 lp->log_off = lseek64(lp->log_fd, 0, SEEK_END);
320 lp->log_skip = grp->eo_group.eg_objs->eo_item.ei_uint64;
322 if (lp->log_skip > lp->log_off) {
324 "resetting to zero\n", lp->log_name, lp->log_skip);
325 lp->log_skip = 0;
333 fmd_log_open_exacct(fmd_log_t *lp, int aflags, int oflags)
335 int fd = dup(lp->log_fd);
340 if (ea_fdopen(&lp->log_ea, fd, creator, aflags, oflags) != 0) {
342 lp->log_name, fmd_ea_strerror(ea_error()));
347 lp->log_flags |= FMD_LF_EAOPEN;
354 fmd_log_t *lp = fmd_zalloc(sizeof (fmd_log_t), FMD_SLEEP);
361 (void) pthread_mutex_init(&lp->log_lock, NULL);
362 (void) pthread_cond_init(&lp->log_cv, NULL);
363 (void) pthread_mutex_lock(&lp->log_lock);
368 lp->log_name = fmd_alloc(len, FMD_SLEEP);
369 (void) snprintf(lp->log_name, len, "%s%s%s", root, slash, name);
370 lp->log_tag = fmd_strdup(tag, FMD_SLEEP);
371 (void) fmd_conf_getprop(fmd.d_conf, "log.minfree", &lp->log_minfree);
373 if (strcmp(lp->log_tag, FMD_LOG_ERROR) == 0)
374 lp->log_flags |= FMD_LF_REPLAY;
376 if (strcmp(lp->log_tag, FMD_LOG_XPRT) == 0)
380 if ((lp->log_fd = open64(lp->log_name, oflags, 0644)) == -1 ||
381 fstat64(lp->log_fd, &lp->log_stat) == -1) {
382 fmd_error(EFMD_LOG_OPEN, "failed to open log %s", lp->log_name);
383 fmd_log_close(lp);
394 if (lp->log_stat.st_size == 0) {
395 err = fmd_log_open_exacct(lp, EO_VALID_HDR | EO_TAIL,
396 O_CREAT | O_WRONLY) || fmd_log_write_hdr(lp, tag);
398 err = fmd_log_open_exacct(lp, EO_VALID_HDR | EO_HEAD,
399 O_RDONLY) || fmd_log_check_hdr(lp, tag);
409 "failed to initialize log %s", lp->log_name);
411 if (lp->log_flags & FMD_LF_EAOPEN) {
412 lp->log_flags &= ~FMD_LF_EAOPEN;
413 (void) ea_close(&lp->log_ea);
416 (void) close(lp->log_fd);
417 lp->log_fd = -1;
419 if (lp->log_stat.st_size != 0 && snprintf(buf,
420 sizeof (buf), "%s-", lp->log_name) < PATH_MAX &&
421 rename(lp->log_name, buf) == 0) {
422 TRACE((FMD_DBG_LOG, "mv %s to %s", lp->log_name, buf));
427 fmd_log_close(lp);
431 lp->log_refs++;
432 (void) pthread_mutex_unlock(&lp->log_lock);
434 return (lp);
450 fmd_log_close(fmd_log_t *lp)
452 ASSERT(MUTEX_HELD(&lp->log_lock));
453 ASSERT(lp->log_refs == 0);
455 if ((lp->log_flags & FMD_LF_EAOPEN) && ea_close(&lp->log_ea) != 0) {
457 lp->log_name, fmd_ea_strerror(ea_error()));
460 if (lp->log_fd >= 0 && close(lp->log_fd) != 0) {
462 "failed to close log %s", lp->log_name);
465 fmd_strfree(lp->log_name);
466 fmd_strfree(lp->log_tag);
467 if (lp->log_uuid != NULL)
468 fmd_free(lp->log_uuid, lp->log_uuidlen + 1);
470 fmd_free(lp, sizeof (fmd_log_t));
474 fmd_log_hold_pending(fmd_log_t *lp)
476 (void) pthread_mutex_lock(&lp->log_lock);
478 lp->log_refs++;
479 ASSERT(lp->log_refs != 0);
481 if (lp->log_flags & FMD_LF_REPLAY) {
482 lp->log_pending++;
483 ASSERT(lp->log_pending != 0);
486 (void) pthread_mutex_unlock(&lp->log_lock);
490 fmd_log_hold(fmd_log_t *lp)
492 (void) pthread_mutex_lock(&lp->log_lock);
493 lp->log_refs++;
494 ASSERT(lp->log_refs != 0);
495 (void) pthread_mutex_unlock(&lp->log_lock);
499 fmd_log_rele(fmd_log_t *lp)
501 (void) pthread_mutex_lock(&lp->log_lock);
502 ASSERT(lp->log_refs != 0);
504 if (--lp->log_refs == 0)
505 fmd_log_close(lp);
507 (void) pthread_mutex_unlock(&lp->log_lock);
511 fmd_log_append(fmd_log_t *lp, fmd_event_t *e, fmd_case_t *cp)
532 if (lp->log_flags & FMD_LF_REPLAY)
627 (void) pthread_mutex_lock(&lp->log_lock);
629 if (lp->log_minfree != 0 && fstatvfs64(lp->log_fd, &stv) == 0 &&
630 stv.f_bavail * stv.f_frsize < lp->log_minfree + easize) {
632 TRACE((FMD_DBG_LOG, "append %s crosses minfree", lp->log_tag));
635 } else if (fmd_log_write(lp, eabuf, easize) == easize) {
637 lp->log_tag, (void *)ep, (u_longlong_t)lp->log_off));
640 ep->ev_log = lp;
641 ep->ev_off = lp->log_off;
644 if (lp->log_flags & FMD_LF_REPLAY) {
645 lp->log_pending++;
646 ASSERT(lp->log_pending != 0);
649 lp->log_refs++;
650 ASSERT(lp->log_refs != 0);
651 lp->log_off += easize;
660 (void) lseek64(lp->log_fd, lp->log_off, SEEK_SET);
661 (void) ftruncate64(lp->log_fd, lp->log_off);
664 (void) pthread_mutex_unlock(&lp->log_lock);
697 if (lp == fmd.d_errlog)
699 else if (lp == fmd.d_fltlog)
711 lp->log_tag, (void *)ep, fmd_strerror(err));
725 fmd_log_commit(fmd_log_t *lp, fmd_event_t *e)
731 if (!(lp->log_flags & FMD_LF_REPLAY))
735 ASSERT(ep->ev_log == lp && ep->ev_off != 0);
740 if (pwrite64(lp->log_fd, &c, sizeof (c), ep->ev_off) == sizeof (c)) {
741 TRACE((FMD_DBG_LOG, "commit %s %p", lp->log_tag, (void *)ep));
748 (void) pthread_mutex_lock(&lp->log_lock);
750 if (lp->log_skip == ep->ev_off) {
751 lp->log_flags |= FMD_LF_DIRTY;
752 lp->log_skip += ep->ev_len;
755 ASSERT(lp->log_pending != 0);
756 lp->log_pending--;
758 (void) pthread_cond_broadcast(&lp->log_cv);
759 (void) pthread_mutex_unlock(&lp->log_lock);
763 lp->log_tag, (void *)ep, fmd_strerror(err));
773 fmd_log_decommit(fmd_log_t *lp, fmd_event_t *e)
777 if (!(lp->log_flags & FMD_LF_REPLAY))
781 ASSERT(ep->ev_log == lp);
783 (void) pthread_mutex_lock(&lp->log_lock);
785 TRACE((FMD_DBG_LOG, "decommit %s %p", lp->log_tag, (void *)ep));
788 ASSERT(lp->log_pending != 0);
789 lp->log_pending--;
791 (void) pthread_cond_broadcast(&lp->log_cv);
792 (void) pthread_mutex_unlock(&lp->log_lock);
796 fmd_log_unpack(fmd_log_t *lp, ea_object_t *grp, off64_t off)
841 &ftv, nvl, class, lp, off, ea_pack_object(grp, NULL, 0)));
852 fmd_log_replay(fmd_log_t *lp, fmd_log_f *func, void *data)
861 (void) pthread_mutex_lock(&lp->log_lock);
863 if (lp->log_stat.st_size == 0 && (lp->log_flags & FMD_LF_REPLAY)) {
864 (void) pthread_mutex_unlock(&lp->log_lock);
868 while (lp->log_flags & FMD_LF_BUSY)
869 (void) pthread_cond_wait(&lp->log_cv, &lp->log_lock);
871 if (lp->log_off == lp->log_beg) {
872 (void) pthread_mutex_unlock(&lp->log_lock);
876 lp->log_flags |= FMD_LF_BUSY;
877 skp = lp->log_skip;
878 ea_clear(&lp->log_ea); /* resync exacct file */
884 if (lp->log_flags & FMD_LF_REPLAY) {
885 off = MAX(lp->log_beg, lp->log_skip);
888 off = lp->log_off;
892 if (lseek64(lp->log_fd, off, SEEK_SET) != off) {
894 lp->log_name, (u_longlong_t)off);
901 if (!(lp->log_flags & FMD_LF_REPLAY) &&
902 (type = ea_previous_object(&lp->log_ea, &obj)) != EO_GROUP) {
908 while ((grp = ea_get_object_tree(&lp->log_ea, 1)) != NULL) {
909 if (!(lp->log_flags & FMD_LF_REPLAY))
920 (void) pthread_mutex_unlock(&lp->log_lock);
923 (ep = fmd_log_unpack(lp, grp, off)) != NULL) {
926 lp->log_tag, (void *)ep, (u_longlong_t)off));
929 func(lp, ep, data);
934 (void) pthread_mutex_lock(&lp->log_lock);
941 "offset 0x%llx: %s\n", lp->log_name, (u_longlong_t)off,
949 if (lseek64(lp->log_fd, lp->log_off, SEEK_SET) != lp->log_off) {
951 lp->log_name, (u_longlong_t)lp->log_off);
954 if (skp != lp->log_skip) {
955 lp->log_flags |= FMD_LF_DIRTY;
956 lp->log_skip = skp;
959 lp->log_flags &= ~FMD_LF_BUSY;
960 (void) pthread_cond_broadcast(&lp->log_cv);
961 (void) pthread_mutex_unlock(&lp->log_lock);
965 fmd_log_update(fmd_log_t *lp)
972 (void) pthread_mutex_lock(&lp->log_lock);
974 if (lp->log_flags & FMD_LF_DIRTY) {
975 lp->log_flags &= ~FMD_LF_DIRTY;
976 skip = lp->log_skip;
979 (void) pthread_mutex_unlock(&lp->log_lock);
993 ASSERT(lp->log_toc + size == lp->log_beg);
995 if (pwrite64(lp->log_fd, buf, size, lp->log_toc) == size) {
999 "failed to log_update %s", lp->log_tag);
1017 fmd_log_rotate(fmd_log_t *lp)
1022 (void) snprintf(npath, sizeof (npath), "%s+", lp->log_name);
1027 if ((nlp = fmd_log_open("", npath, lp->log_tag)) == NULL) {
1033 (void) snprintf(npath, sizeof (npath), "%s.0-", lp->log_name);
1034 (void) pthread_mutex_lock(&lp->log_lock);
1041 if (lp->log_pending != 0) {
1042 (void) pthread_mutex_unlock(&lp->log_lock);
1049 if (rename(lp->log_name, npath) != 0) {
1050 (void) pthread_mutex_unlock(&lp->log_lock);
1051 fmd_error(EFMD_LOG_ROTATE, "failed to rename %s", lp->log_name);
1058 if (rename(nlp->log_name, lp->log_name) != 0) {
1059 (void) pthread_mutex_unlock(&lp->log_lock);
1072 nlp->log_name = fmd_strdup(lp->log_name, FMD_SLEEP);
1079 if (lp->log_flags & FMD_LF_EAOPEN) {
1080 (void) ea_close(&lp->log_ea);
1081 lp->log_flags &= ~FMD_LF_EAOPEN;
1084 (void) close(lp->log_fd);
1085 lp->log_fd = -1;
1087 (void) pthread_mutex_unlock(&lp->log_lock);