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 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/fm/protocol.h> 29 #include <fm/topo_hc.h> 30 31 #include <unistd.h> 32 #include <signal.h> 33 #include <limits.h> 34 #include <syslog.h> 35 #include <alloca.h> 36 #include <stddef.h> 37 38 #include <fmd_module.h> 39 #include <fmd_api.h> 40 #include <fmd_string.h> 41 #include <fmd_subr.h> 42 #include <fmd_error.h> 43 #include <fmd_event.h> 44 #include <fmd_eventq.h> 45 #include <fmd_dispq.h> 46 #include <fmd_timerq.h> 47 #include <fmd_thread.h> 48 #include <fmd_ustat.h> 49 #include <fmd_case.h> 50 #include <fmd_protocol.h> 51 #include <fmd_buf.h> 52 #include <fmd_asru.h> 53 #include <fmd_fmri.h> 54 #include <fmd_topo.h> 55 #include <fmd_ckpt.h> 56 #include <fmd_xprt.h> 57 58 #include <fmd.h> 59 60 /* 61 * Table of configuration file variable types ops-vector pointers. We use this 62 * to convert from the property description array specified by the module to an 63 * array of fmd_conf_formal_t's. The order of this array must match the order 64 * of #define values specified in <fmd_api.h> (i.e. FMD_TYPE_BOOL must be 0). 65 * For now, the fmd_conf_list and fmd_conf_path types are not supported as we 66 * do not believe modules need them and they would require more complexity. 67 */ 68 static const fmd_conf_ops_t *const _fmd_prop_ops[] = { 69 &fmd_conf_bool, /* FMD_TYPE_BOOL */ 70 &fmd_conf_int32, /* FMD_TYPE_INT32 */ 71 &fmd_conf_uint32, /* FMD_TYPE_UINT32 */ 72 &fmd_conf_int64, /* FMD_TYPE_INT64 */ 73 &fmd_conf_uint64, /* FMD_TYPE_UINT64 */ 74 &fmd_conf_string, /* FMD_TYPE_STRING */ 75 &fmd_conf_time, /* FMD_TYPE_TIME */ 76 &fmd_conf_size, /* FMD_TYPE_SIZE */ 77 }; 78 79 static void fmd_api_verror(fmd_module_t *, int, const char *, va_list) 80 __NORETURN; 81 static void fmd_api_error(fmd_module_t *, int, const char *, ...) __NORETURN; 82 83 /* 84 * fmd_api_vxerror() provides the engine underlying the fmd_hdl_[v]error() API 85 * calls and the fmd_api_[v]error() utility routine defined below. The routine 86 * formats the error, optionally associated with a particular errno code 'err', 87 * and logs it as an ereport associated with the calling module. Depending on 88 * other optional properties, we also emit a message to stderr and to syslog. 89 */ 90 static void 91 fmd_api_vxerror(fmd_module_t *mp, int err, const char *format, va_list ap) 92 { 93 int raw_err = err; 94 nvlist_t *nvl; 95 fmd_event_t *e; 96 char *class, *msg; 97 size_t len1, len2; 98 char c; 99 100 /* 101 * fmd_api_vxerror() counts as both an error of class EFMD_MODULE 102 * as well as an instance of 'err' w.r.t. our internal bean counters. 103 */ 104 (void) pthread_mutex_lock(&fmd.d_err_lock); 105 fmd.d_errstats[EFMD_MODULE - EFMD_UNKNOWN].fmds_value.ui64++; 106 107 if (err > EFMD_UNKNOWN && err < EFMD_END) 108 fmd.d_errstats[err - EFMD_UNKNOWN].fmds_value.ui64++; 109 110 (void) pthread_mutex_unlock(&fmd.d_err_lock); 111 112 /* 113 * Format the message using vsnprintf(). As usual, if the format has a 114 * newline in it, it is printed alone; otherwise strerror() is added. 115 */ 116 if (strchr(format, '\n') != NULL) 117 err = 0; /* err is not relevant in the message */ 118 119 len1 = vsnprintf(&c, 1, format, ap); 120 len2 = err != 0 ? snprintf(&c, 1, ": %s\n", fmd_strerror(err)) : 0; 121 122 msg = fmd_alloc(len1 + len2 + 1, FMD_SLEEP); 123 (void) vsnprintf(msg, len1 + 1, format, ap); 124 125 if (err != 0) { 126 (void) snprintf(&msg[len1], len2 + 1, 127 ": %s\n", fmd_strerror(err)); 128 } 129 130 /* 131 * Create an error event corresponding to the error, insert it into the 132 * error log, and dispatch it to the fmd-self-diagnosis engine. 133 */ 134 if (mp != fmd.d_self && (raw_err != EFMD_HDL_ABORT || fmd.d_running)) { 135 if ((c = msg[len1 + len2 - 1]) == '\n') 136 msg[len1 + len2 - 1] = '\0'; /* strip \n for event */ 137 138 nvl = fmd_protocol_moderror(mp, err, msg); 139 140 if (c == '\n') 141 msg[len1 + len2 - 1] = c; 142 143 (void) nvlist_lookup_string(nvl, FM_CLASS, &class); 144 e = fmd_event_create(FMD_EVT_PROTOCOL, FMD_HRT_NOW, nvl, class); 145 146 (void) pthread_rwlock_rdlock(&fmd.d_log_lock); 147 fmd_log_append(fmd.d_errlog, e, NULL); 148 (void) pthread_rwlock_unlock(&fmd.d_log_lock); 149 150 fmd_event_transition(e, FMD_EVS_ACCEPTED); 151 fmd_event_commit(e); 152 153 fmd_dispq_dispatch(fmd.d_disp, e, class); 154 } 155 156 /* 157 * Similar to fmd_vdebug(), if the debugging switches are enabled we 158 * echo the module name and message to stderr and/or syslog. Unlike 159 * fmd_vdebug(), we also print to stderr if foreground mode is enabled. 160 * We also print the message if a built-in module is aborting before 161 * fmd has detached from its parent (e.g. default transport failure). 162 */ 163 if (fmd.d_fg || (fmd.d_hdl_dbout & FMD_DBOUT_STDERR) || ( 164 raw_err == EFMD_HDL_ABORT && !fmd.d_running)) { 165 (void) pthread_mutex_lock(&fmd.d_err_lock); 166 (void) fprintf(stderr, "%s: %s: %s", 167 fmd.d_pname, mp->mod_name, msg); 168 (void) pthread_mutex_unlock(&fmd.d_err_lock); 169 } 170 171 if (fmd.d_hdl_dbout & FMD_DBOUT_SYSLOG) { 172 syslog(LOG_ERR | LOG_DAEMON, "%s ERROR: %s: %s", 173 fmd.d_pname, mp->mod_name, msg); 174 } 175 176 fmd_free(msg, len1 + len2 + 1); 177 } 178 179 /*PRINTFLIKE3*/ 180 static void 181 fmd_api_xerror(fmd_module_t *mp, int err, const char *format, ...) 182 { 183 va_list ap; 184 185 va_start(ap, format); 186 fmd_api_vxerror(mp, err, format, ap); 187 va_end(ap); 188 } 189 190 /* 191 * fmd_api_verror() is a wrapper around fmd_api_vxerror() for API subroutines. 192 * It calls fmd_module_unlock() on behalf of its caller, logs the error, and 193 * then aborts the API call and the surrounding module entry point by doing an 194 * fmd_module_abort(), which longjmps to the place where we entered the module. 195 */ 196 static void 197 fmd_api_verror(fmd_module_t *mp, int err, const char *format, va_list ap) 198 { 199 if (fmd_module_locked(mp)) 200 fmd_module_unlock(mp); 201 202 fmd_api_vxerror(mp, err, format, ap); 203 fmd_module_abort(mp, err); 204 } 205 206 /*PRINTFLIKE3*/ 207 static void 208 fmd_api_error(fmd_module_t *mp, int err, const char *format, ...) 209 { 210 va_list ap; 211 212 va_start(ap, format); 213 fmd_api_verror(mp, err, format, ap); 214 va_end(ap); 215 } 216 217 /* 218 * Common code for fmd_api_module_lock() and fmd_api_transport_impl(). This 219 * code verifies that the handle is valid and associated with a proper thread. 220 */ 221 static fmd_module_t * 222 fmd_api_module(fmd_hdl_t *hdl) 223 { 224 fmd_thread_t *tp; 225 fmd_module_t *mp; 226 227 /* 228 * If our TSD is not present at all, this is either a serious bug or 229 * someone has created a thread behind our back and is using fmd's API. 230 * We can't call fmd_api_error() because we can't be sure that we can 231 * unwind our state back to an enclosing fmd_module_dispatch(), so we 232 * must panic instead. This is likely a module design or coding error. 233 */ 234 if ((tp = pthread_getspecific(fmd.d_key)) == NULL) { 235 fmd_panic("fmd module api call made using " 236 "client handle %p from unknown thread\n", (void *)hdl); 237 } 238 239 /* 240 * If our TSD refers to the root module and is a door server thread, 241 * then it was created asynchronously at the request of a module but 242 * is using now the module API as an auxiliary module thread. We reset 243 * tp->thr_mod to the module handle so it can act as a module thread. 244 */ 245 if (tp->thr_mod == fmd.d_rmod && tp->thr_func == &fmd_door_server) 246 tp->thr_mod = (fmd_module_t *)hdl; 247 248 if ((mp = tp->thr_mod) != (fmd_module_t *)hdl) { 249 fmd_api_error(mp, EFMD_HDL_INVAL, 250 "client handle %p is not valid\n", (void *)hdl); 251 } 252 253 if (mp->mod_flags & FMD_MOD_FAIL) { 254 fmd_api_error(mp, EFMD_MOD_FAIL, 255 "module has experienced an unrecoverable error\n"); 256 } 257 258 return (mp); 259 } 260 261 /* 262 * fmd_api_module_lock() is used as a wrapper around fmd_module_lock() and a 263 * common prologue to each fmd_api.c routine. It verifies that the handle is 264 * valid and owned by the current server thread, locks the handle, and then 265 * verifies that the caller is performing an operation on a registered handle. 266 * If any tests fail, the entire API call is aborted by fmd_api_error(). 267 */ 268 static fmd_module_t * 269 fmd_api_module_lock(fmd_hdl_t *hdl) 270 { 271 fmd_module_t *mp = fmd_api_module(hdl); 272 273 fmd_module_lock(mp); 274 275 if (mp->mod_info == NULL) { 276 fmd_api_error(mp, EFMD_HDL_NOTREG, 277 "client handle %p has not been registered\n", (void *)hdl); 278 } 279 280 return (mp); 281 } 282 283 /* 284 * Utility function for API entry points that accept fmd_case_t's. We cast cp 285 * to fmd_case_impl_t and check to make sure the case is owned by the caller. 286 */ 287 static fmd_case_impl_t * 288 fmd_api_case_impl(fmd_module_t *mp, fmd_case_t *cp) 289 { 290 fmd_case_impl_t *cip = (fmd_case_impl_t *)cp; 291 292 if (cip == NULL || cip->ci_mod != mp) { 293 fmd_api_error(mp, EFMD_CASE_OWNER, 294 "case %p is invalid or not owned by caller\n", (void *)cip); 295 } 296 297 return (cip); 298 } 299 300 /* 301 * Utility function for API entry points that accept fmd_xprt_t's. We cast xp 302 * to fmd_transport_t and check to make sure the case is owned by the caller. 303 * Note that we could make this check safer by actually walking mp's transport 304 * list, but that requires holding the module lock and this routine needs to be 305 * MT-hot w.r.t. auxiliary module threads. Ultimately any loadable module can 306 * cause us to crash anyway, so we optimize for scalability over safety here. 307 */ 308 static fmd_xprt_impl_t * 309 fmd_api_transport_impl(fmd_hdl_t *hdl, fmd_xprt_t *xp) 310 { 311 fmd_module_t *mp = fmd_api_module(hdl); 312 fmd_xprt_impl_t *xip = (fmd_xprt_impl_t *)xp; 313 314 if (xip == NULL || xip->xi_queue->eq_mod != mp) { 315 fmd_api_error(mp, EFMD_XPRT_OWNER, 316 "xprt %p is invalid or not owned by caller\n", (void *)xp); 317 } 318 319 return (xip); 320 } 321 322 /* 323 * fmd_hdl_register() is the one function which cannot use fmd_api_error() to 324 * report errors, because that routine causes the module to abort. Failure to 325 * register is instead handled by having fmd_hdl_register() return an error to 326 * the _fmd_init() function and then detecting no registration when it returns. 327 * So we use this routine for fmd_hdl_register() error paths instead. 328 */ 329 static int 330 fmd_hdl_register_error(fmd_module_t *mp, int err) 331 { 332 if (fmd_module_locked(mp)) 333 fmd_module_unlock(mp); 334 335 fmd_api_xerror(mp, err, "failed to register"); 336 return (fmd_set_errno(err)); 337 } 338 339 static void 340 fmd_hdl_nop(void) 341 { 342 /* empty function for use with unspecified module entry points */ 343 } 344 345 int 346 fmd_hdl_register(fmd_hdl_t *hdl, int version, const fmd_hdl_info_t *mip) 347 { 348 fmd_thread_t *tp = pthread_getspecific(fmd.d_key); 349 fmd_module_t *mp = tp->thr_mod; 350 351 const fmd_prop_t *prop; 352 const fmd_conf_path_t *pap; 353 fmd_conf_formal_t *cfp; 354 fmd_hdl_ops_t ops; 355 356 const char *conf = NULL; 357 char buf[PATH_MAX]; 358 int i; 359 360 if (mp != (fmd_module_t *)hdl) 361 return (fmd_hdl_register_error(mp, EFMD_HDL_INVAL)); 362 363 fmd_module_lock(mp); 364 365 /* 366 * First perform some sanity checks on our input. The API version must 367 * be supported by FMD and the handle can only be registered once by 368 * the module thread to which we assigned this client handle. The info 369 * provided for the handle must be valid and have the minimal settings. 370 */ 371 if (version > FMD_API_VERSION_4) 372 return (fmd_hdl_register_error(mp, EFMD_VER_NEW)); 373 374 if (version < FMD_API_VERSION_1) 375 return (fmd_hdl_register_error(mp, EFMD_VER_OLD)); 376 377 if (mp->mod_conf != NULL) 378 return (fmd_hdl_register_error(mp, EFMD_HDL_REG)); 379 380 if (pthread_self() != mp->mod_thread->thr_tid) 381 return (fmd_hdl_register_error(mp, EFMD_HDL_TID)); 382 383 if (mip == NULL || mip->fmdi_desc == NULL || 384 mip->fmdi_vers == NULL || mip->fmdi_ops == NULL) 385 return (fmd_hdl_register_error(mp, EFMD_HDL_INFO)); 386 387 /* 388 * Copy the module's ops vector into a local variable to account for 389 * changes in the module ABI. Then if any of the optional entry points 390 * are NULL, set them to nop so we don't have to check before calling. 391 */ 392 bzero(&ops, sizeof (ops)); 393 394 if (version < FMD_API_VERSION_3) 395 bcopy(mip->fmdi_ops, &ops, offsetof(fmd_hdl_ops_t, fmdo_send)); 396 else if (version < FMD_API_VERSION_4) 397 bcopy(mip->fmdi_ops, &ops, 398 offsetof(fmd_hdl_ops_t, fmdo_topo)); 399 else 400 bcopy(mip->fmdi_ops, &ops, sizeof (ops)); 401 402 if (ops.fmdo_recv == NULL) 403 ops.fmdo_recv = (void (*)())fmd_hdl_nop; 404 if (ops.fmdo_timeout == NULL) 405 ops.fmdo_timeout = (void (*)())fmd_hdl_nop; 406 if (ops.fmdo_close == NULL) 407 ops.fmdo_close = (void (*)())fmd_hdl_nop; 408 if (ops.fmdo_stats == NULL) 409 ops.fmdo_stats = (void (*)())fmd_hdl_nop; 410 if (ops.fmdo_gc == NULL) 411 ops.fmdo_gc = (void (*)())fmd_hdl_nop; 412 if (ops.fmdo_send == NULL) 413 ops.fmdo_send = (int (*)())fmd_hdl_nop; 414 if (ops.fmdo_topo == NULL) 415 ops.fmdo_topo = (void (*)())fmd_hdl_nop; 416 417 /* 418 * Make two passes through the property array to initialize the formals 419 * to use for processing the module's .conf file. In the first pass, 420 * we validate the types and count the number of properties. In the 421 * second pass we copy the strings and fill in the appropriate ops. 422 */ 423 for (prop = mip->fmdi_props, i = 0; prop != NULL && 424 prop->fmdp_name != NULL; prop++, i++) { 425 if (prop->fmdp_type >= 426 sizeof (_fmd_prop_ops) / sizeof (_fmd_prop_ops[0])) { 427 fmd_api_xerror(mp, EFMD_HDL_PROP, 428 "property %s uses invalid type %u\n", 429 prop->fmdp_name, prop->fmdp_type); 430 return (fmd_hdl_register_error(mp, EFMD_HDL_PROP)); 431 } 432 } 433 434 mp->mod_argc = i; 435 mp->mod_argv = fmd_zalloc(sizeof (fmd_conf_formal_t) * i, FMD_SLEEP); 436 437 prop = mip->fmdi_props; 438 cfp = mp->mod_argv; 439 440 for (i = 0; i < mp->mod_argc; i++, prop++, cfp++) { 441 cfp->cf_name = fmd_strdup(prop->fmdp_name, FMD_SLEEP); 442 cfp->cf_ops = _fmd_prop_ops[prop->fmdp_type]; 443 cfp->cf_default = fmd_strdup(prop->fmdp_defv, FMD_SLEEP); 444 } 445 446 /* 447 * If this module came from an on-disk file, compute the name of the 448 * corresponding .conf file and parse properties from it if it exists. 449 */ 450 if (mp->mod_path != NULL) { 451 (void) strlcpy(buf, mp->mod_path, sizeof (buf)); 452 (void) fmd_strdirname(buf); 453 454 (void) strlcat(buf, "/", sizeof (buf)); 455 (void) strlcat(buf, mp->mod_name, sizeof (buf)); 456 (void) strlcat(buf, ".conf", sizeof (buf)); 457 458 if (access(buf, F_OK) == 0) 459 conf = buf; 460 } 461 462 if ((mp->mod_conf = fmd_conf_open(conf, 463 mp->mod_argc, mp->mod_argv, 0)) == NULL) 464 return (fmd_hdl_register_error(mp, EFMD_MOD_CONF)); 465 466 fmd_conf_propagate(fmd.d_conf, mp->mod_conf, mp->mod_name); 467 468 /* 469 * Look up the list of the libdiagcode dictionaries associated with the 470 * module. If none were specified, use the value from daemon's config. 471 * We only fail if the module specified an explicit dictionary. 472 */ 473 (void) fmd_conf_getprop(mp->mod_conf, FMD_PROP_DICTIONARIES, &pap); 474 if (pap->cpa_argc == 0 && mp->mod_ops == &fmd_bltin_ops) 475 (void) fmd_conf_getprop(fmd.d_conf, "self.dict", &pap); 476 477 for (i = 0; i < pap->cpa_argc; i++) { 478 if (fmd_module_dc_opendict(mp, pap->cpa_argv[i]) != 0) { 479 fmd_api_xerror(mp, errno, 480 "failed to open dictionary %s", pap->cpa_argv[i]); 481 return (fmd_hdl_register_error(mp, EFMD_MOD_CONF)); 482 } 483 } 484 485 /* 486 * Make a copy of the handle information and store it in mod_info. We 487 * do not need to bother copying fmdi_props since they're already read. 488 */ 489 mp->mod_info = fmd_alloc(sizeof (fmd_hdl_info_t), FMD_SLEEP); 490 mp->mod_info->fmdi_desc = fmd_strdup(mip->fmdi_desc, FMD_SLEEP); 491 mp->mod_info->fmdi_vers = fmd_strdup(mip->fmdi_vers, FMD_SLEEP); 492 mp->mod_info->fmdi_ops = fmd_alloc(sizeof (fmd_hdl_ops_t), FMD_SLEEP); 493 bcopy(&ops, (void *)mp->mod_info->fmdi_ops, sizeof (fmd_hdl_ops_t)); 494 mp->mod_info->fmdi_props = NULL; 495 496 /* 497 * Store a copy of module version in mp for fmd_scheme_fmd_present() 498 */ 499 if (mp->mod_vers == NULL) 500 mp->mod_vers = fmd_strdup(mip->fmdi_vers, FMD_SLEEP); 501 502 /* 503 * Allocate an FMRI representing this module. We'll use this later 504 * if the module decides to publish any events (e.g. list.suspects). 505 */ 506 mp->mod_fmri = fmd_protocol_fmri_module(mp); 507 508 /* 509 * Any subscriptions specified in the conf file are now stored in the 510 * corresponding property. Add all of these to the dispatch queue. 511 */ 512 (void) fmd_conf_getprop(mp->mod_conf, FMD_PROP_SUBSCRIPTIONS, &pap); 513 514 for (i = 0; i < pap->cpa_argc; i++) { 515 fmd_dispq_insert(fmd.d_disp, mp->mod_queue, pap->cpa_argv[i]); 516 fmd_xprt_subscribe_all(pap->cpa_argv[i]); 517 } 518 519 /* 520 * Unlock the module and restore any pre-existing module checkpoint. 521 * If the checkpoint is missing or corrupt, we just keep going. 522 */ 523 fmd_module_unlock(mp); 524 fmd_ckpt_restore(mp); 525 return (0); 526 } 527 528 /* 529 * If an auxiliary thread exists for the specified module at unregistration 530 * time, send it an asynchronous cancellation to force it to exit and then 531 * join with it (we expect this to either succeed quickly or return ESRCH). 532 * Once this is complete we can destroy the associated fmd_thread_t data. 533 */ 534 static void 535 fmd_module_thrcancel(fmd_idspace_t *ids, id_t id, fmd_module_t *mp) 536 { 537 fmd_thread_t *tp = fmd_idspace_getspecific(ids, id); 538 539 fmd_dprintf(FMD_DBG_MOD, "cancelling %s auxiliary thread %u\n", 540 mp->mod_name, tp->thr_tid); 541 542 ASSERT(tp->thr_tid == id); 543 (void) pthread_cancel(tp->thr_tid); 544 (void) pthread_join(tp->thr_tid, NULL); 545 546 fmd_thread_destroy(tp, FMD_THREAD_NOJOIN); 547 } 548 549 void 550 fmd_module_unregister(fmd_module_t *mp) 551 { 552 fmd_conf_formal_t *cfp = mp->mod_argv; 553 const fmd_conf_path_t *pap; 554 fmd_case_t *cp; 555 fmd_xprt_t *xp; 556 int i; 557 558 TRACE((FMD_DBG_MOD, "unregister %p (%s)", (void *)mp, mp->mod_name)); 559 ASSERT(fmd_module_locked(mp)); 560 561 /* 562 * If any transports are still open, they have send threads that are 563 * using the module handle: shut them down and join with these threads. 564 */ 565 while ((xp = fmd_list_next(&mp->mod_transports)) != NULL) 566 fmd_xprt_destroy(xp); 567 568 /* 569 * If any auxiliary threads exist, they may be using our module handle, 570 * and therefore could cause a fault as soon as we start destroying it. 571 * Module writers should clean up any threads before unregistering: we 572 * forcibly cancel any remaining auxiliary threads before proceeding. 573 */ 574 fmd_idspace_apply(mp->mod_threads, 575 (void (*)())fmd_module_thrcancel, mp); 576 577 if (mp->mod_error == 0) 578 fmd_ckpt_save(mp); /* take one more checkpoint if needed */ 579 580 /* 581 * Delete any cases associated with the module (UNSOLVED, SOLVED, or 582 * CLOSE_WAIT) as if fmdo_close() has finished processing them. 583 */ 584 while ((cp = fmd_list_next(&mp->mod_cases)) != NULL) 585 fmd_case_delete(cp); 586 587 fmd_ustat_delete_references(mp->mod_ustat); 588 (void) fmd_conf_getprop(mp->mod_conf, FMD_PROP_SUBSCRIPTIONS, &pap); 589 590 for (i = 0; i < pap->cpa_argc; i++) { 591 fmd_xprt_unsubscribe_all(pap->cpa_argv[i]); 592 fmd_dispq_delete(fmd.d_disp, mp->mod_queue, pap->cpa_argv[i]); 593 } 594 595 fmd_conf_close(mp->mod_conf); 596 mp->mod_conf = NULL; 597 598 for (i = 0; i < mp->mod_argc; i++, cfp++) { 599 fmd_strfree((char *)cfp->cf_name); 600 fmd_strfree((char *)cfp->cf_default); 601 } 602 603 fmd_free(mp->mod_argv, sizeof (fmd_conf_formal_t) * mp->mod_argc); 604 mp->mod_argv = NULL; 605 mp->mod_argc = 0; 606 607 nvlist_free(mp->mod_fmri); 608 mp->mod_fmri = NULL; 609 610 fmd_strfree((char *)mp->mod_info->fmdi_desc); 611 fmd_strfree((char *)mp->mod_info->fmdi_vers); 612 fmd_free((void *)mp->mod_info->fmdi_ops, sizeof (fmd_hdl_ops_t)); 613 fmd_free(mp->mod_info, sizeof (fmd_hdl_info_t)); 614 mp->mod_info = NULL; 615 616 fmd_eventq_abort(mp->mod_queue); 617 } 618 619 void 620 fmd_hdl_unregister(fmd_hdl_t *hdl) 621 { 622 fmd_module_t *mp = fmd_api_module_lock(hdl); 623 fmd_module_unregister(mp); 624 fmd_module_unlock(mp); 625 } 626 627 void 628 fmd_hdl_subscribe(fmd_hdl_t *hdl, const char *class) 629 { 630 fmd_module_t *mp = fmd_api_module_lock(hdl); 631 632 if (fmd_conf_setprop(mp->mod_conf, 633 FMD_PROP_SUBSCRIPTIONS, class) == 0) { 634 fmd_dispq_insert(fmd.d_disp, mp->mod_queue, class); 635 fmd_xprt_subscribe_all(class); 636 } 637 638 fmd_module_unlock(mp); 639 } 640 641 642 void 643 fmd_hdl_unsubscribe(fmd_hdl_t *hdl, const char *class) 644 { 645 fmd_module_t *mp = fmd_api_module_lock(hdl); 646 647 if (fmd_conf_delprop(mp->mod_conf, 648 FMD_PROP_SUBSCRIPTIONS, class) == 0) { 649 fmd_xprt_unsubscribe_all(class); 650 fmd_dispq_delete(fmd.d_disp, mp->mod_queue, class); 651 } 652 653 fmd_module_unlock(mp); 654 fmd_eventq_cancel(mp->mod_queue, FMD_EVT_PROTOCOL, (void *)class); 655 } 656 657 void 658 fmd_hdl_setspecific(fmd_hdl_t *hdl, void *spec) 659 { 660 fmd_module_t *mp = fmd_api_module_lock(hdl); 661 662 mp->mod_spec = spec; 663 fmd_module_unlock(mp); 664 } 665 666 void * 667 fmd_hdl_getspecific(fmd_hdl_t *hdl) 668 { 669 fmd_module_t *mp = fmd_api_module_lock(hdl); 670 void *spec = mp->mod_spec; 671 672 fmd_module_unlock(mp); 673 return (spec); 674 } 675 676 void 677 fmd_hdl_opendict(fmd_hdl_t *hdl, const char *dict) 678 { 679 fmd_module_t *mp = fmd_api_module_lock(hdl); 680 const fmd_conf_path_t *pap; 681 int i; 682 683 /* 684 * Update the dictionary property in order to preserve the list of 685 * pathnames and expand any % tokens in the path. Then retrieve the 686 * new dictionary names from cpa_argv[] and open them one at a time. 687 */ 688 (void) fmd_conf_setprop(mp->mod_conf, FMD_PROP_DICTIONARIES, dict); 689 (void) fmd_conf_getprop(mp->mod_conf, FMD_PROP_DICTIONARIES, &pap); 690 691 ASSERT(pap->cpa_argc > mp->mod_dictc); 692 693 for (i = mp->mod_dictc; i < pap->cpa_argc; i++) { 694 if (fmd_module_dc_opendict(mp, pap->cpa_argv[i]) != 0) { 695 fmd_api_error(mp, EFMD_MOD_DICT, 696 "failed to open dictionary %s for module %s", 697 pap->cpa_argv[i], mp->mod_name); 698 } 699 } 700 701 fmd_module_unlock(mp); 702 } 703 704 topo_hdl_t * 705 fmd_hdl_topo_hold(fmd_hdl_t *hdl, int v) 706 { 707 fmd_module_t *mp = fmd_api_module_lock(hdl); 708 topo_hdl_t *thp; 709 710 if (v != TOPO_VERSION) { 711 fmd_api_error(mp, EFMD_MOD_TOPO, "libtopo version mismatch: " 712 "fmd version %d != client version %d\n", TOPO_VERSION, v); 713 } 714 715 thp = fmd_module_topo_hold(mp); 716 ASSERT(thp != NULL); 717 718 fmd_module_unlock(mp); 719 return (thp); 720 } 721 722 void 723 fmd_hdl_topo_rele(fmd_hdl_t *hdl, topo_hdl_t *thp) 724 { 725 fmd_module_t *mp = fmd_api_module_lock(hdl); 726 727 if (fmd_module_topo_rele(mp, thp) != 0) 728 fmd_api_error(mp, EFMD_MOD_TOPO, "failed to release invalid " 729 "topo handle: %p\n", (void *)thp); 730 731 fmd_module_unlock(mp); 732 } 733 734 static void * 735 fmd_hdl_alloc_locked(fmd_module_t *mp, size_t size, int flags) 736 { 737 void *data; 738 739 if (mp->mod_stats->ms_memlimit.fmds_value.ui64 - 740 mp->mod_stats->ms_memtotal.fmds_value.ui64 < size) { 741 fmd_api_error(mp, EFMD_HDL_NOMEM, "%s's allocation of %lu " 742 "bytes exceeds module memory limit (%llu)\n", 743 mp->mod_name, (ulong_t)size, (u_longlong_t) 744 mp->mod_stats->ms_memtotal.fmds_value.ui64); 745 } 746 747 if ((data = fmd_alloc(size, flags)) != NULL) 748 mp->mod_stats->ms_memtotal.fmds_value.ui64 += size; 749 750 return (data); 751 } 752 753 void * 754 fmd_hdl_alloc(fmd_hdl_t *hdl, size_t size, int flags) 755 { 756 fmd_module_t *mp = fmd_api_module_lock(hdl); 757 void *data; 758 759 data = fmd_hdl_alloc_locked(mp, size, flags); 760 761 fmd_module_unlock(mp); 762 return (data); 763 } 764 765 void * 766 fmd_hdl_zalloc(fmd_hdl_t *hdl, size_t size, int flags) 767 { 768 void *data = fmd_hdl_alloc(hdl, size, flags); 769 770 if (data != NULL) 771 bzero(data, size); 772 773 return (data); 774 } 775 776 static void 777 fmd_hdl_free_locked(fmd_module_t *mp, void *data, size_t size) 778 { 779 fmd_free(data, size); 780 mp->mod_stats->ms_memtotal.fmds_value.ui64 -= size; 781 } 782 783 void 784 fmd_hdl_free(fmd_hdl_t *hdl, void *data, size_t size) 785 { 786 fmd_module_t *mp = fmd_api_module_lock(hdl); 787 788 fmd_hdl_free_locked(mp, data, size); 789 790 fmd_module_unlock(mp); 791 } 792 793 char * 794 fmd_hdl_strdup(fmd_hdl_t *hdl, const char *s, int flags) 795 { 796 char *p; 797 798 if (s != NULL) 799 p = fmd_hdl_alloc(hdl, strlen(s) + 1, flags); 800 else 801 p = NULL; 802 803 if (p != NULL) 804 (void) strcpy(p, s); 805 806 return (p); 807 } 808 809 void 810 fmd_hdl_strfree(fmd_hdl_t *hdl, char *s) 811 { 812 if (s != NULL) 813 fmd_hdl_free(hdl, s, strlen(s) + 1); 814 } 815 816 void 817 fmd_hdl_vabort(fmd_hdl_t *hdl, const char *format, va_list ap) 818 { 819 fmd_api_verror(fmd_api_module_lock(hdl), EFMD_HDL_ABORT, format, ap); 820 } 821 822 /*PRINTFLIKE2*/ 823 void 824 fmd_hdl_abort(fmd_hdl_t *hdl, const char *format, ...) 825 { 826 fmd_module_t *mp = fmd_api_module_lock(hdl); 827 va_list ap; 828 829 va_start(ap, format); 830 fmd_api_verror(mp, EFMD_HDL_ABORT, format, ap); 831 va_end(ap); 832 } 833 834 void 835 fmd_hdl_verror(fmd_hdl_t *hdl, const char *format, va_list ap) 836 { 837 fmd_module_t *mp = fmd_api_module_lock(hdl); 838 fmd_api_vxerror(mp, errno, format, ap); 839 fmd_module_unlock(mp); 840 } 841 842 /*PRINTFLIKE2*/ 843 void 844 fmd_hdl_error(fmd_hdl_t *hdl, const char *format, ...) 845 { 846 va_list ap; 847 848 va_start(ap, format); 849 fmd_hdl_verror(hdl, format, ap); 850 va_end(ap); 851 } 852 853 void 854 fmd_hdl_vdebug(fmd_hdl_t *hdl, const char *format, va_list ap) 855 { 856 fmd_module_t *mp = fmd_api_module_lock(hdl); 857 858 char *msg; 859 size_t len; 860 char c; 861 862 if (!(fmd.d_hdl_debug)) { 863 mp->mod_stats->ms_debugdrop.fmds_value.ui64++; 864 fmd_module_unlock(mp); 865 return; 866 } 867 868 len = vsnprintf(&c, 1, format, ap); 869 870 if ((msg = fmd_alloc(len + 2, FMD_NOSLEEP)) == NULL) { 871 mp->mod_stats->ms_debugdrop.fmds_value.ui64++; 872 fmd_module_unlock(mp); 873 return; 874 } 875 876 (void) vsnprintf(msg, len + 1, format, ap); 877 878 if (msg[len - 1] != '\n') 879 (void) strcpy(&msg[len], "\n"); 880 881 if (fmd.d_hdl_dbout & FMD_DBOUT_STDERR) { 882 (void) pthread_mutex_lock(&fmd.d_err_lock); 883 (void) fprintf(stderr, "%s DEBUG: %s: %s", 884 fmd.d_pname, mp->mod_name, msg); 885 (void) pthread_mutex_unlock(&fmd.d_err_lock); 886 } 887 888 if (fmd.d_hdl_dbout & FMD_DBOUT_SYSLOG) { 889 syslog(LOG_DEBUG | LOG_DAEMON, "%s DEBUG: %s: %s", 890 fmd.d_pname, mp->mod_name, msg); 891 } 892 893 fmd_free(msg, len + 2); 894 fmd_module_unlock(mp); 895 } 896 897 /*PRINTFLIKE2*/ 898 void 899 fmd_hdl_debug(fmd_hdl_t *hdl, const char *format, ...) 900 { 901 va_list ap; 902 903 va_start(ap, format); 904 fmd_hdl_vdebug(hdl, format, ap); 905 va_end(ap); 906 } 907 908 int32_t 909 fmd_prop_get_int32(fmd_hdl_t *hdl, const char *name) 910 { 911 fmd_module_t *mp = fmd_api_module_lock(hdl); 912 const fmd_conf_ops_t *ops = fmd_conf_gettype(mp->mod_conf, name); 913 int32_t value = 0; 914 915 if (ops == &fmd_conf_bool || ops == &fmd_conf_int32 || 916 ops == &fmd_conf_uint32) 917 (void) fmd_conf_getprop(mp->mod_conf, name, &value); 918 else if (ops != NULL) { 919 fmd_api_error(mp, EFMD_PROP_TYPE, 920 "property %s is not of int32 type\n", name); 921 } else { 922 fmd_api_error(mp, EFMD_PROP_DEFN, 923 "property %s is not defined\n", name); 924 } 925 926 fmd_module_unlock(mp); 927 return (value); 928 } 929 930 int64_t 931 fmd_prop_get_int64(fmd_hdl_t *hdl, const char *name) 932 { 933 fmd_module_t *mp = fmd_api_module_lock(hdl); 934 const fmd_conf_ops_t *ops = fmd_conf_gettype(mp->mod_conf, name); 935 int64_t value = 0; 936 937 if (ops == &fmd_conf_int64 || ops == &fmd_conf_uint64 || 938 ops == &fmd_conf_time || ops == &fmd_conf_size) 939 (void) fmd_conf_getprop(mp->mod_conf, name, &value); 940 else if (ops != NULL) { 941 fmd_api_error(mp, EFMD_PROP_TYPE, 942 "property %s is not of int64 type\n", name); 943 } else { 944 fmd_api_error(mp, EFMD_PROP_DEFN, 945 "property %s is not defined\n", name); 946 } 947 948 fmd_module_unlock(mp); 949 return (value); 950 } 951 952 char * 953 fmd_prop_get_string(fmd_hdl_t *hdl, const char *name) 954 { 955 fmd_module_t *mp = fmd_api_module_lock(hdl); 956 const fmd_conf_ops_t *ops = fmd_conf_gettype(mp->mod_conf, name); 957 char *value = NULL; 958 const char *s; 959 960 if (ops == &fmd_conf_string) { 961 (void) fmd_conf_getprop(mp->mod_conf, name, &s); 962 value = fmd_strdup(s, FMD_SLEEP); 963 } else if (ops != NULL) { 964 fmd_api_error(mp, EFMD_PROP_TYPE, 965 "property %s is not of string type\n", name); 966 } else { 967 fmd_api_error(mp, EFMD_PROP_DEFN, 968 "property %s is not defined\n", name); 969 } 970 971 fmd_module_unlock(mp); 972 return (value); 973 } 974 975 void 976 fmd_prop_free_string(fmd_hdl_t *hdl, char *s) 977 { 978 fmd_module_t *mp = fmd_api_module_lock(hdl); 979 fmd_strfree(s); 980 fmd_module_unlock(mp); 981 } 982 983 fmd_stat_t * 984 fmd_stat_create(fmd_hdl_t *hdl, uint_t flags, uint_t argc, fmd_stat_t *argv) 985 { 986 fmd_module_t *mp = fmd_api_module_lock(hdl); 987 fmd_stat_t *ep, *sp; 988 989 if (flags & ~FMD_STAT_ALLOC) { 990 fmd_api_error(mp, EFMD_STAT_FLAGS, 991 "invalid flags 0x%x passed to fmd_stat_create\n", flags); 992 } 993 994 if ((sp = fmd_ustat_insert(mp->mod_ustat, 995 flags | FMD_USTAT_VALIDATE, argc, argv, &ep)) == NULL) { 996 fmd_api_error(mp, errno, 997 "failed to publish stat '%s'", ep->fmds_name); 998 } 999 1000 fmd_module_unlock(mp); 1001 return (sp); 1002 } 1003 1004 void 1005 fmd_stat_destroy(fmd_hdl_t *hdl, uint_t argc, fmd_stat_t *argv) 1006 { 1007 fmd_module_t *mp = fmd_api_module_lock(hdl); 1008 fmd_ustat_delete(mp->mod_ustat, argc, argv); 1009 fmd_module_unlock(mp); 1010 } 1011 1012 void 1013 fmd_stat_setstr(fmd_hdl_t *hdl, fmd_stat_t *sp, const char *s) 1014 { 1015 char *str = fmd_strdup(s, FMD_SLEEP); 1016 fmd_module_t *mp = fmd_api_module_lock(hdl); 1017 1018 if (sp->fmds_type != FMD_TYPE_STRING) { 1019 fmd_strfree(str); 1020 fmd_api_error(mp, EFMD_STAT_TYPE, 1021 "stat '%s' is not a string\n", sp->fmds_name); 1022 } 1023 1024 fmd_strfree(sp->fmds_value.str); 1025 sp->fmds_value.str = str; 1026 1027 fmd_module_unlock(mp); 1028 } 1029 1030 fmd_case_t * 1031 fmd_case_open(fmd_hdl_t *hdl, void *data) 1032 { 1033 fmd_module_t *mp = fmd_api_module_lock(hdl); 1034 fmd_case_t *cp = fmd_case_create(mp, data); 1035 fmd_module_unlock(mp); 1036 return (cp); 1037 } 1038 1039 void 1040 fmd_case_reset(fmd_hdl_t *hdl, fmd_case_t *cp) 1041 { 1042 fmd_module_t *mp = fmd_api_module_lock(hdl); 1043 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1044 1045 if (cip->ci_state >= FMD_CASE_SOLVED) { 1046 fmd_api_error(mp, EFMD_CASE_STATE, "cannot solve %s: " 1047 "case is already solved or closed\n", cip->ci_uuid); 1048 } 1049 1050 fmd_case_reset_suspects(cp); 1051 fmd_module_unlock(mp); 1052 } 1053 1054 void 1055 fmd_case_solve(fmd_hdl_t *hdl, fmd_case_t *cp) 1056 { 1057 fmd_module_t *mp = fmd_api_module_lock(hdl); 1058 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1059 1060 if (cip->ci_state >= FMD_CASE_SOLVED) { 1061 fmd_api_error(mp, EFMD_CASE_STATE, "cannot solve %s: " 1062 "case is already solved or closed\n", cip->ci_uuid); 1063 } 1064 1065 fmd_case_transition(cp, FMD_CASE_SOLVED, FMD_CF_SOLVED); 1066 fmd_module_unlock(mp); 1067 } 1068 1069 void 1070 fmd_case_close(fmd_hdl_t *hdl, fmd_case_t *cp) 1071 { 1072 fmd_module_t *mp = fmd_api_module_lock(hdl); 1073 1074 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1075 fmd_case_transition(cp, FMD_CASE_CLOSE_WAIT, FMD_CF_ISOLATED); 1076 1077 fmd_module_unlock(mp); 1078 } 1079 1080 const char * 1081 fmd_case_uuid(fmd_hdl_t *hdl, fmd_case_t *cp) 1082 { 1083 fmd_module_t *mp = fmd_api_module_lock(hdl); 1084 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1085 const char *uuid = cip->ci_uuid; 1086 1087 fmd_module_unlock(mp); 1088 return (uuid); 1089 } 1090 1091 fmd_case_t * 1092 fmd_case_uulookup(fmd_hdl_t *hdl, const char *uuid) 1093 { 1094 fmd_module_t *cmp, *mp = fmd_api_module_lock(hdl); 1095 fmd_case_t *cp = fmd_case_hash_lookup(fmd.d_cases, uuid); 1096 1097 if (cp != NULL) { 1098 cmp = ((fmd_case_impl_t *)cp)->ci_mod; 1099 fmd_case_rele(cp); 1100 } else 1101 cmp = NULL; 1102 1103 fmd_module_unlock(mp); 1104 return (cmp == mp ? cp : NULL); 1105 } 1106 1107 void 1108 fmd_case_uuclose(fmd_hdl_t *hdl, const char *uuid) 1109 { 1110 fmd_module_t *mp = fmd_api_module_lock(hdl); 1111 fmd_case_t *cp = fmd_case_hash_lookup(fmd.d_cases, uuid); 1112 1113 if (cp != NULL) { 1114 fmd_case_transition(cp, FMD_CASE_CLOSE_WAIT, FMD_CF_ISOLATED); 1115 fmd_case_rele(cp); 1116 } 1117 1118 fmd_module_unlock(mp); 1119 } 1120 1121 int 1122 fmd_case_uuclosed(fmd_hdl_t *hdl, const char *uuid) 1123 { 1124 fmd_module_t *mp = fmd_api_module_lock(hdl); 1125 fmd_case_t *cp = fmd_case_hash_lookup(fmd.d_cases, uuid); 1126 fmd_case_impl_t *cip = (fmd_case_impl_t *)cp; 1127 int rv = FMD_B_TRUE; 1128 1129 if (cip != NULL) { 1130 rv = cip->ci_state >= FMD_CASE_CLOSE_WAIT; 1131 fmd_case_rele(cp); 1132 } 1133 1134 fmd_module_unlock(mp); 1135 return (rv); 1136 } 1137 1138 void 1139 fmd_case_uuresolved(fmd_hdl_t *hdl, const char *uuid) 1140 { 1141 fmd_module_t *mp = fmd_api_module_lock(hdl); 1142 fmd_case_t *cp = fmd_case_hash_lookup(fmd.d_cases, uuid); 1143 1144 if (cp != NULL) { 1145 fmd_case_impl_t *cip = (fmd_case_impl_t *)cp; 1146 /* 1147 * For a proxy, we notify the diagnosing side, and then 1148 * wait for it to send us back a list.resolved. 1149 */ 1150 if (cip->ci_xprt != NULL) 1151 fmd_xprt_uuresolved(cip->ci_xprt, cip->ci_uuid); 1152 else 1153 fmd_case_transition(cp, FMD_CASE_RESOLVED, 0); 1154 fmd_case_rele(cp); 1155 } 1156 1157 fmd_module_unlock(mp); 1158 } 1159 1160 static int 1161 fmd_case_instate(fmd_hdl_t *hdl, fmd_case_t *cp, uint_t state) 1162 { 1163 fmd_module_t *mp = fmd_api_module_lock(hdl); 1164 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1165 int rv = cip->ci_state >= state; 1166 1167 fmd_module_unlock(mp); 1168 return (rv); 1169 } 1170 1171 int 1172 fmd_case_solved(fmd_hdl_t *hdl, fmd_case_t *cp) 1173 { 1174 return (fmd_case_instate(hdl, cp, FMD_CASE_SOLVED)); 1175 } 1176 1177 int 1178 fmd_case_closed(fmd_hdl_t *hdl, fmd_case_t *cp) 1179 { 1180 return (fmd_case_instate(hdl, cp, FMD_CASE_CLOSE_WAIT)); 1181 } 1182 1183 void 1184 fmd_case_add_ereport(fmd_hdl_t *hdl, fmd_case_t *cp, fmd_event_t *ep) 1185 { 1186 fmd_module_t *mp = fmd_api_module_lock(hdl); 1187 1188 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1189 1190 if (fmd_case_insert_event(cp, ep)) 1191 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1192 1193 fmd_module_unlock(mp); 1194 } 1195 1196 void 1197 fmd_case_add_serd(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1198 { 1199 fmd_module_t *mp = fmd_api_module_lock(hdl); 1200 fmd_serd_elem_t *sep; 1201 fmd_serd_eng_t *sgp; 1202 1203 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1204 fmd_api_error(mp, EFMD_SERD_NAME, 1205 "failed to add events from serd engine '%s'", name); 1206 } 1207 1208 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1209 1210 for (sep = fmd_list_next(&sgp->sg_list); 1211 sep != NULL; sep = fmd_list_next(sep)) { 1212 if (fmd_case_insert_event(cp, sep->se_event)) 1213 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1214 } 1215 1216 fmd_module_unlock(mp); 1217 } 1218 1219 void 1220 fmd_case_add_suspect(fmd_hdl_t *hdl, fmd_case_t *cp, nvlist_t *nvl) 1221 { 1222 fmd_module_t *mp = fmd_api_module_lock(hdl); 1223 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1224 char *class; 1225 topo_hdl_t *thp; 1226 int err; 1227 nvlist_t *rsrc = NULL, *asru_prop = NULL, *asru = NULL, *fru = NULL; 1228 char *loc = NULL, *serial = NULL; 1229 1230 if (cip->ci_state >= FMD_CASE_SOLVED) { 1231 fmd_api_error(mp, EFMD_CASE_STATE, "cannot add suspect to " 1232 "%s: case is already solved or closed\n", cip->ci_uuid); 1233 } 1234 1235 if (nvlist_lookup_string(nvl, FM_CLASS, &class) != 0 || 1236 class == NULL || *class == '\0') { 1237 fmd_api_error(mp, EFMD_CASE_EVENT, "cannot add suspect to " 1238 "%s: suspect event is missing a class\n", cip->ci_uuid); 1239 } 1240 1241 thp = fmd_module_topo_hold(mp); 1242 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_RESOURCE, &rsrc); 1243 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, &asru); 1244 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_FRU, &fru); 1245 if (rsrc != NULL) { 1246 if (strncmp(class, "defect", 6) == 0) { 1247 if (asru == NULL && topo_fmri_getprop(thp, rsrc, 1248 TOPO_PGROUP_IO, TOPO_IO_MODULE, rsrc, 1249 &asru_prop, &err) == 0 && 1250 nvlist_lookup_nvlist(asru_prop, TOPO_PROP_VAL_VAL, 1251 &asru) == 0) { 1252 (void) nvlist_add_nvlist(nvl, FM_FAULT_ASRU, 1253 asru); 1254 nvlist_free(asru_prop); 1255 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, 1256 &asru); 1257 } 1258 } else { 1259 if (topo_fmri_asru(thp, rsrc, &asru, &err) == 0) { 1260 (void) nvlist_remove(nvl, FM_FAULT_ASRU, 1261 DATA_TYPE_NVLIST); 1262 (void) nvlist_add_nvlist(nvl, FM_FAULT_ASRU, 1263 asru); 1264 nvlist_free(asru); 1265 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, 1266 &asru); 1267 } 1268 if (topo_fmri_fru(thp, rsrc, &fru, &err) == 0) { 1269 (void) nvlist_remove(nvl, FM_FAULT_FRU, 1270 DATA_TYPE_NVLIST); 1271 (void) nvlist_add_nvlist(nvl, FM_FAULT_FRU, 1272 fru); 1273 nvlist_free(fru); 1274 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_FRU, 1275 &fru); 1276 } 1277 } 1278 } 1279 1280 /* 1281 * Try to find the location label for this resource 1282 */ 1283 if (strncmp(class, "defect", 6) != 0) { 1284 if (fru != NULL) 1285 (void) topo_fmri_label(thp, fru, &loc, &err); 1286 else if (rsrc != NULL) 1287 (void) topo_fmri_label(thp, rsrc, &loc, &err); 1288 if (loc != NULL) { 1289 (void) nvlist_remove(nvl, FM_FAULT_LOCATION, 1290 DATA_TYPE_STRING); 1291 (void) nvlist_add_string(nvl, FM_FAULT_LOCATION, loc); 1292 topo_hdl_strfree(thp, loc); 1293 } 1294 } 1295 1296 /* 1297 * In some cases, serial information for the resource will not be 1298 * available at enumeration but may instead be available by invoking 1299 * a dynamic property method on the FRU. In order to ensure the serial 1300 * number is persisted properly in the ASRU cache, we'll fetch the 1301 * property, if it exists, and add it to the resource and fru fmris. 1302 * If the DE has not listed a fru in the suspect, see if we can 1303 * retrieve the serial from the resource instead. 1304 */ 1305 if (fru != NULL) { 1306 (void) topo_fmri_serial(thp, fru, &serial, &err); 1307 if (serial != NULL) { 1308 (void) nvlist_add_string(fru, "serial", serial); 1309 topo_hdl_strfree(thp, serial); 1310 } 1311 } 1312 1313 err = fmd_module_topo_rele(mp, thp); 1314 ASSERT(err == 0); 1315 1316 fmd_case_insert_suspect(cp, nvl); 1317 fmd_module_unlock(mp); 1318 } 1319 1320 void 1321 fmd_case_setspecific(fmd_hdl_t *hdl, fmd_case_t *cp, void *data) 1322 { 1323 fmd_module_t *mp = fmd_api_module_lock(hdl); 1324 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1325 1326 (void) pthread_mutex_lock(&cip->ci_lock); 1327 cip->ci_data = data; 1328 (void) pthread_mutex_unlock(&cip->ci_lock); 1329 1330 fmd_module_unlock(mp); 1331 } 1332 1333 void * 1334 fmd_case_getspecific(fmd_hdl_t *hdl, fmd_case_t *cp) 1335 { 1336 fmd_module_t *mp = fmd_api_module_lock(hdl); 1337 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1338 void *data; 1339 1340 (void) pthread_mutex_lock(&cip->ci_lock); 1341 data = cip->ci_data; 1342 (void) pthread_mutex_unlock(&cip->ci_lock); 1343 1344 fmd_module_unlock(mp); 1345 return (data); 1346 } 1347 1348 void 1349 fmd_case_setprincipal(fmd_hdl_t *hdl, fmd_case_t *cp, fmd_event_t *ep) 1350 { 1351 fmd_module_t *mp = fmd_api_module_lock(hdl); 1352 1353 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1354 1355 if (fmd_case_insert_principal(cp, ep)) 1356 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1357 1358 fmd_module_unlock(mp); 1359 } 1360 1361 fmd_event_t * 1362 fmd_case_getprincipal(fmd_hdl_t *hdl, fmd_case_t *cp) 1363 { 1364 fmd_module_t *mp = fmd_api_module_lock(hdl); 1365 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1366 fmd_event_t *ep; 1367 1368 (void) pthread_mutex_lock(&cip->ci_lock); 1369 ep = cip->ci_principal; 1370 (void) pthread_mutex_unlock(&cip->ci_lock); 1371 1372 fmd_module_unlock(mp); 1373 return (ep); 1374 } 1375 1376 fmd_case_t * 1377 fmd_case_next(fmd_hdl_t *hdl, fmd_case_t *cp) 1378 { 1379 fmd_module_t *mp = fmd_api_module_lock(hdl); 1380 1381 if (cp != NULL) 1382 cp = fmd_list_next(fmd_api_case_impl(mp, cp)); 1383 else 1384 cp = fmd_list_next(&mp->mod_cases); 1385 1386 fmd_module_unlock(mp); 1387 return (cp); 1388 } 1389 1390 fmd_case_t * 1391 fmd_case_prev(fmd_hdl_t *hdl, fmd_case_t *cp) 1392 { 1393 fmd_module_t *mp = fmd_api_module_lock(hdl); 1394 1395 if (cp != NULL) 1396 cp = fmd_list_prev(fmd_api_case_impl(mp, cp)); 1397 else 1398 cp = fmd_list_prev(&mp->mod_cases); 1399 1400 fmd_module_unlock(mp); 1401 return (cp); 1402 } 1403 1404 /* 1405 * Utility function for fmd_buf_* routines. If a case is specified, use the 1406 * case's ci_bufs hash; otherwise use the module's global mod_bufs hash. 1407 */ 1408 static fmd_buf_hash_t * 1409 fmd_buf_gethash(fmd_module_t *mp, fmd_case_t *cp) 1410 { 1411 return (cp ? &fmd_api_case_impl(mp, cp)->ci_bufs : &mp->mod_bufs); 1412 } 1413 1414 void 1415 fmd_buf_create(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name, size_t size) 1416 { 1417 fmd_module_t *mp = fmd_api_module_lock(hdl); 1418 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1419 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1420 1421 if (bp == NULL) { 1422 if (fmd_strbadid(name, FMD_B_TRUE) != NULL || size == 0) { 1423 fmd_api_error(mp, EFMD_BUF_INVAL, "cannot create '%s' " 1424 "(size %lu): %s\n", name, (ulong_t)size, 1425 fmd_strerror(EFMD_BUF_INVAL)); 1426 } 1427 1428 if (mp->mod_stats->ms_buflimit.fmds_value.ui64 - 1429 mp->mod_stats->ms_buftotal.fmds_value.ui64 < size) { 1430 fmd_api_error(mp, EFMD_BUF_LIMIT, "cannot create '%s': " 1431 "buf limit exceeded (%llu)\n", name, (u_longlong_t) 1432 mp->mod_stats->ms_buflimit.fmds_value.ui64); 1433 } 1434 1435 mp->mod_stats->ms_buftotal.fmds_value.ui64 += size; 1436 bp = fmd_buf_insert(bhp, name, size); 1437 1438 } else { 1439 fmd_api_error(mp, EFMD_BUF_EXISTS, 1440 "cannot create '%s': buffer already exists\n", name); 1441 } 1442 1443 if (cp != NULL) 1444 fmd_case_setdirty(cp); 1445 else 1446 fmd_module_setdirty(mp); 1447 1448 fmd_module_unlock(mp); 1449 } 1450 1451 void 1452 fmd_buf_destroy(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1453 { 1454 fmd_module_t *mp = fmd_api_module_lock(hdl); 1455 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1456 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1457 1458 if (bp != NULL) { 1459 mp->mod_stats->ms_buftotal.fmds_value.ui64 -= bp->buf_size; 1460 fmd_buf_delete(bhp, name); 1461 1462 if (cp != NULL) 1463 fmd_case_setdirty(cp); 1464 else 1465 fmd_module_setdirty(mp); 1466 } 1467 1468 fmd_module_unlock(mp); 1469 } 1470 1471 void 1472 fmd_buf_read(fmd_hdl_t *hdl, fmd_case_t *cp, 1473 const char *name, void *buf, size_t size) 1474 { 1475 fmd_module_t *mp = fmd_api_module_lock(hdl); 1476 fmd_buf_t *bp = fmd_buf_lookup(fmd_buf_gethash(mp, cp), name); 1477 1478 if (bp == NULL) { 1479 fmd_api_error(mp, EFMD_BUF_NOENT, "no buf named '%s' is " 1480 "associated with %s\n", name, cp ? "case" : "module"); 1481 } 1482 1483 bcopy(bp->buf_data, buf, MIN(bp->buf_size, size)); 1484 if (size > bp->buf_size) 1485 bzero((char *)buf + bp->buf_size, size - bp->buf_size); 1486 1487 fmd_module_unlock(mp); 1488 } 1489 1490 void 1491 fmd_buf_write(fmd_hdl_t *hdl, fmd_case_t *cp, 1492 const char *name, const void *buf, size_t size) 1493 { 1494 fmd_module_t *mp = fmd_api_module_lock(hdl); 1495 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1496 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1497 1498 if (bp == NULL) { 1499 if (fmd_strbadid(name, FMD_B_TRUE) != NULL || size == 0) { 1500 fmd_api_error(mp, EFMD_BUF_INVAL, "cannot write '%s' " 1501 "(size %lu): %s\n", name, (ulong_t)size, 1502 fmd_strerror(EFMD_BUF_INVAL)); 1503 } 1504 1505 if (mp->mod_stats->ms_buflimit.fmds_value.ui64 - 1506 mp->mod_stats->ms_buftotal.fmds_value.ui64 < size) { 1507 fmd_api_error(mp, EFMD_BUF_LIMIT, "cannot write '%s': " 1508 "buf limit exceeded (%llu)\n", name, (u_longlong_t) 1509 mp->mod_stats->ms_buflimit.fmds_value.ui64); 1510 } 1511 1512 mp->mod_stats->ms_buftotal.fmds_value.ui64 += size; 1513 bp = fmd_buf_insert(bhp, name, size); 1514 1515 } else if (size > bp->buf_size) { 1516 fmd_api_error(mp, EFMD_BUF_OFLOW, 1517 "write to buf '%s' overflows buf size (%lu > %lu)\n", 1518 name, (ulong_t)size, (ulong_t)bp->buf_size); 1519 } 1520 1521 bcopy(buf, bp->buf_data, MIN(bp->buf_size, size)); 1522 bp->buf_flags |= FMD_BUF_DIRTY; 1523 1524 if (cp != NULL) 1525 fmd_case_setdirty(cp); 1526 else 1527 fmd_module_setdirty(mp); 1528 1529 fmd_module_unlock(mp); 1530 } 1531 1532 size_t 1533 fmd_buf_size(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1534 { 1535 fmd_module_t *mp = fmd_api_module_lock(hdl); 1536 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1537 1538 fmd_buf_t *bp; 1539 size_t size; 1540 1541 if ((bp = fmd_buf_lookup(bhp, name)) != NULL) 1542 size = bp->buf_size; 1543 else 1544 size = 0; 1545 1546 fmd_module_unlock(mp); 1547 return (size); 1548 } 1549 1550 void 1551 fmd_serd_create(fmd_hdl_t *hdl, const char *name, uint_t n, hrtime_t t) 1552 { 1553 fmd_module_t *mp = fmd_api_module_lock(hdl); 1554 1555 if (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL) { 1556 fmd_api_error(mp, EFMD_SERD_EXISTS, 1557 "failed to create serd engine '%s': %s\n", 1558 name, fmd_strerror(EFMD_SERD_EXISTS)); 1559 } 1560 1561 (void) fmd_serd_eng_insert(&mp->mod_serds, name, n, t); 1562 fmd_module_setdirty(mp); 1563 fmd_module_unlock(mp); 1564 } 1565 1566 void 1567 fmd_serd_destroy(fmd_hdl_t *hdl, const char *name) 1568 { 1569 fmd_module_t *mp = fmd_api_module_lock(hdl); 1570 1571 fmd_serd_eng_delete(&mp->mod_serds, name); 1572 fmd_module_setdirty(mp); 1573 fmd_module_unlock(mp); 1574 } 1575 1576 int 1577 fmd_serd_exists(fmd_hdl_t *hdl, const char *name) 1578 { 1579 fmd_module_t *mp = fmd_api_module_lock(hdl); 1580 int rv = (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL); 1581 fmd_module_unlock(mp); 1582 1583 return (rv); 1584 } 1585 1586 void 1587 fmd_serd_reset(fmd_hdl_t *hdl, const char *name) 1588 { 1589 fmd_module_t *mp = fmd_api_module_lock(hdl); 1590 fmd_serd_eng_t *sgp; 1591 1592 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1593 fmd_api_error(mp, EFMD_SERD_NAME, 1594 "serd engine '%s' does not exist\n", name); 1595 } 1596 1597 fmd_serd_eng_reset(sgp); 1598 fmd_module_setdirty(mp); 1599 fmd_module_unlock(mp); 1600 } 1601 1602 int 1603 fmd_serd_record(fmd_hdl_t *hdl, const char *name, fmd_event_t *ep) 1604 { 1605 fmd_module_t *mp = fmd_api_module_lock(hdl); 1606 fmd_serd_eng_t *sgp; 1607 int err; 1608 1609 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1610 fmd_api_error(mp, EFMD_SERD_NAME, 1611 "failed to add record to serd engine '%s'", name); 1612 } 1613 1614 err = fmd_serd_eng_record(sgp, ep); 1615 1616 if (sgp->sg_flags & FMD_SERD_DIRTY) 1617 fmd_module_setdirty(mp); 1618 1619 fmd_module_unlock(mp); 1620 return (err); 1621 } 1622 1623 int 1624 fmd_serd_fired(fmd_hdl_t *hdl, const char *name) 1625 { 1626 fmd_module_t *mp = fmd_api_module_lock(hdl); 1627 fmd_serd_eng_t *sgp; 1628 int err; 1629 1630 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1631 fmd_api_error(mp, EFMD_SERD_NAME, 1632 "serd engine '%s' does not exist\n", name); 1633 } 1634 1635 err = fmd_serd_eng_fired(sgp); 1636 fmd_module_unlock(mp); 1637 return (err); 1638 } 1639 1640 int 1641 fmd_serd_empty(fmd_hdl_t *hdl, const char *name) 1642 { 1643 fmd_module_t *mp = fmd_api_module_lock(hdl); 1644 fmd_serd_eng_t *sgp; 1645 int empty; 1646 1647 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1648 fmd_api_error(mp, EFMD_SERD_NAME, 1649 "serd engine '%s' does not exist\n", name); 1650 } 1651 1652 empty = fmd_serd_eng_empty(sgp); 1653 fmd_module_unlock(mp); 1654 return (empty); 1655 } 1656 1657 pthread_t 1658 fmd_thr_create(fmd_hdl_t *hdl, void (*func)(void *), void *arg) 1659 { 1660 fmd_module_t *mp = fmd_api_module_lock(hdl); 1661 fmd_thread_t *tp; 1662 pthread_t tid; 1663 1664 if (mp->mod_stats->ms_thrtotal.fmds_value.ui32 >= 1665 mp->mod_stats->ms_thrlimit.fmds_value.ui32) { 1666 fmd_api_error(mp, EFMD_THR_LIMIT, "%s request to create an " 1667 "auxiliary thread exceeds module thread limit (%u)\n", 1668 mp->mod_name, mp->mod_stats->ms_thrlimit.fmds_value.ui32); 1669 } 1670 1671 if ((tp = fmd_thread_create(mp, func, arg)) == NULL) { 1672 fmd_api_error(mp, EFMD_THR_CREATE, 1673 "failed to create auxiliary thread"); 1674 } 1675 1676 tid = tp->thr_tid; 1677 mp->mod_stats->ms_thrtotal.fmds_value.ui32++; 1678 (void) fmd_idspace_xalloc(mp->mod_threads, tid, tp); 1679 1680 fmd_module_unlock(mp); 1681 return (tid); 1682 } 1683 1684 void 1685 fmd_thr_destroy(fmd_hdl_t *hdl, pthread_t tid) 1686 { 1687 fmd_module_t *mp = fmd_api_module_lock(hdl); 1688 fmd_thread_t *tp; 1689 int err; 1690 1691 if (pthread_self() == tid) { 1692 fmd_api_error(mp, EFMD_THR_INVAL, "auxiliary thread tried to " 1693 "destroy itself (tid %u)\n", tid); 1694 } 1695 1696 if ((tp = fmd_idspace_getspecific(mp->mod_threads, tid)) == NULL) { 1697 fmd_api_error(mp, EFMD_THR_INVAL, "auxiliary thread tried to " 1698 "destroy an invalid thread (tid %u)\n", tid); 1699 } 1700 1701 /* 1702 * Wait for the specified thread to exit and then join with it. Since 1703 * the thread may need to make API calls in order to complete its work 1704 * we must sleep with the module lock unheld, and then reacquire it. 1705 */ 1706 fmd_module_unlock(mp); 1707 err = pthread_join(tid, NULL); 1708 mp = fmd_api_module_lock(hdl); 1709 1710 /* 1711 * Since pthread_join() was called without the module lock held, if 1712 * multiple callers attempted to destroy the same auxiliary thread 1713 * simultaneously, one will succeed and the others will get ESRCH. 1714 * Therefore we silently ignore ESRCH but only allow the caller who 1715 * succeessfully joined with the auxiliary thread to destroy it. 1716 */ 1717 if (err != 0 && err != ESRCH) { 1718 fmd_api_error(mp, EFMD_THR_JOIN, 1719 "failed to join with auxiliary thread %u\n", tid); 1720 } 1721 1722 if (err == 0) { 1723 fmd_thread_destroy(tp, FMD_THREAD_NOJOIN); 1724 mp->mod_stats->ms_thrtotal.fmds_value.ui32--; 1725 (void) fmd_idspace_free(mp->mod_threads, tid); 1726 } 1727 1728 fmd_module_unlock(mp); 1729 } 1730 1731 void 1732 fmd_thr_signal(fmd_hdl_t *hdl, pthread_t tid) 1733 { 1734 fmd_module_t *mp = fmd_api_module_lock(hdl); 1735 1736 if (tid != mp->mod_thread->thr_tid && 1737 fmd_idspace_getspecific(mp->mod_threads, tid) == NULL) { 1738 fmd_api_error(mp, EFMD_THR_INVAL, "tid %u is not a valid " 1739 "thread id for module %s\n", tid, mp->mod_name); 1740 } 1741 1742 (void) pthread_kill(tid, fmd.d_thr_sig); 1743 fmd_module_unlock(mp); 1744 } 1745 1746 void 1747 fmd_thr_checkpoint(fmd_hdl_t *hdl) 1748 { 1749 fmd_module_t *mp = fmd_api_module_lock(hdl); 1750 pthread_t tid = pthread_self(); 1751 1752 if (tid == mp->mod_thread->thr_tid || 1753 fmd_idspace_getspecific(mp->mod_threads, tid) == NULL) { 1754 fmd_api_error(mp, EFMD_THR_INVAL, "tid %u is not a valid " 1755 "auxiliary thread id for module %s\n", tid, mp->mod_name); 1756 } 1757 1758 fmd_ckpt_save(mp); 1759 1760 fmd_module_unlock(mp); 1761 } 1762 1763 id_t 1764 fmd_timer_install(fmd_hdl_t *hdl, void *arg, fmd_event_t *ep, hrtime_t delta) 1765 { 1766 fmd_module_t *mp = fmd_api_module_lock(hdl); 1767 fmd_modtimer_t *t; 1768 id_t id; 1769 1770 if (delta < 0) { 1771 fmd_api_error(mp, EFMD_TIMER_INVAL, 1772 "timer delta %lld is not a valid interval\n", delta); 1773 } 1774 1775 t = fmd_alloc(sizeof (fmd_modtimer_t), FMD_SLEEP); 1776 t->mt_mod = mp; 1777 t->mt_arg = arg; 1778 t->mt_id = -1; 1779 1780 if ((id = fmd_timerq_install(fmd.d_timers, mp->mod_timerids, 1781 (fmd_timer_f *)fmd_module_timeout, t, ep, delta)) == -1) { 1782 fmd_free(t, sizeof (fmd_modtimer_t)); 1783 fmd_api_error(mp, EFMD_TIMER_LIMIT, 1784 "failed to install timer +%lld", delta); 1785 } 1786 1787 fmd_module_unlock(mp); 1788 return (id); 1789 } 1790 1791 void 1792 fmd_timer_remove(fmd_hdl_t *hdl, id_t id) 1793 { 1794 fmd_module_t *mp = fmd_api_module_lock(hdl); 1795 fmd_modtimer_t *t; 1796 1797 if (!fmd_idspace_valid(mp->mod_timerids, id)) { 1798 fmd_api_error(mp, EFMD_TIMER_INVAL, 1799 "id %ld is not a valid timer id\n", id); 1800 } 1801 1802 /* 1803 * If the timer has not fired (t != NULL), remove it from the timer 1804 * queue. If the timer has fired (t == NULL), we could be in one of 1805 * two situations: a) we are processing the timer callback or b) 1806 * the timer event is on the module queue awaiting dispatch. For a), 1807 * fmd_timerq_remove() will wait for the timer callback function 1808 * to complete and queue an event for dispatch. For a) and b), 1809 * we cancel the outstanding timer event from the module's dispatch 1810 * queue. 1811 */ 1812 if ((t = fmd_timerq_remove(fmd.d_timers, mp->mod_timerids, id)) != NULL) 1813 fmd_free(t, sizeof (fmd_modtimer_t)); 1814 fmd_module_unlock(mp); 1815 1816 fmd_eventq_cancel(mp->mod_queue, FMD_EVT_TIMEOUT, (void *)id); 1817 } 1818 1819 nvlist_t * 1820 fmd_nvl_create_fault(fmd_hdl_t *hdl, const char *class, 1821 uint8_t certainty, nvlist_t *asru, nvlist_t *fru, nvlist_t *rsrc) 1822 { 1823 fmd_module_t *mp; 1824 nvlist_t *nvl; 1825 1826 mp = fmd_api_module_lock(hdl); 1827 if (class == NULL || class[0] == '\0') 1828 fmd_api_error(mp, EFMD_NVL_INVAL, "invalid fault class\n"); 1829 1830 nvl = fmd_protocol_fault(class, certainty, asru, fru, rsrc, NULL); 1831 1832 fmd_module_unlock(mp); 1833 1834 return (nvl); 1835 } 1836 1837 int 1838 fmd_nvl_class_match(fmd_hdl_t *hdl, nvlist_t *nvl, const char *pattern) 1839 { 1840 fmd_module_t *mp = fmd_api_module_lock(hdl); 1841 char *class; 1842 int rv; 1843 1844 rv = (nvl != NULL && nvlist_lookup_string(nvl, 1845 FM_CLASS, &class) == 0 && fmd_strmatch(class, pattern)); 1846 1847 fmd_module_unlock(mp); 1848 return (rv); 1849 } 1850 1851 int 1852 fmd_nvl_fmri_expand(fmd_hdl_t *hdl, nvlist_t *nvl) 1853 { 1854 fmd_module_t *mp = fmd_api_module_lock(hdl); 1855 int rv; 1856 1857 if (nvl == NULL) { 1858 fmd_api_error(mp, EFMD_NVL_INVAL, 1859 "invalid nvlist %p\n", (void *)nvl); 1860 } 1861 1862 rv = fmd_fmri_expand(nvl); 1863 fmd_module_unlock(mp); 1864 return (rv); 1865 } 1866 1867 int 1868 fmd_nvl_fmri_present(fmd_hdl_t *hdl, nvlist_t *nvl) 1869 { 1870 fmd_module_t *mp = fmd_api_module_lock(hdl); 1871 int rv; 1872 1873 if (nvl == NULL) { 1874 fmd_api_error(mp, EFMD_NVL_INVAL, 1875 "invalid nvlist %p\n", (void *)nvl); 1876 } 1877 1878 rv = fmd_fmri_present(nvl); 1879 fmd_module_unlock(mp); 1880 1881 if (rv < 0) { 1882 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1883 "fmd_nvl_fmri_present\n"); 1884 } 1885 1886 return (rv); 1887 } 1888 1889 int 1890 fmd_nvl_fmri_replaced(fmd_hdl_t *hdl, nvlist_t *nvl) 1891 { 1892 fmd_module_t *mp = fmd_api_module_lock(hdl); 1893 int rv; 1894 1895 if (nvl == NULL) { 1896 fmd_api_error(mp, EFMD_NVL_INVAL, 1897 "invalid nvlist %p\n", (void *)nvl); 1898 } 1899 1900 rv = fmd_fmri_replaced(nvl); 1901 fmd_module_unlock(mp); 1902 1903 return (rv); 1904 } 1905 1906 int 1907 fmd_nvl_fmri_unusable(fmd_hdl_t *hdl, nvlist_t *nvl) 1908 { 1909 fmd_module_t *mp = fmd_api_module_lock(hdl); 1910 int rv; 1911 1912 if (nvl == NULL) { 1913 fmd_api_error(mp, EFMD_NVL_INVAL, 1914 "invalid nvlist %p\n", (void *)nvl); 1915 } 1916 1917 rv = fmd_fmri_unusable(nvl); 1918 fmd_module_unlock(mp); 1919 1920 if (rv < 0) { 1921 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1922 "fmd_nvl_fmri_unusable\n"); 1923 } 1924 1925 return (rv); 1926 } 1927 1928 int 1929 fmd_nvl_fmri_retire(fmd_hdl_t *hdl, nvlist_t *nvl) 1930 { 1931 fmd_module_t *mp = fmd_api_module_lock(hdl); 1932 int rv; 1933 1934 if (nvl == NULL) { 1935 fmd_api_error(mp, EFMD_NVL_INVAL, 1936 "invalid nvlist %p\n", (void *)nvl); 1937 } 1938 1939 rv = fmd_fmri_retire(nvl); 1940 fmd_module_unlock(mp); 1941 1942 return (rv); 1943 } 1944 1945 int 1946 fmd_nvl_fmri_unretire(fmd_hdl_t *hdl, nvlist_t *nvl) 1947 { 1948 fmd_module_t *mp = fmd_api_module_lock(hdl); 1949 int rv; 1950 1951 if (nvl == NULL) { 1952 fmd_api_error(mp, EFMD_NVL_INVAL, 1953 "invalid nvlist %p\n", (void *)nvl); 1954 } 1955 1956 rv = fmd_fmri_unretire(nvl); 1957 fmd_module_unlock(mp); 1958 1959 return (rv); 1960 } 1961 1962 int 1963 fmd_nvl_fmri_service_state(fmd_hdl_t *hdl, nvlist_t *nvl) 1964 { 1965 fmd_module_t *mp = fmd_api_module_lock(hdl); 1966 int rv; 1967 1968 if (nvl == NULL) { 1969 fmd_api_error(mp, EFMD_NVL_INVAL, 1970 "invalid nvlist %p\n", (void *)nvl); 1971 } 1972 1973 rv = fmd_fmri_service_state(nvl); 1974 if (rv < 0) 1975 rv = fmd_fmri_unusable(nvl) ? FMD_SERVICE_STATE_UNUSABLE : 1976 FMD_SERVICE_STATE_OK; 1977 fmd_module_unlock(mp); 1978 1979 if (rv < 0) { 1980 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1981 "fmd_nvl_fmri_service_state\n"); 1982 } 1983 1984 return (rv); 1985 } 1986 1987 typedef struct { 1988 const char *class; 1989 int *rvp; 1990 } fmd_has_fault_arg_t; 1991 1992 static void 1993 fmd_rsrc_has_fault(fmd_asru_link_t *alp, void *arg) 1994 { 1995 fmd_has_fault_arg_t *fhfp = (fmd_has_fault_arg_t *)arg; 1996 char *class; 1997 1998 if (fhfp->class == NULL) { 1999 if (alp->al_flags & FMD_ASRU_FAULTY) 2000 *fhfp->rvp = 1; 2001 } else { 2002 if ((alp->al_flags & FMD_ASRU_FAULTY) && 2003 alp->al_event != NULL && nvlist_lookup_string(alp->al_event, 2004 FM_CLASS, &class) == 0 && fmd_strmatch(class, fhfp->class)) 2005 *fhfp->rvp = 1; 2006 } 2007 } 2008 2009 int 2010 fmd_nvl_fmri_has_fault(fmd_hdl_t *hdl, nvlist_t *nvl, int type, char *class) 2011 { 2012 fmd_module_t *mp = fmd_api_module_lock(hdl); 2013 fmd_asru_hash_t *ahp = fmd.d_asrus; 2014 int rv = 0; 2015 char *name; 2016 int namelen; 2017 fmd_has_fault_arg_t fhf; 2018 2019 if (nvl == NULL) { 2020 fmd_api_error(mp, EFMD_NVL_INVAL, 2021 "invalid nvlist %p\n", (void *)nvl); 2022 } 2023 if ((namelen = fmd_fmri_nvl2str(nvl, NULL, 0)) == -1) 2024 fmd_api_error(mp, EFMD_NVL_INVAL, 2025 "invalid nvlist: %p\n", (void *)nvl); 2026 name = fmd_alloc(namelen + 1, FMD_SLEEP); 2027 if (fmd_fmri_nvl2str(nvl, name, namelen + 1) == -1) { 2028 if (name != NULL) 2029 fmd_free(name, namelen + 1); 2030 fmd_api_error(mp, EFMD_NVL_INVAL, 2031 "invalid nvlist: %p\n", (void *)nvl); 2032 } 2033 2034 fhf.class = class; 2035 fhf.rvp = &rv; 2036 if (type == FMD_HAS_FAULT_RESOURCE) 2037 fmd_asru_hash_apply_by_rsrc(ahp, name, fmd_rsrc_has_fault, 2038 &fhf); 2039 else if (type == FMD_HAS_FAULT_ASRU) 2040 fmd_asru_hash_apply_by_asru(ahp, name, fmd_rsrc_has_fault, 2041 &fhf); 2042 else if (type == FMD_HAS_FAULT_FRU) 2043 fmd_asru_hash_apply_by_fru(ahp, name, fmd_rsrc_has_fault, 2044 &fhf); 2045 2046 if (name != NULL) 2047 fmd_free(name, namelen + 1); 2048 fmd_module_unlock(mp); 2049 return (rv); 2050 } 2051 2052 int 2053 fmd_nvl_fmri_contains(fmd_hdl_t *hdl, nvlist_t *n1, nvlist_t *n2) 2054 { 2055 fmd_module_t *mp = fmd_api_module_lock(hdl); 2056 int rv; 2057 2058 if (n1 == NULL || n2 == NULL) { 2059 fmd_api_error(mp, EFMD_NVL_INVAL, 2060 "invalid nvlist(s): %p, %p\n", (void *)n1, (void *)n2); 2061 } 2062 2063 rv = fmd_fmri_contains(n1, n2); 2064 fmd_module_unlock(mp); 2065 2066 if (rv < 0) { 2067 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 2068 "fmd_nvl_fmri_contains\n"); 2069 } 2070 2071 return (rv); 2072 } 2073 2074 nvlist_t * 2075 fmd_nvl_fmri_translate(fmd_hdl_t *hdl, nvlist_t *fmri, nvlist_t *auth) 2076 { 2077 fmd_module_t *mp = fmd_api_module_lock(hdl); 2078 nvlist_t *xfmri; 2079 2080 if (fmri == NULL || auth == NULL) { 2081 fmd_api_error(mp, EFMD_NVL_INVAL, 2082 "invalid nvlist(s): %p, %p\n", (void *)fmri, (void *)auth); 2083 } 2084 2085 xfmri = fmd_fmri_translate(fmri, auth); 2086 fmd_module_unlock(mp); 2087 return (xfmri); 2088 } 2089 2090 static int 2091 fmd_nvl_op_init(nv_alloc_t *ops, va_list ap) 2092 { 2093 fmd_module_t *mp = va_arg(ap, fmd_module_t *); 2094 2095 ops->nva_arg = mp; 2096 2097 return (0); 2098 } 2099 2100 static void * 2101 fmd_nvl_op_alloc_sleep(nv_alloc_t *ops, size_t size) 2102 { 2103 fmd_module_t *mp = ops->nva_arg; 2104 2105 return (fmd_hdl_alloc_locked(mp, size, FMD_SLEEP)); 2106 } 2107 2108 static void * 2109 fmd_nvl_op_alloc_nosleep(nv_alloc_t *ops, size_t size) 2110 { 2111 fmd_module_t *mp = ops->nva_arg; 2112 2113 return (fmd_hdl_alloc_locked(mp, size, FMD_NOSLEEP)); 2114 } 2115 2116 static void 2117 fmd_nvl_op_free(nv_alloc_t *ops, void *data, size_t size) 2118 { 2119 fmd_module_t *mp = ops->nva_arg; 2120 2121 fmd_hdl_free_locked(mp, data, size); 2122 } 2123 2124 nv_alloc_ops_t fmd_module_nva_ops_sleep = { 2125 fmd_nvl_op_init, 2126 NULL, 2127 fmd_nvl_op_alloc_sleep, 2128 fmd_nvl_op_free, 2129 NULL 2130 }; 2131 2132 nv_alloc_ops_t fmd_module_nva_ops_nosleep = { 2133 fmd_nvl_op_init, 2134 NULL, 2135 fmd_nvl_op_alloc_nosleep, 2136 fmd_nvl_op_free, 2137 NULL 2138 }; 2139 2140 nvlist_t * 2141 fmd_nvl_alloc(fmd_hdl_t *hdl, int flags) 2142 { 2143 fmd_module_t *mp = fmd_api_module_lock(hdl); 2144 nv_alloc_t *nva; 2145 nvlist_t *nvl; 2146 int ret; 2147 2148 if (flags == FMD_SLEEP) 2149 nva = &mp->mod_nva_sleep; 2150 else 2151 nva = &mp->mod_nva_nosleep; 2152 2153 ret = nvlist_xalloc(&nvl, NV_UNIQUE_NAME, nva); 2154 2155 fmd_module_unlock(mp); 2156 2157 if (ret != 0) 2158 return (NULL); 2159 else 2160 return (nvl); 2161 } 2162 2163 nvlist_t * 2164 fmd_nvl_dup(fmd_hdl_t *hdl, nvlist_t *src, int flags) 2165 { 2166 fmd_module_t *mp = fmd_api_module_lock(hdl); 2167 nv_alloc_t *nva; 2168 nvlist_t *nvl; 2169 int ret; 2170 2171 if (flags == FMD_SLEEP) 2172 nva = &mp->mod_nva_sleep; 2173 else 2174 nva = &mp->mod_nva_nosleep; 2175 2176 ret = nvlist_xdup(src, &nvl, nva); 2177 2178 fmd_module_unlock(mp); 2179 2180 if (ret != 0) 2181 return (NULL); 2182 else 2183 return (nvl); 2184 } 2185 2186 /*ARGSUSED*/ 2187 void 2188 fmd_repair_fru(fmd_hdl_t *hdl, const char *fmri) 2189 { 2190 int err; 2191 fmd_asru_rep_arg_t fara; 2192 2193 fara.fara_reason = FMD_ASRU_REPAIRED; 2194 fara.fara_bywhat = FARA_BY_FRU; 2195 fara.fara_rval = &err; 2196 fmd_asru_hash_apply_by_fru(fmd.d_asrus, (char *)fmri, 2197 fmd_asru_repaired, &fara); 2198 } 2199 2200 /*ARGSUSED*/ 2201 int 2202 fmd_repair_asru(fmd_hdl_t *hdl, const char *fmri) 2203 { 2204 int err = FARA_ERR_RSRCNOTF; 2205 fmd_asru_rep_arg_t fara; 2206 2207 fara.fara_reason = FMD_ASRU_REPAIRED; 2208 fara.fara_rval = &err; 2209 fara.fara_uuid = NULL; 2210 fara.fara_bywhat = FARA_BY_ASRU; 2211 fmd_asru_hash_apply_by_asru(fmd.d_asrus, fmri, 2212 fmd_asru_repaired, &fara); 2213 return (err); 2214 } 2215 2216 int 2217 fmd_event_local(fmd_hdl_t *hdl, fmd_event_t *ep) 2218 { 2219 if (hdl == NULL || ep == NULL) { 2220 fmd_api_error(fmd_api_module_lock(hdl), EFMD_EVENT_INVAL, 2221 "NULL parameter specified to fmd_event_local\n"); 2222 } 2223 2224 return (((fmd_event_impl_t *)ep)->ev_flags & FMD_EVF_LOCAL); 2225 } 2226 2227 /*ARGSUSED*/ 2228 uint64_t 2229 fmd_event_ena_create(fmd_hdl_t *hdl) 2230 { 2231 return (fmd_ena()); 2232 } 2233 2234 fmd_xprt_t * 2235 fmd_xprt_open(fmd_hdl_t *hdl, uint_t flags, nvlist_t *auth, void *data) 2236 { 2237 fmd_module_t *mp = fmd_api_module_lock(hdl); 2238 fmd_xprt_t *xp; 2239 2240 if (flags & ~FMD_XPRT_CMASK) { 2241 fmd_api_error(mp, EFMD_XPRT_INVAL, 2242 "invalid transport flags 0x%x\n", flags); 2243 } 2244 2245 if ((flags & FMD_XPRT_RDWR) != FMD_XPRT_RDWR && 2246 (flags & FMD_XPRT_RDWR) != FMD_XPRT_RDONLY) { 2247 fmd_api_error(mp, EFMD_XPRT_INVAL, 2248 "cannot open write-only transport\n"); 2249 } 2250 2251 if (mp->mod_stats->ms_xprtopen.fmds_value.ui32 >= 2252 mp->mod_stats->ms_xprtlimit.fmds_value.ui32) { 2253 fmd_api_error(mp, EFMD_XPRT_LIMIT, "%s request to create a " 2254 "transport exceeds module transport limit (%u)\n", 2255 mp->mod_name, mp->mod_stats->ms_xprtlimit.fmds_value.ui32); 2256 } 2257 2258 if ((xp = fmd_xprt_create(mp, flags, auth, data)) == NULL) 2259 fmd_api_error(mp, errno, "cannot create transport"); 2260 2261 fmd_module_unlock(mp); 2262 return (xp); 2263 } 2264 2265 void 2266 fmd_xprt_close(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2267 { 2268 fmd_module_t *mp = fmd_api_module_lock(hdl); 2269 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2270 2271 /* 2272 * Although this could be supported, it doesn't seem necessary or worth 2273 * the trouble. For now, just detect this and trigger a module abort. 2274 * If it is needed, transports should grow reference counts and a new 2275 * event type will need to be enqueued for the main thread to reap it. 2276 */ 2277 if (xip->xi_thread != NULL && 2278 xip->xi_thread->thr_tid == pthread_self()) { 2279 fmd_api_error(mp, EFMD_XPRT_INVAL, 2280 "fmd_xprt_close() cannot be called from fmdo_send()\n"); 2281 } 2282 2283 fmd_xprt_destroy(xp); 2284 fmd_module_unlock(mp); 2285 } 2286 2287 void 2288 fmd_xprt_post(fmd_hdl_t *hdl, fmd_xprt_t *xp, nvlist_t *nvl, hrtime_t hrt) 2289 { 2290 nv_alloc_t *nva = nvlist_lookup_nv_alloc(nvl); 2291 fmd_module_t *mp = fmd_api_module(hdl); 2292 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2293 nvlist_t *tmp; 2294 2295 /* 2296 * If this event was allocated using the module-specific nvlist ops, we 2297 * need to create a copy using the standard fmd nvlist ops. Otherwise, 2298 * the event may persist after the module has been unloaded and we'll 2299 * die when attempting to free the nvlist. 2300 */ 2301 if (nva == &mp->mod_nva_sleep || nva == &mp->mod_nva_nosleep) { 2302 (void) nvlist_xdup(nvl, &tmp, &fmd.d_nva); 2303 nvlist_free(nvl); 2304 nvl = tmp; 2305 } 2306 2307 /* 2308 * fmd_xprt_recv() must block during startup waiting for fmd to globally 2309 * clear FMD_XPRT_DSUSPENDED. As such, we can't allow it to be called 2310 * from a module's _fmd_init() routine, because that would block 2311 * fmd from completing initial module loading, resulting in a deadlock. 2312 */ 2313 if ((xip->xi_flags & FMD_XPRT_ISUSPENDED) && 2314 (pthread_self() == xip->xi_queue->eq_mod->mod_thread->thr_tid)) { 2315 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2316 "fmd_xprt_post() cannot be called from _fmd_init()\n"); 2317 } 2318 2319 fmd_xprt_recv(xp, nvl, hrt, FMD_B_FALSE); 2320 } 2321 2322 void 2323 fmd_xprt_log(fmd_hdl_t *hdl, fmd_xprt_t *xp, nvlist_t *nvl, hrtime_t hrt) 2324 { 2325 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2326 2327 /* 2328 * fmd_xprt_recv() must block during startup waiting for fmd to globally 2329 * clear FMD_XPRT_DSUSPENDED. As such, we can't allow it to be called 2330 * from a module's _fmd_init() routine, because that would block 2331 * fmd from completing initial module loading, resulting in a deadlock. 2332 */ 2333 if ((xip->xi_flags & FMD_XPRT_ISUSPENDED) && 2334 (pthread_self() == xip->xi_queue->eq_mod->mod_thread->thr_tid)) { 2335 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2336 "fmd_xprt_log() cannot be called from _fmd_init()\n"); 2337 } 2338 2339 fmd_xprt_recv(xp, nvl, hrt, FMD_B_TRUE); 2340 } 2341 2342 void 2343 fmd_xprt_suspend(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2344 { 2345 (void) fmd_api_transport_impl(hdl, xp); /* validate 'xp' */ 2346 fmd_xprt_xsuspend(xp, FMD_XPRT_SUSPENDED); 2347 } 2348 2349 void 2350 fmd_xprt_resume(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2351 { 2352 (void) fmd_api_transport_impl(hdl, xp); /* validate 'xp' */ 2353 fmd_xprt_xresume(xp, FMD_XPRT_SUSPENDED); 2354 } 2355 2356 int 2357 fmd_xprt_error(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2358 { 2359 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2360 return (xip->xi_state == _fmd_xprt_state_err); 2361 } 2362 2363 /* 2364 * Translate all FMRIs in the specified name-value pair list for the specified 2365 * FMRI authority, and return a new name-value pair list for the translation. 2366 * This function is the recursive engine used by fmd_xprt_translate(), below. 2367 */ 2368 static nvlist_t * 2369 fmd_xprt_xtranslate(nvlist_t *nvl, nvlist_t *auth) 2370 { 2371 uint_t i, j, n; 2372 nvpair_t *nvp, **nvps; 2373 uint_t nvpslen = 0; 2374 char *name; 2375 size_t namelen = 0; 2376 2377 nvlist_t **a, **b; 2378 nvlist_t *l, *r; 2379 data_type_t type; 2380 char *s; 2381 int err; 2382 2383 (void) nvlist_xdup(nvl, &nvl, &fmd.d_nva); 2384 2385 /* 2386 * Count up the number of name-value pairs in 'nvl' and compute the 2387 * maximum length of a name used in this list for use below. 2388 */ 2389 for (nvp = nvlist_next_nvpair(nvl, NULL); 2390 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp), nvpslen++) { 2391 size_t len = strlen(nvpair_name(nvp)); 2392 namelen = MAX(namelen, len); 2393 } 2394 2395 nvps = alloca(sizeof (nvpair_t *) * nvpslen); 2396 name = alloca(namelen + 1); 2397 2398 /* 2399 * Store a snapshot of the name-value pairs in 'nvl' into nvps[] so 2400 * that we can iterate over the original pairs in the loop below while 2401 * performing arbitrary insert and delete operations on 'nvl' itself. 2402 */ 2403 for (i = 0, nvp = nvlist_next_nvpair(nvl, NULL); 2404 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) 2405 nvps[i++] = nvp; 2406 2407 /* 2408 * Now iterate over the snapshot of the name-value pairs. If we find a 2409 * value that is of type NVLIST or NVLIST_ARRAY, we translate that 2410 * object by either calling ourself recursively on it, or calling into 2411 * fmd_fmri_translate() if the object is an FMRI. We then rip out the 2412 * original name-value pair and replace it with the translated one. 2413 */ 2414 for (i = 0; i < nvpslen; i++) { 2415 nvp = nvps[i]; 2416 type = nvpair_type(nvp); 2417 2418 switch (type) { 2419 case DATA_TYPE_NVLIST_ARRAY: 2420 if (nvpair_value_nvlist_array(nvp, &a, &n) != 0 || 2421 a == NULL || n == 0) 2422 continue; /* array is zero-sized; skip it */ 2423 2424 b = fmd_alloc(sizeof (nvlist_t *) * n, FMD_SLEEP); 2425 2426 /* 2427 * If the first array nvlist element looks like an FMRI 2428 * then assume the other elements are FMRIs as well. 2429 * If any b[j]'s can't be translated, then EINVAL will 2430 * be returned from nvlist_add_nvlist_array() below. 2431 */ 2432 if (nvlist_lookup_string(*a, FM_FMRI_SCHEME, &s) == 0) { 2433 for (j = 0; j < n; j++) 2434 b[j] = fmd_fmri_translate(a[j], auth); 2435 } else { 2436 for (j = 0; j < n; j++) 2437 b[j] = fmd_xprt_xtranslate(a[j], auth); 2438 } 2439 2440 (void) strcpy(name, nvpair_name(nvp)); 2441 (void) nvlist_remove(nvl, name, type); 2442 err = nvlist_add_nvlist_array(nvl, name, b, n); 2443 2444 for (j = 0; j < n; j++) 2445 nvlist_free(b[j]); 2446 2447 fmd_free(b, sizeof (nvlist_t *) * n); 2448 2449 if (err != 0) { 2450 nvlist_free(nvl); 2451 errno = err; 2452 return (NULL); 2453 } 2454 break; 2455 2456 case DATA_TYPE_NVLIST: 2457 if (nvpair_value_nvlist(nvp, &l) == 0 && 2458 nvlist_lookup_string(l, FM_FMRI_SCHEME, &s) == 0) 2459 r = fmd_fmri_translate(l, auth); 2460 else 2461 r = fmd_xprt_xtranslate(l, auth); 2462 2463 if (r == NULL) { 2464 nvlist_free(nvl); 2465 return (NULL); 2466 } 2467 2468 (void) strcpy(name, nvpair_name(nvp)); 2469 (void) nvlist_remove(nvl, name, type); 2470 (void) nvlist_add_nvlist(nvl, name, r); 2471 2472 nvlist_free(r); 2473 break; 2474 } 2475 } 2476 2477 return (nvl); 2478 } 2479 2480 nvlist_t * 2481 fmd_xprt_translate(fmd_hdl_t *hdl, fmd_xprt_t *xp, fmd_event_t *ep) 2482 { 2483 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2484 2485 if (xip->xi_auth == NULL) { 2486 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2487 "no authority defined for transport %p\n", (void *)xp); 2488 } 2489 2490 return (fmd_xprt_xtranslate(FMD_EVENT_NVL(ep), xip->xi_auth)); 2491 } 2492 2493 /*ARGSUSED*/ 2494 void 2495 fmd_xprt_add_domain(fmd_hdl_t *hdl, nvlist_t *nvl, char *domain) 2496 { 2497 nvpair_t *nvp, *nvp2; 2498 nvlist_t *nvl2, *nvl3; 2499 char *class; 2500 2501 if (nvl == NULL || domain == NULL) 2502 return; 2503 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 2504 nvp = nvlist_next_nvpair(nvl, nvp)) { 2505 if (strcmp(nvpair_name(nvp), FM_CLASS) == 0) { 2506 (void) nvpair_value_string(nvp, &class); 2507 if (strcmp(class, FM_LIST_SUSPECT_CLASS) != 0) 2508 return; 2509 } 2510 } 2511 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 2512 nvp = nvlist_next_nvpair(nvl, nvp)) { 2513 if (strcmp(nvpair_name(nvp), FM_SUSPECT_DE) == 0) { 2514 (void) nvpair_value_nvlist(nvp, &nvl2); 2515 for (nvp2 = nvlist_next_nvpair(nvl2, NULL); 2516 nvp2 != NULL; 2517 nvp2 = nvlist_next_nvpair(nvl2, nvp2)) { 2518 if (strcmp(nvpair_name(nvp2), 2519 FM_FMRI_AUTHORITY) == 0) { 2520 (void) nvpair_value_nvlist(nvp2, &nvl3); 2521 (void) nvlist_add_string(nvl3, 2522 FM_FMRI_AUTH_DOMAIN, domain); 2523 break; 2524 } 2525 } 2526 break; 2527 } 2528 } 2529 } 2530 2531 void 2532 fmd_xprt_setspecific(fmd_hdl_t *hdl, fmd_xprt_t *xp, void *data) 2533 { 2534 fmd_api_transport_impl(hdl, xp)->xi_data = data; 2535 } 2536 2537 void * 2538 fmd_xprt_getspecific(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2539 { 2540 return (fmd_api_transport_impl(hdl, xp)->xi_data); 2541 } 2542