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 * Copyright (c) 2016, Intel Corporation. 25 */ 26 27 /* 28 * This file implements the minimal FMD module API required to support the 29 * fault logic modules in ZED. This support includes module registration, 30 * memory allocation, module property accessors, basic case management, 31 * one-shot timers and SERD engines. 32 * 33 * In the ZED runtime, the modules are called from a single thread so no 34 * locking is required in this emulated FMD environment. 35 */ 36 37 #include <sys/types.h> 38 #include <sys/fm/protocol.h> 39 #include <uuid/uuid.h> 40 #include <signal.h> 41 #include <strings.h> 42 #include <time.h> 43 44 #include "fmd_api.h" 45 #include "fmd_serd.h" 46 47 #include "zfs_agents.h" 48 #include "../zed_log.h" 49 50 typedef struct fmd_modstat { 51 fmd_stat_t ms_accepted; /* total events accepted by module */ 52 fmd_stat_t ms_caseopen; /* cases currently open */ 53 fmd_stat_t ms_casesolved; /* total cases solved by module */ 54 fmd_stat_t ms_caseclosed; /* total cases closed by module */ 55 } fmd_modstat_t; 56 57 typedef struct fmd_module { 58 const char *mod_name; /* basename of module (ro) */ 59 const fmd_hdl_info_t *mod_info; /* module info registered with handle */ 60 void *mod_spec; /* fmd_hdl_get/setspecific data value */ 61 fmd_stat_t *mod_ustat; /* module specific custom stats */ 62 uint_t mod_ustat_cnt; /* count of ustat stats */ 63 fmd_modstat_t mod_stats; /* fmd built-in per-module statistics */ 64 fmd_serd_hash_t mod_serds; /* hash of serd engs owned by module */ 65 char *mod_vers; /* a copy of module version string */ 66 } fmd_module_t; 67 68 /* 69 * ZED has two FMD hardwired module instances 70 */ 71 fmd_module_t zfs_retire_module; 72 fmd_module_t zfs_diagnosis_module; 73 74 /* 75 * Enable a reasonable set of defaults for libumem debugging on DEBUG builds. 76 */ 77 78 #ifdef DEBUG 79 const char * 80 _umem_debug_init(void) 81 { 82 return ("default,verbose"); /* $UMEM_DEBUG setting */ 83 } 84 85 const char * 86 _umem_logging_init(void) 87 { 88 return ("fail,contents"); /* $UMEM_LOGGING setting */ 89 } 90 #endif 91 92 /* 93 * Register a module with fmd and finish module initialization. 94 * Returns an integer indicating whether it succeeded (zero) or 95 * failed (non-zero). 96 */ 97 int 98 fmd_hdl_register(fmd_hdl_t *hdl, int version, const fmd_hdl_info_t *mip) 99 { 100 fmd_module_t *mp = (fmd_module_t *)hdl; 101 102 mp->mod_info = mip; 103 mp->mod_name = mip->fmdi_desc + 4; /* drop 'ZFS ' prefix */ 104 mp->mod_spec = NULL; 105 106 /* bare minimum module stats */ 107 (void) strcpy(mp->mod_stats.ms_accepted.fmds_name, "fmd.accepted"); 108 (void) strcpy(mp->mod_stats.ms_caseopen.fmds_name, "fmd.caseopen"); 109 (void) strcpy(mp->mod_stats.ms_casesolved.fmds_name, "fmd.casesolved"); 110 (void) strcpy(mp->mod_stats.ms_caseclosed.fmds_name, "fmd.caseclosed"); 111 112 fmd_serd_hash_create(&mp->mod_serds); 113 114 fmd_hdl_debug(hdl, "register module"); 115 116 return (0); 117 } 118 119 void 120 fmd_hdl_unregister(fmd_hdl_t *hdl) 121 { 122 fmd_module_t *mp = (fmd_module_t *)hdl; 123 fmd_modstat_t *msp = &mp->mod_stats; 124 const fmd_hdl_ops_t *ops = mp->mod_info->fmdi_ops; 125 126 /* dump generic module stats */ 127 fmd_hdl_debug(hdl, "%s: %llu", msp->ms_accepted.fmds_name, 128 msp->ms_accepted.fmds_value.ui64); 129 if (ops->fmdo_close != NULL) { 130 fmd_hdl_debug(hdl, "%s: %llu", msp->ms_caseopen.fmds_name, 131 msp->ms_caseopen.fmds_value.ui64); 132 fmd_hdl_debug(hdl, "%s: %llu", msp->ms_casesolved.fmds_name, 133 msp->ms_casesolved.fmds_value.ui64); 134 fmd_hdl_debug(hdl, "%s: %llu", msp->ms_caseclosed.fmds_name, 135 msp->ms_caseclosed.fmds_value.ui64); 136 } 137 138 /* dump module specific stats */ 139 if (mp->mod_ustat != NULL) { 140 int i; 141 142 for (i = 0; i < mp->mod_ustat_cnt; i++) { 143 fmd_hdl_debug(hdl, "%s: %llu", 144 mp->mod_ustat[i].fmds_name, 145 mp->mod_ustat[i].fmds_value.ui64); 146 } 147 } 148 149 fmd_serd_hash_destroy(&mp->mod_serds); 150 151 fmd_hdl_debug(hdl, "unregister module"); 152 } 153 154 /* 155 * fmd_hdl_setspecific() is used to associate a data pointer with 156 * the specified handle for the duration of the module's lifetime. 157 * This pointer can be retrieved using fmd_hdl_getspecific(). 158 */ 159 void 160 fmd_hdl_setspecific(fmd_hdl_t *hdl, void *spec) 161 { 162 fmd_module_t *mp = (fmd_module_t *)hdl; 163 164 mp->mod_spec = spec; 165 } 166 167 /* 168 * Return the module-specific data pointer previously associated 169 * with the handle using fmd_hdl_setspecific(). 170 */ 171 void * 172 fmd_hdl_getspecific(fmd_hdl_t *hdl) 173 { 174 fmd_module_t *mp = (fmd_module_t *)hdl; 175 176 return (mp->mod_spec); 177 } 178 179 void * 180 fmd_hdl_alloc(fmd_hdl_t *hdl, size_t size, int flags) 181 { 182 return (umem_alloc(size, flags)); 183 } 184 185 void * 186 fmd_hdl_zalloc(fmd_hdl_t *hdl, size_t size, int flags) 187 { 188 return (umem_zalloc(size, flags)); 189 } 190 191 void 192 fmd_hdl_free(fmd_hdl_t *hdl, void *data, size_t size) 193 { 194 umem_free(data, size); 195 } 196 197 /* 198 * Record a module debug message using the specified format. 199 */ 200 void 201 fmd_hdl_debug(fmd_hdl_t *hdl, const char *format, ...) 202 { 203 char message[256]; 204 va_list vargs; 205 fmd_module_t *mp = (fmd_module_t *)hdl; 206 207 va_start(vargs, format); 208 (void) vsnprintf(message, sizeof (message), format, vargs); 209 va_end(vargs); 210 211 /* prefix message with module name */ 212 zed_log_msg(LOG_INFO, "%s: %s", mp->mod_name, message); 213 } 214 215 /* Property Retrieval */ 216 217 int32_t 218 fmd_prop_get_int32(fmd_hdl_t *hdl, const char *name) 219 { 220 /* 221 * These can be looked up in mp->modinfo->fmdi_props 222 * For now we just hard code for phase 2. In the 223 * future, there can be a ZED based override. 224 */ 225 if (strcmp(name, "spare_on_remove") == 0) 226 return (1); 227 228 if (strcmp(name, "io_N") == 0 || strcmp(name, "checksum_N") == 0) 229 return (10); /* N = 10 events */ 230 231 return (0); 232 } 233 234 int64_t 235 fmd_prop_get_int64(fmd_hdl_t *hdl, const char *name) 236 { 237 /* 238 * These can be looked up in mp->modinfo->fmdi_props 239 * For now we just hard code for phase 2. In the 240 * future, there can be a ZED based override. 241 */ 242 if (strcmp(name, "remove_timeout") == 0) 243 return (15ULL * 1000ULL * 1000ULL * 1000ULL); /* 15 sec */ 244 245 if (strcmp(name, "io_T") == 0 || strcmp(name, "checksum_T") == 0) 246 return (1000ULL * 1000ULL * 1000ULL * 600ULL); /* 10 min */ 247 248 return (0); 249 } 250 251 /* FMD Statistics */ 252 253 fmd_stat_t * 254 fmd_stat_create(fmd_hdl_t *hdl, uint_t flags, uint_t nstats, fmd_stat_t *statv) 255 { 256 fmd_module_t *mp = (fmd_module_t *)hdl; 257 258 if (flags == FMD_STAT_NOALLOC) { 259 mp->mod_ustat = statv; 260 mp->mod_ustat_cnt = nstats; 261 } 262 263 return (statv); 264 } 265 266 /* Case Management */ 267 268 fmd_case_t * 269 fmd_case_open(fmd_hdl_t *hdl, void *data) 270 { 271 fmd_module_t *mp = (fmd_module_t *)hdl; 272 uuid_t uuid; 273 274 fmd_case_t *cp; 275 276 cp = fmd_hdl_zalloc(hdl, sizeof (fmd_case_t), FMD_SLEEP); 277 cp->ci_mod = hdl; 278 cp->ci_state = FMD_CASE_UNSOLVED; 279 cp->ci_flags = FMD_CF_DIRTY; 280 cp->ci_data = data; 281 cp->ci_bufptr = NULL; 282 cp->ci_bufsiz = 0; 283 284 uuid_generate(uuid); 285 uuid_unparse(uuid, cp->ci_uuid); 286 287 fmd_hdl_debug(hdl, "case opened (%s)", cp->ci_uuid); 288 mp->mod_stats.ms_caseopen.fmds_value.ui64++; 289 290 return (cp); 291 } 292 293 void 294 fmd_case_solve(fmd_hdl_t *hdl, fmd_case_t *cp) 295 { 296 fmd_module_t *mp = (fmd_module_t *)hdl; 297 298 /* 299 * For ZED, the event was already sent from fmd_case_add_suspect() 300 */ 301 302 if (cp->ci_state >= FMD_CASE_SOLVED) 303 fmd_hdl_debug(hdl, "case is already solved or closed"); 304 305 cp->ci_state = FMD_CASE_SOLVED; 306 307 fmd_hdl_debug(hdl, "case solved (%s)", cp->ci_uuid); 308 mp->mod_stats.ms_casesolved.fmds_value.ui64++; 309 } 310 311 void 312 fmd_case_close(fmd_hdl_t *hdl, fmd_case_t *cp) 313 { 314 fmd_module_t *mp = (fmd_module_t *)hdl; 315 const fmd_hdl_ops_t *ops = mp->mod_info->fmdi_ops; 316 317 fmd_hdl_debug(hdl, "case closed (%s)", cp->ci_uuid); 318 319 if (ops->fmdo_close != NULL) 320 ops->fmdo_close(hdl, cp); 321 322 mp->mod_stats.ms_caseopen.fmds_value.ui64--; 323 mp->mod_stats.ms_caseclosed.fmds_value.ui64++; 324 325 if (cp->ci_bufptr != NULL && cp->ci_bufsiz > 0) 326 fmd_hdl_free(hdl, cp->ci_bufptr, cp->ci_bufsiz); 327 328 fmd_hdl_free(hdl, cp, sizeof (fmd_case_t)); 329 } 330 331 void 332 fmd_case_uuresolved(fmd_hdl_t *hdl, const char *uuid) 333 { 334 fmd_hdl_debug(hdl, "case resolved by uuid (%s)", uuid); 335 } 336 337 int 338 fmd_case_solved(fmd_hdl_t *hdl, fmd_case_t *cp) 339 { 340 return ((cp->ci_state >= FMD_CASE_SOLVED) ? FMD_B_TRUE : FMD_B_FALSE); 341 } 342 343 void 344 fmd_case_add_ereport(fmd_hdl_t *hdl, fmd_case_t *cp, fmd_event_t *ep) 345 { 346 } 347 348 static void 349 zed_log_fault(nvlist_t *nvl, const char *uuid, const char *code) 350 { 351 nvlist_t *rsrc; 352 char *strval; 353 uint64_t guid; 354 uint8_t byte; 355 356 zed_log_msg(LOG_INFO, "\nzed_fault_event:"); 357 358 if (uuid != NULL) 359 zed_log_msg(LOG_INFO, "\t%s: %s", FM_SUSPECT_UUID, uuid); 360 if (nvlist_lookup_string(nvl, FM_CLASS, &strval) == 0) 361 zed_log_msg(LOG_INFO, "\t%s: %s", FM_CLASS, strval); 362 if (code != NULL) 363 zed_log_msg(LOG_INFO, "\t%s: %s", FM_SUSPECT_DIAG_CODE, code); 364 if (nvlist_lookup_uint8(nvl, FM_FAULT_CERTAINTY, &byte) == 0) 365 zed_log_msg(LOG_INFO, "\t%s: %llu", FM_FAULT_CERTAINTY, byte); 366 if (nvlist_lookup_nvlist(nvl, FM_FAULT_RESOURCE, &rsrc) == 0) { 367 if (nvlist_lookup_string(rsrc, FM_FMRI_SCHEME, &strval) == 0) 368 zed_log_msg(LOG_INFO, "\t%s: %s", FM_FMRI_SCHEME, 369 strval); 370 if (nvlist_lookup_uint64(rsrc, FM_FMRI_ZFS_POOL, &guid) == 0) 371 zed_log_msg(LOG_INFO, "\t%s: %llu", FM_FMRI_ZFS_POOL, 372 guid); 373 if (nvlist_lookup_uint64(rsrc, FM_FMRI_ZFS_VDEV, &guid) == 0) 374 zed_log_msg(LOG_INFO, "\t%s: %llu \n", FM_FMRI_ZFS_VDEV, 375 guid); 376 } 377 } 378 379 static const char * 380 fmd_fault_mkcode(nvlist_t *fault) 381 { 382 char *class, *code = "-"; 383 384 /* 385 * Note: message codes come from: openzfs/usr/src/cmd/fm/dicts/ZFS.po 386 */ 387 if (nvlist_lookup_string(fault, FM_CLASS, &class) == 0) { 388 if (strcmp(class, "fault.fs.zfs.vdev.io") == 0) 389 code = "ZFS-8000-FD"; 390 else if (strcmp(class, "fault.fs.zfs.vdev.checksum") == 0) 391 code = "ZFS-8000-GH"; 392 else if (strcmp(class, "fault.fs.zfs.io_failure_wait") == 0) 393 code = "ZFS-8000-HC"; 394 else if (strcmp(class, "fault.fs.zfs.io_failure_continue") == 0) 395 code = "ZFS-8000-JQ"; 396 else if (strcmp(class, "fault.fs.zfs.log_replay") == 0) 397 code = "ZFS-8000-K4"; 398 else if (strcmp(class, "fault.fs.zfs.pool") == 0) 399 code = "ZFS-8000-CS"; 400 else if (strcmp(class, "fault.fs.zfs.device") == 0) 401 code = "ZFS-8000-D3"; 402 403 } 404 return (code); 405 } 406 407 void 408 fmd_case_add_suspect(fmd_hdl_t *hdl, fmd_case_t *cp, nvlist_t *fault) 409 { 410 nvlist_t *nvl; 411 const char *code = fmd_fault_mkcode(fault); 412 int64_t tod[2]; 413 int err = 0; 414 415 /* 416 * payload derived from fmd_protocol_list() 417 */ 418 419 (void) gettimeofday(&cp->ci_tv, NULL); 420 tod[0] = cp->ci_tv.tv_sec; 421 tod[1] = cp->ci_tv.tv_usec; 422 423 nvl = fmd_nvl_alloc(hdl, FMD_SLEEP); 424 425 err |= nvlist_add_uint8(nvl, FM_VERSION, FM_SUSPECT_VERSION); 426 err |= nvlist_add_string(nvl, FM_CLASS, FM_LIST_SUSPECT_CLASS); 427 err |= nvlist_add_string(nvl, FM_SUSPECT_UUID, cp->ci_uuid); 428 err |= nvlist_add_string(nvl, FM_SUSPECT_DIAG_CODE, code); 429 err |= nvlist_add_int64_array(nvl, FM_SUSPECT_DIAG_TIME, tod, 2); 430 err |= nvlist_add_uint32(nvl, FM_SUSPECT_FAULT_SZ, 1); 431 err |= nvlist_add_nvlist_array(nvl, FM_SUSPECT_FAULT_LIST, &fault, 1); 432 433 if (err) 434 zed_log_die("failed to populate nvlist"); 435 436 zed_log_fault(fault, cp->ci_uuid, code); 437 zfs_agent_post_event(FM_LIST_SUSPECT_CLASS, NULL, nvl); 438 439 nvlist_free(nvl); 440 nvlist_free(fault); 441 } 442 443 void 444 fmd_case_setspecific(fmd_hdl_t *hdl, fmd_case_t *cp, void *data) 445 { 446 cp->ci_data = data; 447 } 448 449 void * 450 fmd_case_getspecific(fmd_hdl_t *hdl, fmd_case_t *cp) 451 { 452 return (cp->ci_data); 453 } 454 455 void 456 fmd_buf_create(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name, size_t size) 457 { 458 assert(strcmp(name, "data") == 0); 459 assert(cp->ci_bufptr == NULL); 460 assert(size < (1024 * 1024)); 461 462 cp->ci_bufptr = fmd_hdl_alloc(hdl, size, FMD_SLEEP); 463 cp->ci_bufsiz = size; 464 } 465 466 void 467 fmd_buf_read(fmd_hdl_t *hdl, fmd_case_t *cp, 468 const char *name, void *buf, size_t size) 469 { 470 assert(strcmp(name, "data") == 0); 471 assert(cp->ci_bufptr != NULL); 472 assert(size <= cp->ci_bufsiz); 473 474 bcopy(cp->ci_bufptr, buf, size); 475 } 476 477 void 478 fmd_buf_write(fmd_hdl_t *hdl, fmd_case_t *cp, 479 const char *name, const void *buf, size_t size) 480 { 481 assert(strcmp(name, "data") == 0); 482 assert(cp->ci_bufptr != NULL); 483 assert(cp->ci_bufsiz >= size); 484 485 bcopy(buf, cp->ci_bufptr, size); 486 } 487 488 /* SERD Engines */ 489 490 void 491 fmd_serd_create(fmd_hdl_t *hdl, const char *name, uint_t n, hrtime_t t) 492 { 493 fmd_module_t *mp = (fmd_module_t *)hdl; 494 495 if (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL) { 496 zed_log_msg(LOG_ERR, "failed to create SERD engine '%s': " 497 " name already exists", name); 498 return; 499 } 500 501 (void) fmd_serd_eng_insert(&mp->mod_serds, name, n, t); 502 } 503 504 void 505 fmd_serd_destroy(fmd_hdl_t *hdl, const char *name) 506 { 507 fmd_module_t *mp = (fmd_module_t *)hdl; 508 509 fmd_serd_eng_delete(&mp->mod_serds, name); 510 511 fmd_hdl_debug(hdl, "serd_destroy %s", name); 512 } 513 514 int 515 fmd_serd_exists(fmd_hdl_t *hdl, const char *name) 516 { 517 fmd_module_t *mp = (fmd_module_t *)hdl; 518 519 return (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL); 520 } 521 522 void 523 fmd_serd_reset(fmd_hdl_t *hdl, const char *name) 524 { 525 fmd_module_t *mp = (fmd_module_t *)hdl; 526 fmd_serd_eng_t *sgp; 527 528 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 529 zed_log_msg(LOG_ERR, "serd engine '%s' does not exist", name); 530 return; 531 } 532 533 fmd_serd_eng_reset(sgp); 534 535 fmd_hdl_debug(hdl, "serd_reset %s", name); 536 } 537 538 int 539 fmd_serd_record(fmd_hdl_t *hdl, const char *name, fmd_event_t *ep) 540 { 541 fmd_module_t *mp = (fmd_module_t *)hdl; 542 fmd_serd_eng_t *sgp; 543 int err; 544 545 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 546 zed_log_msg(LOG_ERR, "failed to add record to SERD engine '%s'", 547 name); 548 return (FMD_B_FALSE); 549 } 550 err = fmd_serd_eng_record(sgp, ep->ev_hrt); 551 552 return (err); 553 } 554 555 /* FMD Timers */ 556 557 static void 558 _timer_notify(union sigval sv) 559 { 560 fmd_timer_t *ftp = sv.sival_ptr; 561 fmd_hdl_t *hdl = ftp->ft_hdl; 562 fmd_module_t *mp = (fmd_module_t *)hdl; 563 const fmd_hdl_ops_t *ops = mp->mod_info->fmdi_ops; 564 struct itimerspec its; 565 566 fmd_hdl_debug(hdl, "timer fired (%p)", ftp->ft_tid); 567 568 /* disarm the timer */ 569 bzero(&its, sizeof (struct itimerspec)); 570 timer_settime(ftp->ft_tid, 0, &its, NULL); 571 572 /* Note that the fmdo_timeout can remove this timer */ 573 if (ops->fmdo_timeout != NULL) 574 ops->fmdo_timeout(hdl, ftp, ftp->ft_arg); 575 } 576 577 /* 578 * Install a new timer which will fire at least delta nanoseconds after the 579 * current time. After the timeout has expired, the module's fmdo_timeout 580 * entry point is called. 581 */ 582 fmd_timer_t * 583 fmd_timer_install(fmd_hdl_t *hdl, void *arg, fmd_event_t *ep, hrtime_t delta) 584 { 585 struct sigevent sev; 586 struct itimerspec its; 587 fmd_timer_t *ftp; 588 589 ftp = fmd_hdl_alloc(hdl, sizeof (fmd_timer_t), FMD_SLEEP); 590 ftp->ft_arg = arg; 591 ftp->ft_hdl = hdl; 592 593 its.it_value.tv_sec = delta / 1000000000; 594 its.it_value.tv_nsec = delta % 1000000000; 595 its.it_interval.tv_sec = its.it_value.tv_sec; 596 its.it_interval.tv_nsec = its.it_value.tv_nsec; 597 598 sev.sigev_notify = SIGEV_THREAD; 599 sev.sigev_notify_function = _timer_notify; 600 sev.sigev_notify_attributes = NULL; 601 sev.sigev_value.sival_ptr = ftp; 602 603 timer_create(CLOCK_REALTIME, &sev, &ftp->ft_tid); 604 timer_settime(ftp->ft_tid, 0, &its, NULL); 605 606 fmd_hdl_debug(hdl, "installing timer for %d secs (%p)", 607 (int)its.it_value.tv_sec, ftp->ft_tid); 608 609 return (ftp); 610 } 611 612 void 613 fmd_timer_remove(fmd_hdl_t *hdl, fmd_timer_t *ftp) 614 { 615 fmd_hdl_debug(hdl, "removing timer (%p)", ftp->ft_tid); 616 617 timer_delete(ftp->ft_tid); 618 619 fmd_hdl_free(hdl, ftp, sizeof (fmd_timer_t)); 620 } 621 622 /* Name-Value Pair Lists */ 623 624 nvlist_t * 625 fmd_nvl_create_fault(fmd_hdl_t *hdl, const char *class, uint8_t certainty, 626 nvlist_t *asru, nvlist_t *fru, nvlist_t *resource) 627 { 628 nvlist_t *nvl; 629 int err = 0; 630 631 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 632 zed_log_die("failed to xalloc fault nvlist"); 633 634 err |= nvlist_add_uint8(nvl, FM_VERSION, FM_FAULT_VERSION); 635 err |= nvlist_add_string(nvl, FM_CLASS, class); 636 err |= nvlist_add_uint8(nvl, FM_FAULT_CERTAINTY, certainty); 637 638 if (asru != NULL) 639 err |= nvlist_add_nvlist(nvl, FM_FAULT_ASRU, asru); 640 if (fru != NULL) 641 err |= nvlist_add_nvlist(nvl, FM_FAULT_FRU, fru); 642 if (resource != NULL) 643 err |= nvlist_add_nvlist(nvl, FM_FAULT_RESOURCE, resource); 644 645 if (err) 646 zed_log_die("failed to populate nvlist: %s\n", strerror(err)); 647 648 return (nvl); 649 } 650 651 /* 652 * sourced from fmd_string.c 653 */ 654 static int 655 fmd_strmatch(const char *s, const char *p) 656 { 657 char c; 658 659 if (p == NULL) 660 return (0); 661 662 if (s == NULL) 663 s = ""; /* treat NULL string as the empty string */ 664 665 do { 666 if ((c = *p++) == '\0') 667 return (*s == '\0'); 668 669 if (c == '*') { 670 while (*p == '*') 671 p++; /* consecutive *'s can be collapsed */ 672 673 if (*p == '\0') 674 return (1); 675 676 while (*s != '\0') { 677 if (fmd_strmatch(s++, p) != 0) 678 return (1); 679 } 680 681 return (0); 682 } 683 } while (c == *s++); 684 685 return (0); 686 } 687 688 int 689 fmd_nvl_class_match(fmd_hdl_t *hdl, nvlist_t *nvl, const char *pattern) 690 { 691 char *class; 692 693 return (nvl != NULL && 694 nvlist_lookup_string(nvl, FM_CLASS, &class) == 0 && 695 fmd_strmatch(class, pattern)); 696 } 697 698 nvlist_t * 699 fmd_nvl_alloc(fmd_hdl_t *hdl, int flags) 700 { 701 nvlist_t *nvl = NULL; 702 703 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 704 return (NULL); 705 706 return (nvl); 707 } 708 709 710 /* 711 * ZED Agent specific APIs 712 */ 713 714 fmd_hdl_t * 715 fmd_module_hdl(const char *name) 716 { 717 if (strcmp(name, "zfs-retire") == 0) 718 return ((fmd_hdl_t *)&zfs_retire_module); 719 if (strcmp(name, "zfs-diagnosis") == 0) 720 return ((fmd_hdl_t *)&zfs_diagnosis_module); 721 722 return (NULL); 723 } 724 725 boolean_t 726 fmd_module_initialized(fmd_hdl_t *hdl) 727 { 728 fmd_module_t *mp = (fmd_module_t *)hdl; 729 730 return (mp->mod_info != NULL); 731 } 732 733 /* 734 * fmd_module_recv is called for each event that is received by 735 * the fault manager that has a class that matches one of the 736 * module's subscriptions. 737 */ 738 void 739 fmd_module_recv(fmd_hdl_t *hdl, nvlist_t *nvl, const char *class) 740 { 741 fmd_module_t *mp = (fmd_module_t *)hdl; 742 const fmd_hdl_ops_t *ops = mp->mod_info->fmdi_ops; 743 fmd_event_t faux_event = {0}; 744 int64_t *tv; 745 uint_t n; 746 747 /* 748 * Will need to normalized this if we persistently store the case data 749 */ 750 if (nvlist_lookup_int64_array(nvl, FM_EREPORT_TIME, &tv, &n) == 0) 751 faux_event.ev_hrt = tv[0] * NANOSEC + tv[1]; 752 else 753 faux_event.ev_hrt = 0; 754 755 ops->fmdo_recv(hdl, &faux_event, nvl, class); 756 757 mp->mod_stats.ms_accepted.fmds_value.ui64++; 758 759 /* TBD - should we initiate fm_module_gc() periodically? */ 760 } 761