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 */