]> git.proxmox.com Git - mirror_zfs.git/blob - module/zfs/fm.c
projects / mirror_zfs.git / blob
? search:


c004032f8dc89f3eb256620be4081404bec15121
[mirror_zfs.git] / module / zfs / fm.c
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * Fault Management Architecture (FMA) Resource and Protocol Support
27 *
28 * The routines contained herein provide services to support kernel subsystems
29 * in publishing fault management telemetry (see PSARC 2002/412 and 2003/089).
30 *
31 * Name-Value Pair Lists
32 *
33 * The embodiment of an FMA protocol element (event, fmri or authority) is a
34 * name-value pair list (nvlist_t). FMA-specific nvlist construtor and
35 * destructor functions, fm_nvlist_create() and fm_nvlist_destroy(), are used
36 * to create an nvpair list using custom allocators. Callers may choose to
37 * allocate either from the kernel memory allocator, or from a preallocated
38 * buffer, useful in constrained contexts like high-level interrupt routines.
39 *
40 * Protocol Event and FMRI Construction
41 *
42 * Convenience routines are provided to construct nvlist events according to
43 * the FMA Event Protocol and Naming Schema specification for ereports and
44 * FMRIs for the dev, cpu, hc, mem, legacy hc and de schemes.
45 *
46 * ENA Manipulation
47 *
48 * Routines to generate ENA formats 0, 1 and 2 are available as well as
49 * routines to increment formats 1 and 2. Individual fields within the
50 * ENA are extractable via fm_ena_time_get(), fm_ena_id_get(),
51 * fm_ena_format_get() and fm_ena_gen_get().
52 */
53
54 #include <sys/types.h>
55 #include <sys/time.h>
56 #include <sys/list.h>
57 #include <sys/nvpair.h>
58 #include <sys/cmn_err.h>
59 #include <sys/sysmacros.h>
60 #include <sys/compress.h>
61 #include <sys/sunddi.h>
62 #include <sys/systeminfo.h>
63 #include <sys/fm/util.h>
64 #include <sys/fm/protocol.h>
65 #include <sys/kstat.h>
66 #include <sys/zfs_context.h>
67 #ifdef _KERNEL
68 #include <sys/atomic.h>
69 #include <sys/condvar.h>
70 #include <sys/cpuvar.h>
71 #include <sys/systm.h>
72 #include <sys/dumphdr.h>
73 #include <sys/cpuvar.h>
74 #include <sys/console.h>
75 #include <sys/kobj.h>
76 #include <sys/time.h>
77 #include <sys/zfs_ioctl.h>
78
79 int zfs_zevent_len_max = 0;
80 int zfs_zevent_cols = 80;
81 int zfs_zevent_console = 0;
82
83 static int zevent_len_cur = 0;
84 static int zevent_waiters = 0;
85 static int zevent_flags = 0;
86
87 static kmutex_t zevent_lock;
88 static list_t zevent_list;
89 static kcondvar_t zevent_cv;
90 #endif /* _KERNEL */
91
92 extern void fastreboot_disable_highpil(void);
93
94 /*
95 * Common fault management kstats to record event generation failures
96 */
97
98 struct erpt_kstat {
99 kstat_named_t erpt_dropped; /* num erpts dropped on post */
100 kstat_named_t erpt_set_failed; /* num erpt set failures */
101 kstat_named_t fmri_set_failed; /* num fmri set failures */
102 kstat_named_t payload_set_failed; /* num payload set failures */
103 };
104
105 static struct erpt_kstat erpt_kstat_data = {
106 { "erpt-dropped", KSTAT_DATA_UINT64 },
107 { "erpt-set-failed", KSTAT_DATA_UINT64 },
108 { "fmri-set-failed", KSTAT_DATA_UINT64 },
109 { "payload-set-failed", KSTAT_DATA_UINT64 }
110 };
111
112 kstat_t *fm_ksp;
113
114 #ifdef _KERNEL
115
116 /*
117 * Formatting utility function for fm_nvprintr. We attempt to wrap chunks of
118 * output so they aren't split across console lines, and return the end column.
119 */
120 /*PRINTFLIKE4*/
121 static int
122 fm_printf(int depth, int c, int cols, const char *format, ...)
123 {
124 va_list ap;
125 int width;
126 char c1;
127
128 va_start(ap, format);
129 width = vsnprintf(&c1, sizeof (c1), format, ap);
130 va_end(ap);
131
132 if (c + width >= cols) {
133 console_printf("\n");
134 c = 0;
135 if (format[0] != ' ' && depth > 0) {
136 console_printf(" ");
137 c++;
138 }
139 }
140
141 va_start(ap, format);
142 console_vprintf(format, ap);
143 va_end(ap);
144
145 return ((c + width) % cols);
146 }
147
148 /*
149 * Recursively print a nvlist in the specified column width and return the
150 * column we end up in. This function is called recursively by fm_nvprint(),
151 * below. We generically format the entire nvpair using hexadecimal
152 * integers and strings, and elide any integer arrays. Arrays are basically
153 * used for cache dumps right now, so we suppress them so as not to overwhelm
154 * the amount of console output we produce at panic time. This can be further
155 * enhanced as FMA technology grows based upon the needs of consumers. All
156 * FMA telemetry is logged using the dump device transport, so the console
157 * output serves only as a fallback in case this procedure is unsuccessful.
158 */
159 static int
160 fm_nvprintr(nvlist_t *nvl, int d, int c, int cols)
161 {
162 nvpair_t *nvp;
163
164 for (nvp = nvlist_next_nvpair(nvl, NULL);
165 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) {
166
167 data_type_t type = nvpair_type(nvp);
168 const char *name = nvpair_name(nvp);
169
170 boolean_t b;
171 uint8_t i8;
172 uint16_t i16;
173 uint32_t i32;
174 uint64_t i64;
175 char *str;
176 nvlist_t *cnv;
177
178 if (strcmp(name, FM_CLASS) == 0)
179 continue; /* already printed by caller */
180
181 c = fm_printf(d, c, cols, " %s=", name);
182
183 switch (type) {
184 case DATA_TYPE_BOOLEAN:
185 c = fm_printf(d + 1, c, cols, " 1");
186 break;
187
188 case DATA_TYPE_BOOLEAN_VALUE:
189 (void) nvpair_value_boolean_value(nvp, &b);
190 c = fm_printf(d + 1, c, cols, b ? "1" : "0");
191 break;
192
193 case DATA_TYPE_BYTE:
194 (void) nvpair_value_byte(nvp, &i8);
195 c = fm_printf(d + 1, c, cols, "0x%x", i8);
196 break;
197
198 case DATA_TYPE_INT8:
199 (void) nvpair_value_int8(nvp, (void *)&i8);
200 c = fm_printf(d + 1, c, cols, "0x%x", i8);
201 break;
202
203 case DATA_TYPE_UINT8:
204 (void) nvpair_value_uint8(nvp, &i8);
205 c = fm_printf(d + 1, c, cols, "0x%x", i8);
206 break;
207
208 case DATA_TYPE_INT16:
209 (void) nvpair_value_int16(nvp, (void *)&i16);
210 c = fm_printf(d + 1, c, cols, "0x%x", i16);
211 break;
212
213 case DATA_TYPE_UINT16:
214 (void) nvpair_value_uint16(nvp, &i16);
215 c = fm_printf(d + 1, c, cols, "0x%x", i16);
216 break;
217
218 case DATA_TYPE_INT32:
219 (void) nvpair_value_int32(nvp, (void *)&i32);
220 c = fm_printf(d + 1, c, cols, "0x%x", i32);
221 break;
222
223 case DATA_TYPE_UINT32:
224 (void) nvpair_value_uint32(nvp, &i32);
225 c = fm_printf(d + 1, c, cols, "0x%x", i32);
226 break;
227
228 case DATA_TYPE_INT64:
229 (void) nvpair_value_int64(nvp, (void *)&i64);
230 c = fm_printf(d + 1, c, cols, "0x%llx",
231 (u_longlong_t)i64);
232 break;
233
234 case DATA_TYPE_UINT64:
235 (void) nvpair_value_uint64(nvp, &i64);
236 c = fm_printf(d + 1, c, cols, "0x%llx",
237 (u_longlong_t)i64);
238 break;
239
240 case DATA_TYPE_HRTIME:
241 (void) nvpair_value_hrtime(nvp, (void *)&i64);
242 c = fm_printf(d + 1, c, cols, "0x%llx",
243 (u_longlong_t)i64);
244 break;
245
246 case DATA_TYPE_STRING:
247 (void) nvpair_value_string(nvp, &str);
248 c = fm_printf(d + 1, c, cols, "\"%s\"",
249 str ? str : "<NULL>");
250 break;
251
252 case DATA_TYPE_NVLIST:
253 c = fm_printf(d + 1, c, cols, "[");
254 (void) nvpair_value_nvlist(nvp, &cnv);
255 c = fm_nvprintr(cnv, d + 1, c, cols);
256 c = fm_printf(d + 1, c, cols, " ]");
257 break;
258
259 case DATA_TYPE_NVLIST_ARRAY: {
260 nvlist_t **val;
261 uint_t i, nelem;
262
263 c = fm_printf(d + 1, c, cols, "[");
264 (void) nvpair_value_nvlist_array(nvp, &val, &nelem);
265 for (i = 0; i < nelem; i++) {
266 c = fm_nvprintr(val[i], d + 1, c, cols);
267 }
268 c = fm_printf(d + 1, c, cols, " ]");
269 }
270 break;
271
272 case DATA_TYPE_INT8_ARRAY: {
273 int8_t *val;
274 uint_t i, nelem;
275
276 c = fm_printf(d + 1, c, cols, "[ ");
277 (void) nvpair_value_int8_array(nvp, &val, &nelem);
278 for (i = 0; i < nelem; i++)
279 c = fm_printf(d + 1, c, cols, "0x%llx ",
280 (u_longlong_t)val[i]);
281
282 c = fm_printf(d + 1, c, cols, "]");
283 break;
284 }
285
286 case DATA_TYPE_UINT8_ARRAY: {
287 uint8_t *val;
288 uint_t i, nelem;
289
290 c = fm_printf(d + 1, c, cols, "[ ");
291 (void) nvpair_value_uint8_array(nvp, &val, &nelem);
292 for (i = 0; i < nelem; i++)
293 c = fm_printf(d + 1, c, cols, "0x%llx ",
294 (u_longlong_t)val[i]);
295
296 c = fm_printf(d + 1, c, cols, "]");
297 break;
298 }
299
300 case DATA_TYPE_INT16_ARRAY: {
301 int16_t *val;
302 uint_t i, nelem;
303
304 c = fm_printf(d + 1, c, cols, "[ ");
305 (void) nvpair_value_int16_array(nvp, &val, &nelem);
306 for (i = 0; i < nelem; i++)
307 c = fm_printf(d + 1, c, cols, "0x%llx ",
308 (u_longlong_t)val[i]);
309
310 c = fm_printf(d + 1, c, cols, "]");
311 break;
312 }
313
314 case DATA_TYPE_UINT16_ARRAY: {
315 uint16_t *val;
316 uint_t i, nelem;
317
318 c = fm_printf(d + 1, c, cols, "[ ");
319 (void) nvpair_value_uint16_array(nvp, &val, &nelem);
320 for (i = 0; i < nelem; i++)
321 c = fm_printf(d + 1, c, cols, "0x%llx ",
322 (u_longlong_t)val[i]);
323
324 c = fm_printf(d + 1, c, cols, "]");
325 break;
326 }
327
328 case DATA_TYPE_INT32_ARRAY: {
329 int32_t *val;
330 uint_t i, nelem;
331
332 c = fm_printf(d + 1, c, cols, "[ ");
333 (void) nvpair_value_int32_array(nvp, &val, &nelem);
334 for (i = 0; i < nelem; i++)
335 c = fm_printf(d + 1, c, cols, "0x%llx ",
336 (u_longlong_t)val[i]);
337
338 c = fm_printf(d + 1, c, cols, "]");
339 break;
340 }
341
342 case DATA_TYPE_UINT32_ARRAY: {
343 uint32_t *val;
344 uint_t i, nelem;
345
346 c = fm_printf(d + 1, c, cols, "[ ");
347 (void) nvpair_value_uint32_array(nvp, &val, &nelem);
348 for (i = 0; i < nelem; i++)
349 c = fm_printf(d + 1, c, cols, "0x%llx ",
350 (u_longlong_t)val[i]);
351
352 c = fm_printf(d + 1, c, cols, "]");
353 break;
354 }
355
356 case DATA_TYPE_INT64_ARRAY: {
357 int64_t *val;
358 uint_t i, nelem;
359
360 c = fm_printf(d + 1, c, cols, "[ ");
361 (void) nvpair_value_int64_array(nvp, &val, &nelem);
362 for (i = 0; i < nelem; i++)
363 c = fm_printf(d + 1, c, cols, "0x%llx ",
364 (u_longlong_t)val[i]);
365
366 c = fm_printf(d + 1, c, cols, "]");
367 break;
368 }
369
370 case DATA_TYPE_UINT64_ARRAY: {
371 uint64_t *val;
372 uint_t i, nelem;
373
374 c = fm_printf(d + 1, c, cols, "[ ");
375 (void) nvpair_value_uint64_array(nvp, &val, &nelem);
376 for (i = 0; i < nelem; i++)
377 c = fm_printf(d + 1, c, cols, "0x%llx ",
378 (u_longlong_t)val[i]);
379
380 c = fm_printf(d + 1, c, cols, "]");
381 break;
382 }
383
384 case DATA_TYPE_STRING_ARRAY:
385 case DATA_TYPE_BOOLEAN_ARRAY:
386 case DATA_TYPE_BYTE_ARRAY:
387 c = fm_printf(d + 1, c, cols, "[...]");
388 break;
389
390 case DATA_TYPE_UNKNOWN:
391 c = fm_printf(d + 1, c, cols, "<unknown>");
392 break;
393 }
394 }
395
396 return (c);
397 }
398
399 void
400 fm_nvprint(nvlist_t *nvl)
401 {
402 char *class;
403 int c = 0;
404
405 console_printf("\n");
406
407 if (nvlist_lookup_string(nvl, FM_CLASS, &class) == 0)
408 c = fm_printf(0, c, zfs_zevent_cols, "%s", class);
409
410 if (fm_nvprintr(nvl, 0, c, zfs_zevent_cols) != 0)
411 console_printf("\n");
412
413 console_printf("\n");
414 }
415
416 static zevent_t *
417 zfs_zevent_alloc(void)
418 {
419 zevent_t *ev;
420
421 ev = kmem_zalloc(sizeof(zevent_t), KM_PUSHPAGE);
422 if (ev == NULL)
423 return NULL;
424
425 list_create(&ev->ev_ze_list, sizeof(zfs_zevent_t),
426 offsetof(zfs_zevent_t, ze_node));
427 list_link_init(&ev->ev_node);
428
429 return ev;
430 }
431
432 static void
433 zfs_zevent_free(zevent_t *ev)
434 {
435 /* Run provided cleanup callback */
436 ev->ev_cb(ev->ev_nvl, ev->ev_detector);
437
438 list_destroy(&ev->ev_ze_list);
439 kmem_free(ev, sizeof(zevent_t));
440 }
441
442 static void
443 zfs_zevent_drain(zevent_t *ev)
444 {
445 zfs_zevent_t *ze;
446
447 ASSERT(MUTEX_HELD(&zevent_lock));
448 list_remove(&zevent_list, ev);
449
450 /* Remove references to this event in all private file data */
451 while ((ze = list_head(&ev->ev_ze_list)) != NULL) {
452 list_remove(&ev->ev_ze_list, ze);
453 ze->ze_zevent = NULL;
454 ze->ze_dropped++;
455 }
456
457 zfs_zevent_free(ev);
458 }
459
460 void
461 zfs_zevent_drain_all(int *count)
462 {
463 zevent_t *ev;
464
465 mutex_enter(&zevent_lock);
466 while ((ev = list_head(&zevent_list)) != NULL)
467 zfs_zevent_drain(ev);
468
469 *count = zevent_len_cur;
470 zevent_len_cur = 0;
471 mutex_exit(&zevent_lock);
472 }
473
474 /*
475 * New zevents are inserted at the head. If the maximum queue
476 * length is exceeded a zevent will be drained from the tail.
477 * As part of this any user space processes which currently have
478 * a reference to this zevent_t in their private data will have
479 * this reference set to NULL.
480 */
481 static void
482 zfs_zevent_insert(zevent_t *ev)
483 {
484 ASSERT(MUTEX_HELD(&zevent_lock));
485 list_insert_head(&zevent_list, ev);
486
487 if (zevent_len_cur >= zfs_zevent_len_max)
488 zfs_zevent_drain(list_tail(&zevent_list));
489 else
490 zevent_len_cur++;
491 }
492
493 /*
494 * Post a zevent
495 */
496 void
497 zfs_zevent_post(nvlist_t *nvl, nvlist_t *detector, zevent_cb_t *cb)
498 {
499 int64_t tv_array[2];
500 timestruc_t tv;
501 size_t nvl_size = 0;
502 zevent_t *ev;
503
504 gethrestime(&tv);
505 tv_array[0] = tv.tv_sec;
506 tv_array[1] = tv.tv_nsec;
507 if (nvlist_add_int64_array(nvl, FM_EREPORT_TIME, tv_array, 2)) {
508 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
509 return;
510 }
511
512 (void) nvlist_size(nvl, &nvl_size, NV_ENCODE_NATIVE);
513 if (nvl_size > ERPT_DATA_SZ || nvl_size == 0) {
514 atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
515 return;
516 }
517
518 if (zfs_zevent_console)
519 fm_nvprint(nvl);
520
521 ev = zfs_zevent_alloc();
522 if (ev == NULL) {
523 atomic_add_64(&erpt_kstat_data.erpt_dropped.value.ui64, 1);
524 return;
525 }
526
527 ev->ev_nvl = nvl;
528 ev->ev_detector = detector;
529 ev->ev_cb = cb;
530
531 mutex_enter(&zevent_lock);
532 zfs_zevent_insert(ev);
533 cv_broadcast(&zevent_cv);
534 mutex_exit(&zevent_lock);
535 }
536
537 static int
538 zfs_zevent_minor_to_state(minor_t minor, zfs_zevent_t **ze)
539 {
540 *ze = zfsdev_get_state(minor, ZST_ZEVENT);
541 if (*ze == NULL)
542 return (EBADF);
543
544 return (0);
545 }
546
547 int
548 zfs_zevent_fd_hold(int fd, minor_t *minorp, zfs_zevent_t **ze)
549 {
550 file_t *fp;
551 int error;
552
553 fp = getf(fd);
554 if (fp == NULL)
555 return (EBADF);
556
557 *minorp = zfsdev_getminor(fp->f_file);
558 error = zfs_zevent_minor_to_state(*minorp, ze);
559
560 if (error)
561 zfs_zevent_fd_rele(fd);
562
563 return (error);
564 }
565
566 void
567 zfs_zevent_fd_rele(int fd)
568 {
569 releasef(fd);
570 }
571
572 /*
573 * Get the next zevent in the stream and place a copy in 'event'. This
574 * may fail with ENOMEM if the encoded nvlist size exceeds the passed
575 * 'event_size'. In this case the stream pointer is not advanced and
576 * and 'event_size' is set to the minimum required buffer size.
577 */
578 int
579 zfs_zevent_next(zfs_zevent_t *ze, nvlist_t **event, uint64_t *event_size,
580 uint64_t *dropped)
581 {
582 zevent_t *ev;
583 size_t size;
584 int error = 0;
585
586 mutex_enter(&zevent_lock);
587 if (ze->ze_zevent == NULL) {
588 /* New stream start at the beginning/tail */
589 ev = list_tail(&zevent_list);
590 if (ev == NULL) {
591 error = ENOENT;
592 goto out;
593 }
594 } else {
595 /* Existing stream continue with the next element and remove
596 * ourselves from the wait queue for the previous element */
597 ev = list_prev(&zevent_list, ze->ze_zevent);
598 if (ev == NULL) {
599 error = ENOENT;
600 goto out;
601 }
602 }
603
604 VERIFY(nvlist_size(ev->ev_nvl, &size, NV_ENCODE_NATIVE) == 0);
605 if (size > *event_size) {
606 *event_size = size;
607 error = ENOMEM;
608 goto out;
609 }
610
611 if (ze->ze_zevent)
612 list_remove(&ze->ze_zevent->ev_ze_list, ze);
613
614 ze->ze_zevent = ev;
615 list_insert_head(&ev->ev_ze_list, ze);
616 nvlist_dup(ev->ev_nvl, event, KM_SLEEP);
617 *dropped = ze->ze_dropped;
618 ze->ze_dropped = 0;
619 out:
620 mutex_exit(&zevent_lock);
621
622 return error;
623 }
624
625 int
626 zfs_zevent_wait(zfs_zevent_t *ze)
627 {
628 int error = 0;
629
630 mutex_enter(&zevent_lock);
631
632 if (zevent_flags & ZEVENT_SHUTDOWN) {
633 error = ESHUTDOWN;
634 goto out;
635 }
636
637 zevent_waiters++;
638 cv_wait_interruptible(&zevent_cv, &zevent_lock);
639 if (issig(JUSTLOOKING))
640 error = EINTR;
641
642 zevent_waiters--;
643 out:
644 mutex_exit(&zevent_lock);
645
646 return error;
647 }
648
649 void
650 zfs_zevent_init(zfs_zevent_t **zep)
651 {
652 zfs_zevent_t *ze;
653
654 ze = *zep = kmem_zalloc(sizeof (zfs_zevent_t), KM_SLEEP);
655 list_link_init(&ze->ze_node);
656 }
657
658 void
659 zfs_zevent_destroy(zfs_zevent_t *ze)
660 {
661 mutex_enter(&zevent_lock);
662 if (ze->ze_zevent)
663 list_remove(&ze->ze_zevent->ev_ze_list, ze);
664 mutex_exit(&zevent_lock);
665
666 kmem_free(ze, sizeof (zfs_zevent_t));
667 }
668 #endif /* _KERNEL */
669
670 /*
671 * Wrapppers for FM nvlist allocators
672 */
673 /* ARGSUSED */
674 static void *
675 i_fm_alloc(nv_alloc_t *nva, size_t size)
676 {
677 return (kmem_zalloc(size, KM_PUSHPAGE));
678 }
679
680 /* ARGSUSED */
681 static void
682 i_fm_free(nv_alloc_t *nva, void *buf, size_t size)
683 {
684 kmem_free(buf, size);
685 }
686
687 const nv_alloc_ops_t fm_mem_alloc_ops = {
688 NULL,
689 NULL,
690 i_fm_alloc,
691 i_fm_free,
692 NULL
693 };
694
695 /*
696 * Create and initialize a new nv_alloc_t for a fixed buffer, buf. A pointer
697 * to the newly allocated nv_alloc_t structure is returned upon success or NULL
698 * is returned to indicate that the nv_alloc structure could not be created.
699 */
700 nv_alloc_t *
701 fm_nva_xcreate(char *buf, size_t bufsz)
702 {
703 nv_alloc_t *nvhdl = kmem_zalloc(sizeof (nv_alloc_t), KM_SLEEP);
704
705 if (bufsz == 0 || nv_alloc_init(nvhdl, nv_fixed_ops, buf, bufsz) != 0) {
706 kmem_free(nvhdl, sizeof (nv_alloc_t));
707 return (NULL);
708 }
709
710 return (nvhdl);
711 }
712
713 /*
714 * Destroy a previously allocated nv_alloc structure. The fixed buffer
715 * associated with nva must be freed by the caller.
716 */
717 void
718 fm_nva_xdestroy(nv_alloc_t *nva)
719 {
720 nv_alloc_fini(nva);
721 kmem_free(nva, sizeof (nv_alloc_t));
722 }
723
724 /*
725 * Create a new nv list. A pointer to a new nv list structure is returned
726 * upon success or NULL is returned to indicate that the structure could
727 * not be created. The newly created nv list is created and managed by the
728 * operations installed in nva. If nva is NULL, the default FMA nva
729 * operations are installed and used.
730 *
731 * When called from the kernel and nva == NULL, this function must be called
732 * from passive kernel context with no locks held that can prevent a
733 * sleeping memory allocation from occurring. Otherwise, this function may
734 * be called from other kernel contexts as long a valid nva created via
735 * fm_nva_create() is supplied.
736 */
737 nvlist_t *
738 fm_nvlist_create(nv_alloc_t *nva)
739 {
740 int hdl_alloced = 0;
741 nvlist_t *nvl;
742 nv_alloc_t *nvhdl;
743
744 if (nva == NULL) {
745 nvhdl = kmem_zalloc(sizeof (nv_alloc_t), KM_PUSHPAGE);
746
747 if (nv_alloc_init(nvhdl, &fm_mem_alloc_ops, NULL, 0) != 0) {
748 kmem_free(nvhdl, sizeof (nv_alloc_t));
749 return (NULL);
750 }
751 hdl_alloced = 1;
752 } else {
753 nvhdl = nva;
754 }
755
756 if (nvlist_xalloc(&nvl, NV_UNIQUE_NAME, nvhdl) != 0) {
757 if (hdl_alloced) {
758 nv_alloc_fini(nvhdl);
759 kmem_free(nvhdl, sizeof (nv_alloc_t));
760 }
761 return (NULL);
762 }
763
764 return (nvl);
765 }
766
767 /*
768 * Destroy a previously allocated nvlist structure. flag indicates whether
769 * or not the associated nva structure should be freed (FM_NVA_FREE) or
770 * retained (FM_NVA_RETAIN). Retaining the nv alloc structure allows
771 * it to be re-used for future nvlist creation operations.
772 */
773 void
774 fm_nvlist_destroy(nvlist_t *nvl, int flag)
775 {
776 nv_alloc_t *nva = nvlist_lookup_nv_alloc(nvl);
777
778 nvlist_free(nvl);
779
780 if (nva != NULL) {
781 if (flag == FM_NVA_FREE)
782 fm_nva_xdestroy(nva);
783 }
784 }
785
786 int
787 i_fm_payload_set(nvlist_t *payload, const char *name, va_list ap)
788 {
789 int nelem, ret = 0;
790 data_type_t type;
791
792 while (ret == 0 && name != NULL) {
793 type = va_arg(ap, data_type_t);
794 switch (type) {
795 case DATA_TYPE_BYTE:
796 ret = nvlist_add_byte(payload, name,
797 va_arg(ap, uint_t));
798 break;
799 case DATA_TYPE_BYTE_ARRAY:
800 nelem = va_arg(ap, int);
801 ret = nvlist_add_byte_array(payload, name,
802 va_arg(ap, uchar_t *), nelem);
803 break;
804 case DATA_TYPE_BOOLEAN_VALUE:
805 ret = nvlist_add_boolean_value(payload, name,
806 va_arg(ap, boolean_t));
807 break;
808 case DATA_TYPE_BOOLEAN_ARRAY:
809 nelem = va_arg(ap, int);
810 ret = nvlist_add_boolean_array(payload, name,
811 va_arg(ap, boolean_t *), nelem);
812 break;
813 case DATA_TYPE_INT8:
814 ret = nvlist_add_int8(payload, name,
815 va_arg(ap, int));
816 break;
817 case DATA_TYPE_INT8_ARRAY:
818 nelem = va_arg(ap, int);
819 ret = nvlist_add_int8_array(payload, name,
820 va_arg(ap, int8_t *), nelem);
821 break;
822 case DATA_TYPE_UINT8:
823 ret = nvlist_add_uint8(payload, name,
824 va_arg(ap, uint_t));
825 break;
826 case DATA_TYPE_UINT8_ARRAY:
827 nelem = va_arg(ap, int);
828 ret = nvlist_add_uint8_array(payload, name,
829 va_arg(ap, uint8_t *), nelem);
830 break;
831 case DATA_TYPE_INT16:
832 ret = nvlist_add_int16(payload, name,
833 va_arg(ap, int));
834 break;
835 case DATA_TYPE_INT16_ARRAY:
836 nelem = va_arg(ap, int);
837 ret = nvlist_add_int16_array(payload, name,
838 va_arg(ap, int16_t *), nelem);
839 break;
840 case DATA_TYPE_UINT16:
841 ret = nvlist_add_uint16(payload, name,
842 va_arg(ap, uint_t));
843 break;
844 case DATA_TYPE_UINT16_ARRAY:
845 nelem = va_arg(ap, int);
846 ret = nvlist_add_uint16_array(payload, name,
847 va_arg(ap, uint16_t *), nelem);
848 break;
849 case DATA_TYPE_INT32:
850 ret = nvlist_add_int32(payload, name,
851 va_arg(ap, int32_t));
852 break;
853 case DATA_TYPE_INT32_ARRAY:
854 nelem = va_arg(ap, int);
855 ret = nvlist_add_int32_array(payload, name,
856 va_arg(ap, int32_t *), nelem);
857 break;
858 case DATA_TYPE_UINT32:
859 ret = nvlist_add_uint32(payload, name,
860 va_arg(ap, uint32_t));
861 break;
862 case DATA_TYPE_UINT32_ARRAY:
863 nelem = va_arg(ap, int);
864 ret = nvlist_add_uint32_array(payload, name,
865 va_arg(ap, uint32_t *), nelem);
866 break;
867 case DATA_TYPE_INT64:
868 ret = nvlist_add_int64(payload, name,
869 va_arg(ap, int64_t));
870 break;
871 case DATA_TYPE_INT64_ARRAY:
872 nelem = va_arg(ap, int);
873 ret = nvlist_add_int64_array(payload, name,
874 va_arg(ap, int64_t *), nelem);
875 break;
876 case DATA_TYPE_UINT64:
877 ret = nvlist_add_uint64(payload, name,
878 va_arg(ap, uint64_t));
879 break;
880 case DATA_TYPE_UINT64_ARRAY:
881 nelem = va_arg(ap, int);
882 ret = nvlist_add_uint64_array(payload, name,
883 va_arg(ap, uint64_t *), nelem);
884 break;
885 case DATA_TYPE_STRING:
886 ret = nvlist_add_string(payload, name,
887 va_arg(ap, char *));
888 break;
889 case DATA_TYPE_STRING_ARRAY:
890 nelem = va_arg(ap, int);
891 ret = nvlist_add_string_array(payload, name,
892 va_arg(ap, char **), nelem);
893 break;
894 case DATA_TYPE_NVLIST:
895 ret = nvlist_add_nvlist(payload, name,
896 va_arg(ap, nvlist_t *));
897 break;
898 case DATA_TYPE_NVLIST_ARRAY:
899 nelem = va_arg(ap, int);
900 ret = nvlist_add_nvlist_array(payload, name,
901 va_arg(ap, nvlist_t **), nelem);
902 break;
903 default:
904 ret = EINVAL;
905 }
906
907 name = va_arg(ap, char *);
908 }
909 return (ret);
910 }
911
912 void
913 fm_payload_set(nvlist_t *payload, ...)
914 {
915 int ret;
916 const char *name;
917 va_list ap;
918
919 va_start(ap, payload);
920 name = va_arg(ap, char *);
921 ret = i_fm_payload_set(payload, name, ap);
922 va_end(ap);
923
924 if (ret)
925 atomic_add_64(
926 &erpt_kstat_data.payload_set_failed.value.ui64, 1);
927 }
928
929 /*
930 * Set-up and validate the members of an ereport event according to:
931 *
932 * Member name Type Value
933 * ====================================================
934 * class string ereport
935 * version uint8_t 0
936 * ena uint64_t <ena>
937 * detector nvlist_t <detector>
938 * ereport-payload nvlist_t <var args>
939 *
940 * We don't actually add a 'version' member to the payload. Really,
941 * the version quoted to us by our caller is that of the category 1
942 * "ereport" event class (and we require FM_EREPORT_VERS0) but
943 * the payload version of the actual leaf class event under construction
944 * may be something else. Callers should supply a version in the varargs,
945 * or (better) we could take two version arguments - one for the
946 * ereport category 1 classification (expect FM_EREPORT_VERS0) and one
947 * for the leaf class.
948 */
949 void
950 fm_ereport_set(nvlist_t *ereport, int version, const char *erpt_class,
951 uint64_t ena, const nvlist_t *detector, ...)
952 {
953 char ereport_class[FM_MAX_CLASS];
954 const char *name;
955 va_list ap;
956 int ret;
957
958 if (version != FM_EREPORT_VERS0) {
959 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
960 return;
961 }
962
963 (void) snprintf(ereport_class, FM_MAX_CLASS, "%s.%s",
964 FM_EREPORT_CLASS, erpt_class);
965 if (nvlist_add_string(ereport, FM_CLASS, ereport_class) != 0) {
966 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
967 return;
968 }
969
970 if (nvlist_add_uint64(ereport, FM_EREPORT_ENA, ena)) {
971 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
972 }
973
974 if (nvlist_add_nvlist(ereport, FM_EREPORT_DETECTOR,
975 (nvlist_t *)detector) != 0) {
976 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
977 }
978
979 va_start(ap, detector);
980 name = va_arg(ap, const char *);
981 ret = i_fm_payload_set(ereport, name, ap);
982 va_end(ap);
983
984 if (ret)
985 atomic_add_64(&erpt_kstat_data.erpt_set_failed.value.ui64, 1);
986 }
987
988 /*
989 * Set-up and validate the members of an hc fmri according to;
990 *
991 * Member name Type Value
992 * ===================================================
993 * version uint8_t 0
994 * auth nvlist_t <auth>
995 * hc-name string <name>
996 * hc-id string <id>
997 *
998 * Note that auth and hc-id are optional members.
999 */
1000
1001 #define HC_MAXPAIRS 20
1002 #define HC_MAXNAMELEN 50
1003
1004 static int
1005 fm_fmri_hc_set_common(nvlist_t *fmri, int version, const nvlist_t *auth)
1006 {
1007 if (version != FM_HC_SCHEME_VERSION) {
1008 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1009 return (0);
1010 }
1011
1012 if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0 ||
1013 nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC) != 0) {
1014 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1015 return (0);
1016 }
1017
1018 if (auth != NULL && nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
1019 (nvlist_t *)auth) != 0) {
1020 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1021 return (0);
1022 }
1023
1024 return (1);
1025 }
1026
1027 void
1028 fm_fmri_hc_set(nvlist_t *fmri, int version, const nvlist_t *auth,
1029 nvlist_t *snvl, int npairs, ...)
1030 {
1031 nv_alloc_t *nva = nvlist_lookup_nv_alloc(fmri);
1032 nvlist_t *pairs[HC_MAXPAIRS];
1033 va_list ap;
1034 int i;
1035
1036 if (!fm_fmri_hc_set_common(fmri, version, auth))
1037 return;
1038
1039 npairs = MIN(npairs, HC_MAXPAIRS);
1040
1041 va_start(ap, npairs);
1042 for (i = 0; i < npairs; i++) {
1043 const char *name = va_arg(ap, const char *);
1044 uint32_t id = va_arg(ap, uint32_t);
1045 char idstr[11];
1046
1047 (void) snprintf(idstr, sizeof (idstr), "%u", id);
1048
1049 pairs[i] = fm_nvlist_create(nva);
1050 if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
1051 nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
1052 atomic_add_64(
1053 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1054 }
1055 }
1056 va_end(ap);
1057
1058 if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs, npairs) != 0)
1059 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1060
1061 for (i = 0; i < npairs; i++)
1062 fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
1063
1064 if (snvl != NULL) {
1065 if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
1066 atomic_add_64(
1067 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1068 }
1069 }
1070 }
1071
1072 void
1073 fm_fmri_hc_create(nvlist_t *fmri, int version, const nvlist_t *auth,
1074 nvlist_t *snvl, nvlist_t *bboard, int npairs, ...)
1075 {
1076 nv_alloc_t *nva = nvlist_lookup_nv_alloc(fmri);
1077 nvlist_t *pairs[HC_MAXPAIRS];
1078 nvlist_t **hcl;
1079 uint_t n;
1080 int i, j;
1081 va_list ap;
1082 char *hcname, *hcid;
1083
1084 if (!fm_fmri_hc_set_common(fmri, version, auth))
1085 return;
1086
1087 /*
1088 * copy the bboard nvpairs to the pairs array
1089 */
1090 if (nvlist_lookup_nvlist_array(bboard, FM_FMRI_HC_LIST, &hcl, &n)
1091 != 0) {
1092 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1093 return;
1094 }
1095
1096 for (i = 0; i < n; i++) {
1097 if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME,
1098 &hcname) != 0) {
1099 atomic_add_64(
1100 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1101 return;
1102 }
1103 if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &hcid) != 0) {
1104 atomic_add_64(
1105 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1106 return;
1107 }
1108
1109 pairs[i] = fm_nvlist_create(nva);
1110 if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, hcname) != 0 ||
1111 nvlist_add_string(pairs[i], FM_FMRI_HC_ID, hcid) != 0) {
1112 for (j = 0; j <= i; j++) {
1113 if (pairs[j] != NULL)
1114 fm_nvlist_destroy(pairs[j],
1115 FM_NVA_RETAIN);
1116 }
1117 atomic_add_64(
1118 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1119 return;
1120 }
1121 }
1122
1123 /*
1124 * create the pairs from passed in pairs
1125 */
1126 npairs = MIN(npairs, HC_MAXPAIRS);
1127
1128 va_start(ap, npairs);
1129 for (i = n; i < npairs + n; i++) {
1130 const char *name = va_arg(ap, const char *);
1131 uint32_t id = va_arg(ap, uint32_t);
1132 char idstr[11];
1133 (void) snprintf(idstr, sizeof (idstr), "%u", id);
1134 pairs[i] = fm_nvlist_create(nva);
1135 if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 ||
1136 nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
1137 for (j = 0; j <= i; j++) {
1138 if (pairs[j] != NULL)
1139 fm_nvlist_destroy(pairs[j],
1140 FM_NVA_RETAIN);
1141 }
1142 atomic_add_64(
1143 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1144 return;
1145 }
1146 }
1147 va_end(ap);
1148
1149 /*
1150 * Create the fmri hc list
1151 */
1152 if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs,
1153 npairs + n) != 0) {
1154 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1155 return;
1156 }
1157
1158 for (i = 0; i < npairs + n; i++) {
1159 fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
1160 }
1161
1162 if (snvl != NULL) {
1163 if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
1164 atomic_add_64(
1165 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1166 return;
1167 }
1168 }
1169 }
1170
1171 /*
1172 * Set-up and validate the members of an dev fmri according to:
1173 *
1174 * Member name Type Value
1175 * ====================================================
1176 * version uint8_t 0
1177 * auth nvlist_t <auth>
1178 * devpath string <devpath>
1179 * [devid] string <devid>
1180 * [target-port-l0id] string <target-port-lun0-id>
1181 *
1182 * Note that auth and devid are optional members.
1183 */
1184 void
1185 fm_fmri_dev_set(nvlist_t *fmri_dev, int version, const nvlist_t *auth,
1186 const char *devpath, const char *devid, const char *tpl0)
1187 {
1188 int err = 0;
1189
1190 if (version != DEV_SCHEME_VERSION0) {
1191 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1192 return;
1193 }
1194
1195 err |= nvlist_add_uint8(fmri_dev, FM_VERSION, version);
1196 err |= nvlist_add_string(fmri_dev, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);
1197
1198 if (auth != NULL) {
1199 err |= nvlist_add_nvlist(fmri_dev, FM_FMRI_AUTHORITY,
1200 (nvlist_t *)auth);
1201 }
1202
1203 err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_PATH, devpath);
1204
1205 if (devid != NULL)
1206 err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_ID, devid);
1207
1208 if (tpl0 != NULL)
1209 err |= nvlist_add_string(fmri_dev, FM_FMRI_DEV_TGTPTLUN0, tpl0);
1210
1211 if (err)
1212 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1213
1214 }
1215
1216 /*
1217 * Set-up and validate the members of an cpu fmri according to:
1218 *
1219 * Member name Type Value
1220 * ====================================================
1221 * version uint8_t 0
1222 * auth nvlist_t <auth>
1223 * cpuid uint32_t <cpu_id>
1224 * cpumask uint8_t <cpu_mask>
1225 * serial uint64_t <serial_id>
1226 *
1227 * Note that auth, cpumask, serial are optional members.
1228 *
1229 */
1230 void
1231 fm_fmri_cpu_set(nvlist_t *fmri_cpu, int version, const nvlist_t *auth,
1232 uint32_t cpu_id, uint8_t *cpu_maskp, const char *serial_idp)
1233 {
1234 uint64_t *failedp = &erpt_kstat_data.fmri_set_failed.value.ui64;
1235
1236 if (version < CPU_SCHEME_VERSION1) {
1237 atomic_add_64(failedp, 1);
1238 return;
1239 }
1240
1241 if (nvlist_add_uint8(fmri_cpu, FM_VERSION, version) != 0) {
1242 atomic_add_64(failedp, 1);
1243 return;
1244 }
1245
1246 if (nvlist_add_string(fmri_cpu, FM_FMRI_SCHEME,
1247 FM_FMRI_SCHEME_CPU) != 0) {
1248 atomic_add_64(failedp, 1);
1249 return;
1250 }
1251
1252 if (auth != NULL && nvlist_add_nvlist(fmri_cpu, FM_FMRI_AUTHORITY,
1253 (nvlist_t *)auth) != 0)
1254 atomic_add_64(failedp, 1);
1255
1256 if (nvlist_add_uint32(fmri_cpu, FM_FMRI_CPU_ID, cpu_id) != 0)
1257 atomic_add_64(failedp, 1);
1258
1259 if (cpu_maskp != NULL && nvlist_add_uint8(fmri_cpu, FM_FMRI_CPU_MASK,
1260 *cpu_maskp) != 0)
1261 atomic_add_64(failedp, 1);
1262
1263 if (serial_idp == NULL || nvlist_add_string(fmri_cpu,
1264 FM_FMRI_CPU_SERIAL_ID, (char *)serial_idp) != 0)
1265 atomic_add_64(failedp, 1);
1266 }
1267
1268 /*
1269 * Set-up and validate the members of a mem according to:
1270 *
1271 * Member name Type Value
1272 * ====================================================
1273 * version uint8_t 0
1274 * auth nvlist_t <auth> [optional]
1275 * unum string <unum>
1276 * serial string <serial> [optional*]
1277 * offset uint64_t <offset> [optional]
1278 *
1279 * * serial is required if offset is present
1280 */
1281 void
1282 fm_fmri_mem_set(nvlist_t *fmri, int version, const nvlist_t *auth,
1283 const char *unum, const char *serial, uint64_t offset)
1284 {
1285 if (version != MEM_SCHEME_VERSION0) {
1286 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1287 return;
1288 }
1289
1290 if (!serial && (offset != (uint64_t)-1)) {
1291 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1292 return;
1293 }
1294
1295 if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
1296 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1297 return;
1298 }
1299
1300 if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_MEM) != 0) {
1301 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1302 return;
1303 }
1304
1305 if (auth != NULL) {
1306 if (nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
1307 (nvlist_t *)auth) != 0) {
1308 atomic_add_64(
1309 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1310 }
1311 }
1312
1313 if (nvlist_add_string(fmri, FM_FMRI_MEM_UNUM, unum) != 0) {
1314 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1315 }
1316
1317 if (serial != NULL) {
1318 if (nvlist_add_string_array(fmri, FM_FMRI_MEM_SERIAL_ID,
1319 (char **)&serial, 1) != 0) {
1320 atomic_add_64(
1321 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1322 }
1323 if (offset != (uint64_t)-1) {
1324 if (nvlist_add_uint64(fmri, FM_FMRI_MEM_OFFSET,
1325 offset) != 0) {
1326 atomic_add_64(&erpt_kstat_data.
1327 fmri_set_failed.value.ui64, 1);
1328 }
1329 }
1330 }
1331 }
1332
1333 void
1334 fm_fmri_zfs_set(nvlist_t *fmri, int version, uint64_t pool_guid,
1335 uint64_t vdev_guid)
1336 {
1337 if (version != ZFS_SCHEME_VERSION0) {
1338 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1339 return;
1340 }
1341
1342 if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
1343 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1344 return;
1345 }
1346
1347 if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_ZFS) != 0) {
1348 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1349 return;
1350 }
1351
1352 if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_POOL, pool_guid) != 0) {
1353 atomic_add_64(&erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1354 }
1355
1356 if (vdev_guid != 0) {
1357 if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_VDEV, vdev_guid) != 0) {
1358 atomic_add_64(
1359 &erpt_kstat_data.fmri_set_failed.value.ui64, 1);
1360 }
1361 }
1362 }
1363
1364 uint64_t
1365 fm_ena_increment(uint64_t ena)
1366 {
1367 uint64_t new_ena;
1368
1369 switch (ENA_FORMAT(ena)) {
1370 case FM_ENA_FMT1:
1371 new_ena = ena + (1 << ENA_FMT1_GEN_SHFT);
1372 break;
1373 case FM_ENA_FMT2:
1374 new_ena = ena + (1 << ENA_FMT2_GEN_SHFT);
1375 break;
1376 default:
1377 new_ena = 0;
1378 }
1379
1380 return (new_ena);
1381 }
1382
1383 uint64_t
1384 fm_ena_generate_cpu(uint64_t timestamp, processorid_t cpuid, uchar_t format)
1385 {
1386 uint64_t ena = 0;
1387
1388 switch (format) {
1389 case FM_ENA_FMT1:
1390 if (timestamp) {
1391 ena = (uint64_t)((format & ENA_FORMAT_MASK) |
1392 ((cpuid << ENA_FMT1_CPUID_SHFT) &
1393 ENA_FMT1_CPUID_MASK) |
1394 ((timestamp << ENA_FMT1_TIME_SHFT) &
1395 ENA_FMT1_TIME_MASK));
1396 } else {
1397 ena = (uint64_t)((format & ENA_FORMAT_MASK) |
1398 ((cpuid << ENA_FMT1_CPUID_SHFT) &
1399 ENA_FMT1_CPUID_MASK) |
1400 ((gethrtime() << ENA_FMT1_TIME_SHFT) &
1401 ENA_FMT1_TIME_MASK));
1402 }
1403 break;
1404 case FM_ENA_FMT2:
1405 ena = (uint64_t)((format & ENA_FORMAT_MASK) |
1406 ((timestamp << ENA_FMT2_TIME_SHFT) & ENA_FMT2_TIME_MASK));
1407 break;
1408 default:
1409 break;
1410 }
1411
1412 return (ena);
1413 }
1414
1415 uint64_t
1416 fm_ena_generate(uint64_t timestamp, uchar_t format)
1417 {
1418 uint64_t ena;
1419
1420 kpreempt_disable();
1421 ena = fm_ena_generate_cpu(timestamp, getcpuid(), format);
1422 kpreempt_enable();
1423
1424 return (ena);
1425 }
1426
1427 uint64_t
1428 fm_ena_generation_get(uint64_t ena)
1429 {
1430 uint64_t gen;
1431
1432 switch (ENA_FORMAT(ena)) {
1433 case FM_ENA_FMT1:
1434 gen = (ena & ENA_FMT1_GEN_MASK) >> ENA_FMT1_GEN_SHFT;
1435 break;
1436 case FM_ENA_FMT2:
1437 gen = (ena & ENA_FMT2_GEN_MASK) >> ENA_FMT2_GEN_SHFT;
1438 break;
1439 default:
1440 gen = 0;
1441 break;
1442 }
1443
1444 return (gen);
1445 }
1446
1447 uchar_t
1448 fm_ena_format_get(uint64_t ena)
1449 {
1450
1451 return (ENA_FORMAT(ena));
1452 }
1453
1454 uint64_t
1455 fm_ena_id_get(uint64_t ena)
1456 {
1457 uint64_t id;
1458
1459 switch (ENA_FORMAT(ena)) {
1460 case FM_ENA_FMT1:
1461 id = (ena & ENA_FMT1_ID_MASK) >> ENA_FMT1_ID_SHFT;
1462 break;
1463 case FM_ENA_FMT2:
1464 id = (ena & ENA_FMT2_ID_MASK) >> ENA_FMT2_ID_SHFT;
1465 break;
1466 default:
1467 id = 0;
1468 }
1469
1470 return (id);
1471 }
1472
1473 uint64_t
1474 fm_ena_time_get(uint64_t ena)
1475 {
1476 uint64_t time;
1477
1478 switch (ENA_FORMAT(ena)) {
1479 case FM_ENA_FMT1:
1480 time = (ena & ENA_FMT1_TIME_MASK) >> ENA_FMT1_TIME_SHFT;
1481 break;
1482 case FM_ENA_FMT2:
1483 time = (ena & ENA_FMT2_TIME_MASK) >> ENA_FMT2_TIME_SHFT;
1484 break;
1485 default:
1486 time = 0;
1487 }
1488
1489 return (time);
1490 }
1491
1492 #ifdef _KERNEL
1493 void
1494 fm_init(void)
1495 {
1496 zevent_len_cur = 0;
1497 zevent_flags = 0;
1498
1499 if (zfs_zevent_len_max == 0)
1500 zfs_zevent_len_max = ERPT_MAX_ERRS * MAX(max_ncpus, 4);
1501
1502 /* Initialize zevent allocation and generation kstats */
1503 fm_ksp = kstat_create("zfs", 0, "fm", "misc", KSTAT_TYPE_NAMED,
1504 sizeof (struct erpt_kstat) / sizeof (kstat_named_t),
1505 KSTAT_FLAG_VIRTUAL);
1506
1507 if (fm_ksp != NULL) {
1508 fm_ksp->ks_data = &erpt_kstat_data;
1509 kstat_install(fm_ksp);
1510 } else {
1511 cmn_err(CE_NOTE, "failed to create fm/misc kstat\n");
1512 }
1513
1514 mutex_init(&zevent_lock, NULL, MUTEX_DEFAULT, NULL);
1515 list_create(&zevent_list, sizeof(zevent_t), offsetof(zevent_t, ev_node));
1516 cv_init(&zevent_cv, NULL, CV_DEFAULT, NULL);
1517 }
1518
1519 void
1520 fm_fini(void)
1521 {
1522 int count;
1523
1524 zfs_zevent_drain_all(&count);
1525
1526 mutex_enter(&zevent_lock);
1527 cv_broadcast(&zevent_cv);
1528
1529 zevent_flags |= ZEVENT_SHUTDOWN;
1530 while (zevent_waiters > 0) {
1531 mutex_exit(&zevent_lock);
1532 schedule();
1533 mutex_enter(&zevent_lock);
1534 }
1535 mutex_exit(&zevent_lock);
1536
1537 cv_destroy(&zevent_cv);
1538 list_destroy(&zevent_list);
1539 mutex_destroy(&zevent_lock);
1540
1541 if (fm_ksp != NULL) {
1542 kstat_delete(fm_ksp);
1543 fm_ksp = NULL;
1544 }
1545 }
1546
1547 module_param(zfs_zevent_len_max, int, 0644);
1548 MODULE_PARM_DESC(zfs_zevent_len_max, "Max event queue length");
1549
1550 module_param(zfs_zevent_cols, int, 0644);
1551 MODULE_PARM_DESC(zfs_zevent_cols, "Max event column width");
1552
1553 module_param(zfs_zevent_console, int, 0644);
1554 MODULE_PARM_DESC(zfs_zevent_console, "Log events to the console");
1555
1556 #endif /* _KERNEL */
ZFS On Linux mirror for PVE