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.
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.
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]
22 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
26 * Fault Management Architecture (FMA) Resource and Protocol Support
28 * The routines contained herein provide services to support kernel subsystems
29 * in publishing fault management telemetry (see PSARC 2002/412 and 2003/089).
31 * Name-Value Pair Lists
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.
40 * Protocol Event and FMRI Construction
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.
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().
54 #include <sys/types.h>
56 #include <sys/sysevent.h>
57 #include <sys/sysevent_impl.h>
58 #include <sys/nvpair.h>
59 #include <sys/cmn_err.h>
60 #include <sys/cpuvar.h>
61 #include <sys/sysmacros.h>
62 #include <sys/systm.h>
63 #include <sys/ddifm.h>
64 #include <sys/ddifm_impl.h>
66 #include <sys/dumphdr.h>
67 #include <sys/compress.h>
68 #include <sys/cpuvar.h>
69 #include <sys/console.h>
70 #include <sys/panic.h>
72 #include <sys/sunddi.h>
73 #include <sys/systeminfo.h>
74 #include <sys/sysevent/eventdefs.h>
75 #include <sys/fm/util.h>
76 #include <sys/fm/protocol.h>
79 * URL and SUNW-MSG-ID value to display for fm_panic(), defined below. These
80 * values must be kept in sync with the FMA source code in usr/src/cmd/fm.
82 static const char *fm_url
= "http://illumos.org/msg";
83 static const char *fm_msgid
= "SUNOS-8000-0G";
84 static char *volatile fm_panicstr
= NULL
;
86 errorq_t
*ereport_errorq
;
87 void *ereport_dumpbuf
;
88 size_t ereport_dumplen
;
90 static uint_t ereport_chanlen
= ERPT_EVCH_MAX
;
91 static evchan_t
*ereport_chan
= NULL
;
92 static ulong_t ereport_qlen
= 0;
93 static size_t ereport_size
= 0;
94 static int ereport_cols
= 80;
96 extern void fastreboot_disable_highpil(void);
99 * Common fault management kstats to record ereport generation
104 kstat_named_t erpt_dropped
; /* num erpts dropped on post */
105 kstat_named_t erpt_set_failed
; /* num erpt set failures */
106 kstat_named_t fmri_set_failed
; /* num fmri set failures */
107 kstat_named_t payload_set_failed
; /* num payload set failures */
110 static struct erpt_kstat erpt_kstat_data
= {
111 { "erpt-dropped", KSTAT_DATA_UINT64
},
112 { "erpt-set-failed", KSTAT_DATA_UINT64
},
113 { "fmri-set-failed", KSTAT_DATA_UINT64
},
114 { "payload-set-failed", KSTAT_DATA_UINT64
}
119 fm_drain(void *private, void *data
, errorq_elem_t
*eep
)
121 nvlist_t
*nvl
= errorq_elem_nvl(ereport_errorq
, eep
);
124 (void) fm_ereport_post(nvl
, EVCH_TRYHARD
);
134 (void) sysevent_evc_bind(FM_ERROR_CHAN
,
135 &ereport_chan
, EVCH_CREAT
| EVCH_HOLD_PEND
);
137 (void) sysevent_evc_control(ereport_chan
,
138 EVCH_SET_CHAN_LEN
, &ereport_chanlen
);
140 if (ereport_qlen
== 0)
141 ereport_qlen
= ERPT_MAX_ERRS
* MAX(max_ncpus
, 4);
143 if (ereport_size
== 0)
144 ereport_size
= ERPT_DATA_SZ
;
146 ereport_errorq
= errorq_nvcreate("fm_ereport_queue",
147 (errorq_func_t
)fm_drain
, NULL
, ereport_qlen
, ereport_size
,
148 FM_ERR_PIL
, ERRORQ_VITAL
);
149 if (ereport_errorq
== NULL
)
150 panic("failed to create required ereport error queue");
152 ereport_dumpbuf
= kmem_alloc(ereport_size
, KM_SLEEP
);
153 ereport_dumplen
= ereport_size
;
155 /* Initialize ereport allocation and generation kstats */
156 ksp
= kstat_create("unix", 0, "fm", "misc", KSTAT_TYPE_NAMED
,
157 sizeof (struct erpt_kstat
) / sizeof (kstat_named_t
),
161 ksp
->ks_data
= &erpt_kstat_data
;
164 cmn_err(CE_NOTE
, "failed to create fm/misc kstat\n");
170 * Formatting utility function for fm_nvprintr. We attempt to wrap chunks of
171 * output so they aren't split across console lines, and return the end column.
175 fm_printf(int depth
, int c
, int cols
, const char *format
, ...)
181 va_start(ap
, format
);
182 width
= vsnprintf(&c1
, sizeof (c1
), format
, ap
);
185 if (c
+ width
>= cols
) {
186 console_printf("\n\r");
188 if (format
[0] != ' ' && depth
> 0) {
194 va_start(ap
, format
);
195 console_vprintf(format
, ap
);
198 return ((c
+ width
) % cols
);
202 * Recursively print a nvlist in the specified column width and return the
203 * column we end up in. This function is called recursively by fm_nvprint(),
204 * below. We generically format the entire nvpair using hexadecimal
205 * integers and strings, and elide any integer arrays. Arrays are basically
206 * used for cache dumps right now, so we suppress them so as not to overwhelm
207 * the amount of console output we produce at panic time. This can be further
208 * enhanced as FMA technology grows based upon the needs of consumers. All
209 * FMA telemetry is logged using the dump device transport, so the console
210 * output serves only as a fallback in case this procedure is unsuccessful.
213 fm_nvprintr(nvlist_t
*nvl
, int d
, int c
, int cols
)
217 for (nvp
= nvlist_next_nvpair(nvl
, NULL
);
218 nvp
!= NULL
; nvp
= nvlist_next_nvpair(nvl
, nvp
)) {
220 data_type_t type
= nvpair_type(nvp
);
221 const char *name
= nvpair_name(nvp
);
231 if (strcmp(name
, FM_CLASS
) == 0)
232 continue; /* already printed by caller */
234 c
= fm_printf(d
, c
, cols
, " %s=", name
);
237 case DATA_TYPE_BOOLEAN
:
238 c
= fm_printf(d
+ 1, c
, cols
, " 1");
241 case DATA_TYPE_BOOLEAN_VALUE
:
242 (void) nvpair_value_boolean_value(nvp
, &b
);
243 c
= fm_printf(d
+ 1, c
, cols
, b
? "1" : "0");
247 (void) nvpair_value_byte(nvp
, &i8
);
248 c
= fm_printf(d
+ 1, c
, cols
, "%x", i8
);
252 (void) nvpair_value_int8(nvp
, (void *)&i8
);
253 c
= fm_printf(d
+ 1, c
, cols
, "%x", i8
);
256 case DATA_TYPE_UINT8
:
257 (void) nvpair_value_uint8(nvp
, &i8
);
258 c
= fm_printf(d
+ 1, c
, cols
, "%x", i8
);
261 case DATA_TYPE_INT16
:
262 (void) nvpair_value_int16(nvp
, (void *)&i16
);
263 c
= fm_printf(d
+ 1, c
, cols
, "%x", i16
);
266 case DATA_TYPE_UINT16
:
267 (void) nvpair_value_uint16(nvp
, &i16
);
268 c
= fm_printf(d
+ 1, c
, cols
, "%x", i16
);
271 case DATA_TYPE_INT32
:
272 (void) nvpair_value_int32(nvp
, (void *)&i32
);
273 c
= fm_printf(d
+ 1, c
, cols
, "%x", i32
);
276 case DATA_TYPE_UINT32
:
277 (void) nvpair_value_uint32(nvp
, &i32
);
278 c
= fm_printf(d
+ 1, c
, cols
, "%x", i32
);
281 case DATA_TYPE_INT64
:
282 (void) nvpair_value_int64(nvp
, (void *)&i64
);
283 c
= fm_printf(d
+ 1, c
, cols
, "%llx",
287 case DATA_TYPE_UINT64
:
288 (void) nvpair_value_uint64(nvp
, &i64
);
289 c
= fm_printf(d
+ 1, c
, cols
, "%llx",
293 case DATA_TYPE_HRTIME
:
294 (void) nvpair_value_hrtime(nvp
, (void *)&i64
);
295 c
= fm_printf(d
+ 1, c
, cols
, "%llx",
299 case DATA_TYPE_STRING
:
300 (void) nvpair_value_string(nvp
, &str
);
301 c
= fm_printf(d
+ 1, c
, cols
, "\"%s\"",
302 str
? str
: "<NULL>");
305 case DATA_TYPE_NVLIST
:
306 c
= fm_printf(d
+ 1, c
, cols
, "[");
307 (void) nvpair_value_nvlist(nvp
, &cnv
);
308 c
= fm_nvprintr(cnv
, d
+ 1, c
, cols
);
309 c
= fm_printf(d
+ 1, c
, cols
, " ]");
312 case DATA_TYPE_NVLIST_ARRAY
: {
316 c
= fm_printf(d
+ 1, c
, cols
, "[");
317 (void) nvpair_value_nvlist_array(nvp
, &val
, &nelem
);
318 for (i
= 0; i
< nelem
; i
++) {
319 c
= fm_nvprintr(val
[i
], d
+ 1, c
, cols
);
321 c
= fm_printf(d
+ 1, c
, cols
, " ]");
325 case DATA_TYPE_BOOLEAN_ARRAY
:
326 case DATA_TYPE_BYTE_ARRAY
:
327 case DATA_TYPE_INT8_ARRAY
:
328 case DATA_TYPE_UINT8_ARRAY
:
329 case DATA_TYPE_INT16_ARRAY
:
330 case DATA_TYPE_UINT16_ARRAY
:
331 case DATA_TYPE_INT32_ARRAY
:
332 case DATA_TYPE_UINT32_ARRAY
:
333 case DATA_TYPE_INT64_ARRAY
:
334 case DATA_TYPE_UINT64_ARRAY
:
335 case DATA_TYPE_STRING_ARRAY
:
336 c
= fm_printf(d
+ 1, c
, cols
, "[...]");
338 case DATA_TYPE_UNKNOWN
:
339 c
= fm_printf(d
+ 1, c
, cols
, "<unknown>");
348 fm_nvprint(nvlist_t
*nvl
)
353 console_printf("\r");
355 if (nvlist_lookup_string(nvl
, FM_CLASS
, &class) == 0)
356 c
= fm_printf(0, c
, ereport_cols
, "%s", class);
358 if (fm_nvprintr(nvl
, 0, c
, ereport_cols
) != 0)
359 console_printf("\n");
361 console_printf("\n");
365 * Wrapper for panic() that first produces an FMA-style message for admins.
366 * Normally such messages are generated by fmd(1M)'s syslog-msgs agent: this
367 * is the one exception to that rule and the only error that gets messaged.
368 * This function is intended for use by subsystems that have detected a fatal
369 * error and enqueued appropriate ereports and wish to then force a panic.
373 fm_panic(const char *format
, ...)
377 (void) atomic_cas_ptr((void *)&fm_panicstr
, NULL
, (void *)format
);
378 #if defined(__i386) || defined(__amd64)
379 fastreboot_disable_highpil();
380 #endif /* __i386 || __amd64 */
381 va_start(ap
, format
);
387 * Simply tell the caller if fm_panicstr is set, ie. an fma event has
388 * caused the panic. If so, something other than the default panic
389 * diagnosis method will diagnose the cause of the panic.
401 * Print any appropriate FMA banner message before the panic message. This
402 * function is called by panicsys() and prints the message for fm_panic().
403 * We print the message here so that it comes after the system is quiesced.
404 * A one-line summary is recorded in the log only (cmn_err(9F) with "!" prefix).
405 * The rest of the message is for the console only and not needed in the log,
406 * so it is printed using console_printf(). We break it up into multiple
407 * chunks so as to avoid overflowing any small legacy prom_printf() buffers.
416 return; /* panic was not initiated by fm_panic(); do nothing */
419 tod
= panic_hrestime
;
423 now
= gethrtime_waitfree();
426 cmn_err(CE_NOTE
, "!SUNW-MSG-ID: %s, "
427 "TYPE: Error, VER: 1, SEVERITY: Major\n", fm_msgid
);
430 "\n\rSUNW-MSG-ID: %s, TYPE: Error, VER: 1, SEVERITY: Major\n"
431 "EVENT-TIME: 0x%lx.0x%lx (0x%llx)\n",
432 fm_msgid
, tod
.tv_sec
, tod
.tv_nsec
, (u_longlong_t
)now
);
435 "PLATFORM: %s, CSN: -, HOSTNAME: %s\n"
436 "SOURCE: %s, REV: %s %s\n",
437 platform
, utsname
.nodename
, utsname
.sysname
,
438 utsname
.release
, utsname
.version
);
441 "DESC: Errors have been detected that require a reboot to ensure system\n"
442 "integrity. See %s/%s for more information.\n",
446 "AUTO-RESPONSE: Solaris will attempt to save and diagnose the error telemetry\n"
447 "IMPACT: The system will sync files, save a crash dump if needed, and reboot\n"
448 "REC-ACTION: Save the error summary below in case telemetry cannot be saved\n");
450 console_printf("\n");
454 * Utility function to write all of the pending ereports to the dump device.
455 * This function is called at either normal reboot or panic time, and simply
456 * iterates over the in-transit messages in the ereport sysevent channel.
459 fm_ereport_dump(void)
471 tod
= panic_hrestime
;
474 if (ereport_errorq
!= NULL
)
475 errorq_drain(ereport_errorq
);
477 now
= gethrtime_waitfree();
481 * In the panic case, sysevent_evc_walk_init() will return NULL.
483 if ((chq
= sysevent_evc_walk_init(ereport_chan
, NULL
)) == NULL
&&
485 return; /* event channel isn't initialized yet */
487 while ((sep
= sysevent_evc_walk_step(chq
)) != NULL
) {
488 if ((buf
= sysevent_evc_event_attr(sep
, &len
)) == NULL
)
491 ed
.ed_magic
= ERPT_MAGIC
;
492 ed
.ed_chksum
= checksum32(buf
, len
);
493 ed
.ed_size
= (uint32_t)len
;
495 ed
.ed_hrt_nsec
= SE_TIME(sep
);
496 ed
.ed_hrt_base
= now
;
497 ed
.ed_tod_base
.sec
= tod
.tv_sec
;
498 ed
.ed_tod_base
.nsec
= tod
.tv_nsec
;
500 dumpvp_write(&ed
, sizeof (ed
));
501 dumpvp_write(buf
, len
);
504 sysevent_evc_walk_fini(chq
);
508 * Post an error report (ereport) to the sysevent error channel. The error
509 * channel must be established with a prior call to sysevent_evc_create()
510 * before publication may occur.
513 fm_ereport_post(nvlist_t
*ereport
, int evc_flag
)
516 evchan_t
*error_chan
;
518 (void) nvlist_size(ereport
, &nvl_size
, NV_ENCODE_NATIVE
);
519 if (nvl_size
> ERPT_DATA_SZ
|| nvl_size
== 0) {
520 atomic_add_64(&erpt_kstat_data
.erpt_dropped
.value
.ui64
, 1);
524 if (sysevent_evc_bind(FM_ERROR_CHAN
, &error_chan
,
525 EVCH_CREAT
|EVCH_HOLD_PEND
) != 0) {
526 atomic_add_64(&erpt_kstat_data
.erpt_dropped
.value
.ui64
, 1);
530 if (sysevent_evc_publish(error_chan
, EC_FM
, ESC_FM_ERROR
,
531 SUNW_VENDOR
, FM_PUB
, ereport
, evc_flag
) != 0) {
532 atomic_add_64(&erpt_kstat_data
.erpt_dropped
.value
.ui64
, 1);
533 (void) sysevent_evc_unbind(error_chan
);
536 (void) sysevent_evc_unbind(error_chan
);
540 * Wrapppers for FM nvlist allocators
544 i_fm_alloc(nv_alloc_t
*nva
, size_t size
)
546 return (kmem_zalloc(size
, KM_SLEEP
));
551 i_fm_free(nv_alloc_t
*nva
, void *buf
, size_t size
)
553 kmem_free(buf
, size
);
556 const nv_alloc_ops_t fm_mem_alloc_ops
= {
565 * Create and initialize a new nv_alloc_t for a fixed buffer, buf. A pointer
566 * to the newly allocated nv_alloc_t structure is returned upon success or NULL
567 * is returned to indicate that the nv_alloc structure could not be created.
570 fm_nva_xcreate(char *buf
, size_t bufsz
)
572 nv_alloc_t
*nvhdl
= kmem_zalloc(sizeof (nv_alloc_t
), KM_SLEEP
);
574 if (bufsz
== 0 || nv_alloc_init(nvhdl
, nv_fixed_ops
, buf
, bufsz
) != 0) {
575 kmem_free(nvhdl
, sizeof (nv_alloc_t
));
583 * Destroy a previously allocated nv_alloc structure. The fixed buffer
584 * associated with nva must be freed by the caller.
587 fm_nva_xdestroy(nv_alloc_t
*nva
)
590 kmem_free(nva
, sizeof (nv_alloc_t
));
594 * Create a new nv list. A pointer to a new nv list structure is returned
595 * upon success or NULL is returned to indicate that the structure could
596 * not be created. The newly created nv list is created and managed by the
597 * operations installed in nva. If nva is NULL, the default FMA nva
598 * operations are installed and used.
600 * When called from the kernel and nva == NULL, this function must be called
601 * from passive kernel context with no locks held that can prevent a
602 * sleeping memory allocation from occurring. Otherwise, this function may
603 * be called from other kernel contexts as long a valid nva created via
604 * fm_nva_create() is supplied.
607 fm_nvlist_create(nv_alloc_t
*nva
)
614 nvhdl
= kmem_zalloc(sizeof (nv_alloc_t
), KM_SLEEP
);
616 if (nv_alloc_init(nvhdl
, &fm_mem_alloc_ops
, NULL
, 0) != 0) {
617 kmem_free(nvhdl
, sizeof (nv_alloc_t
));
625 if (nvlist_xalloc(&nvl
, NV_UNIQUE_NAME
, nvhdl
) != 0) {
627 nv_alloc_fini(nvhdl
);
628 kmem_free(nvhdl
, sizeof (nv_alloc_t
));
637 * Destroy a previously allocated nvlist structure. flag indicates whether
638 * or not the associated nva structure should be freed (FM_NVA_FREE) or
639 * retained (FM_NVA_RETAIN). Retaining the nv alloc structure allows
640 * it to be re-used for future nvlist creation operations.
643 fm_nvlist_destroy(nvlist_t
*nvl
, int flag
)
645 nv_alloc_t
*nva
= nvlist_lookup_nv_alloc(nvl
);
650 if (flag
== FM_NVA_FREE
)
651 fm_nva_xdestroy(nva
);
656 i_fm_payload_set(nvlist_t
*payload
, const char *name
, va_list ap
)
661 while (ret
== 0 && name
!= NULL
) {
662 type
= va_arg(ap
, data_type_t
);
665 ret
= nvlist_add_byte(payload
, name
,
668 case DATA_TYPE_BYTE_ARRAY
:
669 nelem
= va_arg(ap
, int);
670 ret
= nvlist_add_byte_array(payload
, name
,
671 va_arg(ap
, uchar_t
*), nelem
);
673 case DATA_TYPE_BOOLEAN_VALUE
:
674 ret
= nvlist_add_boolean_value(payload
, name
,
675 va_arg(ap
, boolean_t
));
677 case DATA_TYPE_BOOLEAN_ARRAY
:
678 nelem
= va_arg(ap
, int);
679 ret
= nvlist_add_boolean_array(payload
, name
,
680 va_arg(ap
, boolean_t
*), nelem
);
683 ret
= nvlist_add_int8(payload
, name
,
686 case DATA_TYPE_INT8_ARRAY
:
687 nelem
= va_arg(ap
, int);
688 ret
= nvlist_add_int8_array(payload
, name
,
689 va_arg(ap
, int8_t *), nelem
);
691 case DATA_TYPE_UINT8
:
692 ret
= nvlist_add_uint8(payload
, name
,
695 case DATA_TYPE_UINT8_ARRAY
:
696 nelem
= va_arg(ap
, int);
697 ret
= nvlist_add_uint8_array(payload
, name
,
698 va_arg(ap
, uint8_t *), nelem
);
700 case DATA_TYPE_INT16
:
701 ret
= nvlist_add_int16(payload
, name
,
704 case DATA_TYPE_INT16_ARRAY
:
705 nelem
= va_arg(ap
, int);
706 ret
= nvlist_add_int16_array(payload
, name
,
707 va_arg(ap
, int16_t *), nelem
);
709 case DATA_TYPE_UINT16
:
710 ret
= nvlist_add_uint16(payload
, name
,
713 case DATA_TYPE_UINT16_ARRAY
:
714 nelem
= va_arg(ap
, int);
715 ret
= nvlist_add_uint16_array(payload
, name
,
716 va_arg(ap
, uint16_t *), nelem
);
718 case DATA_TYPE_INT32
:
719 ret
= nvlist_add_int32(payload
, name
,
720 va_arg(ap
, int32_t));
722 case DATA_TYPE_INT32_ARRAY
:
723 nelem
= va_arg(ap
, int);
724 ret
= nvlist_add_int32_array(payload
, name
,
725 va_arg(ap
, int32_t *), nelem
);
727 case DATA_TYPE_UINT32
:
728 ret
= nvlist_add_uint32(payload
, name
,
729 va_arg(ap
, uint32_t));
731 case DATA_TYPE_UINT32_ARRAY
:
732 nelem
= va_arg(ap
, int);
733 ret
= nvlist_add_uint32_array(payload
, name
,
734 va_arg(ap
, uint32_t *), nelem
);
736 case DATA_TYPE_INT64
:
737 ret
= nvlist_add_int64(payload
, name
,
738 va_arg(ap
, int64_t));
740 case DATA_TYPE_INT64_ARRAY
:
741 nelem
= va_arg(ap
, int);
742 ret
= nvlist_add_int64_array(payload
, name
,
743 va_arg(ap
, int64_t *), nelem
);
745 case DATA_TYPE_UINT64
:
746 ret
= nvlist_add_uint64(payload
, name
,
747 va_arg(ap
, uint64_t));
749 case DATA_TYPE_UINT64_ARRAY
:
750 nelem
= va_arg(ap
, int);
751 ret
= nvlist_add_uint64_array(payload
, name
,
752 va_arg(ap
, uint64_t *), nelem
);
754 case DATA_TYPE_STRING
:
755 ret
= nvlist_add_string(payload
, name
,
758 case DATA_TYPE_STRING_ARRAY
:
759 nelem
= va_arg(ap
, int);
760 ret
= nvlist_add_string_array(payload
, name
,
761 va_arg(ap
, char **), nelem
);
763 case DATA_TYPE_NVLIST
:
764 ret
= nvlist_add_nvlist(payload
, name
,
765 va_arg(ap
, nvlist_t
*));
767 case DATA_TYPE_NVLIST_ARRAY
:
768 nelem
= va_arg(ap
, int);
769 ret
= nvlist_add_nvlist_array(payload
, name
,
770 va_arg(ap
, nvlist_t
**), nelem
);
776 name
= va_arg(ap
, char *);
782 fm_payload_set(nvlist_t
*payload
, ...)
788 va_start(ap
, payload
);
789 name
= va_arg(ap
, char *);
790 ret
= i_fm_payload_set(payload
, name
, ap
);
795 &erpt_kstat_data
.payload_set_failed
.value
.ui64
, 1);
799 * Set-up and validate the members of an ereport event according to:
801 * Member name Type Value
802 * ====================================================
803 * class string ereport
806 * detector nvlist_t <detector>
807 * ereport-payload nvlist_t <var args>
809 * We don't actually add a 'version' member to the payload. Really,
810 * the version quoted to us by our caller is that of the category 1
811 * "ereport" event class (and we require FM_EREPORT_VERS0) but
812 * the payload version of the actual leaf class event under construction
813 * may be something else. Callers should supply a version in the varargs,
814 * or (better) we could take two version arguments - one for the
815 * ereport category 1 classification (expect FM_EREPORT_VERS0) and one
816 * for the leaf class.
819 fm_ereport_set(nvlist_t
*ereport
, int version
, const char *erpt_class
,
820 uint64_t ena
, const nvlist_t
*detector
, ...)
822 char ereport_class
[FM_MAX_CLASS
];
827 if (version
!= FM_EREPORT_VERS0
) {
828 atomic_add_64(&erpt_kstat_data
.erpt_set_failed
.value
.ui64
, 1);
832 (void) snprintf(ereport_class
, FM_MAX_CLASS
, "%s.%s",
833 FM_EREPORT_CLASS
, erpt_class
);
834 if (nvlist_add_string(ereport
, FM_CLASS
, ereport_class
) != 0) {
835 atomic_add_64(&erpt_kstat_data
.erpt_set_failed
.value
.ui64
, 1);
839 if (nvlist_add_uint64(ereport
, FM_EREPORT_ENA
, ena
)) {
840 atomic_add_64(&erpt_kstat_data
.erpt_set_failed
.value
.ui64
, 1);
843 if (nvlist_add_nvlist(ereport
, FM_EREPORT_DETECTOR
,
844 (nvlist_t
*)detector
) != 0) {
845 atomic_add_64(&erpt_kstat_data
.erpt_set_failed
.value
.ui64
, 1);
848 va_start(ap
, detector
);
849 name
= va_arg(ap
, const char *);
850 ret
= i_fm_payload_set(ereport
, name
, ap
);
854 atomic_add_64(&erpt_kstat_data
.erpt_set_failed
.value
.ui64
, 1);
858 * Set-up and validate the members of an hc fmri according to;
860 * Member name Type Value
861 * ===================================================
863 * auth nvlist_t <auth>
864 * hc-name string <name>
867 * Note that auth and hc-id are optional members.
870 #define HC_MAXPAIRS 20
871 #define HC_MAXNAMELEN 50
874 fm_fmri_hc_set_common(nvlist_t
*fmri
, int version
, const nvlist_t
*auth
)
876 if (version
!= FM_HC_SCHEME_VERSION
) {
877 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
881 if (nvlist_add_uint8(fmri
, FM_VERSION
, version
) != 0 ||
882 nvlist_add_string(fmri
, FM_FMRI_SCHEME
, FM_FMRI_SCHEME_HC
) != 0) {
883 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
887 if (auth
!= NULL
&& nvlist_add_nvlist(fmri
, FM_FMRI_AUTHORITY
,
888 (nvlist_t
*)auth
) != 0) {
889 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
897 fm_fmri_hc_set(nvlist_t
*fmri
, int version
, const nvlist_t
*auth
,
898 nvlist_t
*snvl
, int npairs
, ...)
900 nv_alloc_t
*nva
= nvlist_lookup_nv_alloc(fmri
);
901 nvlist_t
*pairs
[HC_MAXPAIRS
];
905 if (!fm_fmri_hc_set_common(fmri
, version
, auth
))
908 npairs
= MIN(npairs
, HC_MAXPAIRS
);
910 va_start(ap
, npairs
);
911 for (i
= 0; i
< npairs
; i
++) {
912 const char *name
= va_arg(ap
, const char *);
913 uint32_t id
= va_arg(ap
, uint32_t);
916 (void) snprintf(idstr
, sizeof (idstr
), "%u", id
);
918 pairs
[i
] = fm_nvlist_create(nva
);
919 if (nvlist_add_string(pairs
[i
], FM_FMRI_HC_NAME
, name
) != 0 ||
920 nvlist_add_string(pairs
[i
], FM_FMRI_HC_ID
, idstr
) != 0) {
922 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
927 if (nvlist_add_nvlist_array(fmri
, FM_FMRI_HC_LIST
, pairs
, npairs
) != 0)
928 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
930 for (i
= 0; i
< npairs
; i
++)
931 fm_nvlist_destroy(pairs
[i
], FM_NVA_RETAIN
);
934 if (nvlist_add_nvlist(fmri
, FM_FMRI_HC_SPECIFIC
, snvl
) != 0) {
936 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
942 * Set-up and validate the members of an dev fmri according to:
944 * Member name Type Value
945 * ====================================================
947 * auth nvlist_t <auth>
948 * devpath string <devpath>
949 * [devid] string <devid>
950 * [target-port-l0id] string <target-port-lun0-id>
952 * Note that auth and devid are optional members.
955 fm_fmri_dev_set(nvlist_t
*fmri_dev
, int version
, const nvlist_t
*auth
,
956 const char *devpath
, const char *devid
, const char *tpl0
)
960 if (version
!= DEV_SCHEME_VERSION0
) {
961 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
965 err
|= nvlist_add_uint8(fmri_dev
, FM_VERSION
, version
);
966 err
|= nvlist_add_string(fmri_dev
, FM_FMRI_SCHEME
, FM_FMRI_SCHEME_DEV
);
969 err
|= nvlist_add_nvlist(fmri_dev
, FM_FMRI_AUTHORITY
,
973 err
|= nvlist_add_string(fmri_dev
, FM_FMRI_DEV_PATH
, devpath
);
976 err
|= nvlist_add_string(fmri_dev
, FM_FMRI_DEV_ID
, devid
);
979 err
|= nvlist_add_string(fmri_dev
, FM_FMRI_DEV_TGTPTLUN0
, tpl0
);
982 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
987 * Set-up and validate the members of an cpu fmri according to:
989 * Member name Type Value
990 * ====================================================
992 * auth nvlist_t <auth>
993 * cpuid uint32_t <cpu_id>
994 * cpumask uint8_t <cpu_mask>
995 * serial uint64_t <serial_id>
997 * Note that auth, cpumask, serial are optional members.
1001 fm_fmri_cpu_set(nvlist_t
*fmri_cpu
, int version
, const nvlist_t
*auth
,
1002 uint32_t cpu_id
, uint8_t *cpu_maskp
, const char *serial_idp
)
1004 uint64_t *failedp
= &erpt_kstat_data
.fmri_set_failed
.value
.ui64
;
1006 if (version
< CPU_SCHEME_VERSION1
) {
1007 atomic_add_64(failedp
, 1);
1011 if (nvlist_add_uint8(fmri_cpu
, FM_VERSION
, version
) != 0) {
1012 atomic_add_64(failedp
, 1);
1016 if (nvlist_add_string(fmri_cpu
, FM_FMRI_SCHEME
,
1017 FM_FMRI_SCHEME_CPU
) != 0) {
1018 atomic_add_64(failedp
, 1);
1022 if (auth
!= NULL
&& nvlist_add_nvlist(fmri_cpu
, FM_FMRI_AUTHORITY
,
1023 (nvlist_t
*)auth
) != 0)
1024 atomic_add_64(failedp
, 1);
1026 if (nvlist_add_uint32(fmri_cpu
, FM_FMRI_CPU_ID
, cpu_id
) != 0)
1027 atomic_add_64(failedp
, 1);
1029 if (cpu_maskp
!= NULL
&& nvlist_add_uint8(fmri_cpu
, FM_FMRI_CPU_MASK
,
1031 atomic_add_64(failedp
, 1);
1033 if (serial_idp
== NULL
|| nvlist_add_string(fmri_cpu
,
1034 FM_FMRI_CPU_SERIAL_ID
, (char *)serial_idp
) != 0)
1035 atomic_add_64(failedp
, 1);
1039 * Set-up and validate the members of a mem according to:
1041 * Member name Type Value
1042 * ====================================================
1044 * auth nvlist_t <auth> [optional]
1045 * unum string <unum>
1046 * serial string <serial> [optional*]
1047 * offset uint64_t <offset> [optional]
1049 * * serial is required if offset is present
1052 fm_fmri_mem_set(nvlist_t
*fmri
, int version
, const nvlist_t
*auth
,
1053 const char *unum
, const char *serial
, uint64_t offset
)
1055 if (version
!= MEM_SCHEME_VERSION0
) {
1056 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1060 if (!serial
&& (offset
!= (uint64_t)-1)) {
1061 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1065 if (nvlist_add_uint8(fmri
, FM_VERSION
, version
) != 0) {
1066 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1070 if (nvlist_add_string(fmri
, FM_FMRI_SCHEME
, FM_FMRI_SCHEME_MEM
) != 0) {
1071 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1076 if (nvlist_add_nvlist(fmri
, FM_FMRI_AUTHORITY
,
1077 (nvlist_t
*)auth
) != 0) {
1079 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1083 if (nvlist_add_string(fmri
, FM_FMRI_MEM_UNUM
, unum
) != 0) {
1084 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1087 if (serial
!= NULL
) {
1088 if (nvlist_add_string_array(fmri
, FM_FMRI_MEM_SERIAL_ID
,
1089 (char **)&serial
, 1) != 0) {
1091 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1093 if (offset
!= (uint64_t)-1) {
1094 if (nvlist_add_uint64(fmri
, FM_FMRI_MEM_OFFSET
,
1096 atomic_add_64(&erpt_kstat_data
.
1097 fmri_set_failed
.value
.ui64
, 1);
1104 fm_fmri_zfs_set(nvlist_t
*fmri
, int version
, uint64_t pool_guid
,
1107 if (version
!= ZFS_SCHEME_VERSION0
) {
1108 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1112 if (nvlist_add_uint8(fmri
, FM_VERSION
, version
) != 0) {
1113 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1117 if (nvlist_add_string(fmri
, FM_FMRI_SCHEME
, FM_FMRI_SCHEME_ZFS
) != 0) {
1118 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1122 if (nvlist_add_uint64(fmri
, FM_FMRI_ZFS_POOL
, pool_guid
) != 0) {
1123 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1126 if (vdev_guid
!= 0) {
1127 if (nvlist_add_uint64(fmri
, FM_FMRI_ZFS_VDEV
, vdev_guid
) != 0) {
1129 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1135 fm_ena_increment(uint64_t ena
)
1139 switch (ENA_FORMAT(ena
)) {
1141 new_ena
= ena
+ (1 << ENA_FMT1_GEN_SHFT
);
1144 new_ena
= ena
+ (1 << ENA_FMT2_GEN_SHFT
);
1154 fm_ena_generate_cpu(uint64_t timestamp
, processorid_t cpuid
, uchar_t format
)
1161 ena
= (uint64_t)((format
& ENA_FORMAT_MASK
) |
1162 ((cpuid
<< ENA_FMT1_CPUID_SHFT
) &
1163 ENA_FMT1_CPUID_MASK
) |
1164 ((timestamp
<< ENA_FMT1_TIME_SHFT
) &
1165 ENA_FMT1_TIME_MASK
));
1167 ena
= (uint64_t)((format
& ENA_FORMAT_MASK
) |
1168 ((cpuid
<< ENA_FMT1_CPUID_SHFT
) &
1169 ENA_FMT1_CPUID_MASK
) |
1170 ((gethrtime_waitfree() << ENA_FMT1_TIME_SHFT
) &
1171 ENA_FMT1_TIME_MASK
));
1175 ena
= (uint64_t)((format
& ENA_FORMAT_MASK
) |
1176 ((timestamp
<< ENA_FMT2_TIME_SHFT
) & ENA_FMT2_TIME_MASK
));
1186 fm_ena_generate(uint64_t timestamp
, uchar_t format
)
1188 return (fm_ena_generate_cpu(timestamp
, CPU
->cpu_id
, format
));
1192 fm_ena_generation_get(uint64_t ena
)
1196 switch (ENA_FORMAT(ena
)) {
1198 gen
= (ena
& ENA_FMT1_GEN_MASK
) >> ENA_FMT1_GEN_SHFT
;
1201 gen
= (ena
& ENA_FMT2_GEN_MASK
) >> ENA_FMT2_GEN_SHFT
;
1212 fm_ena_format_get(uint64_t ena
)
1215 return (ENA_FORMAT(ena
));
1219 fm_ena_id_get(uint64_t ena
)
1223 switch (ENA_FORMAT(ena
)) {
1225 id
= (ena
& ENA_FMT1_ID_MASK
) >> ENA_FMT1_ID_SHFT
;
1228 id
= (ena
& ENA_FMT2_ID_MASK
) >> ENA_FMT2_ID_SHFT
;
1238 fm_ena_time_get(uint64_t ena
)
1242 switch (ENA_FORMAT(ena
)) {
1244 time
= (ena
& ENA_FMT1_TIME_MASK
) >> ENA_FMT1_TIME_SHFT
;
1247 time
= (ena
& ENA_FMT2_TIME_MASK
) >> ENA_FMT2_TIME_SHFT
;
1257 * Convert a getpcstack() trace to symbolic name+offset, and add the resulting
1258 * string array to a Fault Management ereport as FM_EREPORT_PAYLOAD_NAME_STACK.
1261 fm_payload_stack_add(nvlist_t
*payload
, const pc_t
*stack
, int depth
)
1266 char *stkpp
[FM_STK_DEPTH
];
1267 char buf
[FM_STK_DEPTH
* FM_SYM_SZ
];
1270 for (i
= 0; i
< depth
&& i
!= FM_STK_DEPTH
; i
++, stkp
+= FM_SYM_SZ
) {
1271 if ((sym
= kobj_getsymname(stack
[i
], &off
)) != NULL
)
1272 (void) snprintf(stkp
, FM_SYM_SZ
, "%s+%lx", sym
, off
);
1274 (void) snprintf(stkp
, FM_SYM_SZ
, "%lx", (long)stack
[i
]);
1278 fm_payload_set(payload
, FM_EREPORT_PAYLOAD_NAME_STACK
,
1279 DATA_TYPE_STRING_ARRAY
, depth
, stkpp
, NULL
);
1283 print_msg_hwerr(ctid_t ct_id
, proc_t
*p
)
1285 uprintf("Killed process %d (%s) in contract id %d "
1286 "due to hardware error\n", p
->p_pid
, p
->p_user
.u_comm
, ct_id
);
1290 fm_fmri_hc_create(nvlist_t
*fmri
, int version
, const nvlist_t
*auth
,
1291 nvlist_t
*snvl
, nvlist_t
*bboard
, int npairs
, ...)
1293 nv_alloc_t
*nva
= nvlist_lookup_nv_alloc(fmri
);
1294 nvlist_t
*pairs
[HC_MAXPAIRS
];
1299 char *hcname
, *hcid
;
1301 if (!fm_fmri_hc_set_common(fmri
, version
, auth
))
1305 * copy the bboard nvpairs to the pairs array
1307 if (nvlist_lookup_nvlist_array(bboard
, FM_FMRI_HC_LIST
, &hcl
, &n
)
1309 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1313 for (i
= 0; i
< n
; i
++) {
1314 if (nvlist_lookup_string(hcl
[i
], FM_FMRI_HC_NAME
,
1317 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1320 if (nvlist_lookup_string(hcl
[i
], FM_FMRI_HC_ID
, &hcid
) != 0) {
1322 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1326 pairs
[i
] = fm_nvlist_create(nva
);
1327 if (nvlist_add_string(pairs
[i
], FM_FMRI_HC_NAME
, hcname
) != 0 ||
1328 nvlist_add_string(pairs
[i
], FM_FMRI_HC_ID
, hcid
) != 0) {
1329 for (j
= 0; j
<= i
; j
++) {
1330 if (pairs
[j
] != NULL
)
1331 fm_nvlist_destroy(pairs
[j
],
1335 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1341 * create the pairs from passed in pairs
1343 npairs
= MIN(npairs
, HC_MAXPAIRS
);
1345 va_start(ap
, npairs
);
1346 for (i
= n
; i
< npairs
+ n
; i
++) {
1347 const char *name
= va_arg(ap
, const char *);
1348 uint32_t id
= va_arg(ap
, uint32_t);
1350 (void) snprintf(idstr
, sizeof (idstr
), "%u", id
);
1351 pairs
[i
] = fm_nvlist_create(nva
);
1352 if (nvlist_add_string(pairs
[i
], FM_FMRI_HC_NAME
, name
) != 0 ||
1353 nvlist_add_string(pairs
[i
], FM_FMRI_HC_ID
, idstr
) != 0) {
1354 for (j
= 0; j
<= i
; j
++) {
1355 if (pairs
[j
] != NULL
)
1356 fm_nvlist_destroy(pairs
[j
],
1360 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1367 * Create the fmri hc list
1369 if (nvlist_add_nvlist_array(fmri
, FM_FMRI_HC_LIST
, pairs
,
1371 atomic_add_64(&erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);
1375 for (i
= 0; i
< npairs
+ n
; i
++) {
1376 fm_nvlist_destroy(pairs
[i
], FM_NVA_RETAIN
);
1380 if (nvlist_add_nvlist(fmri
, FM_FMRI_HC_SPECIFIC
, snvl
) != 0) {
1382 &erpt_kstat_data
.fmri_set_failed
.value
.ui64
, 1);