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 2008 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_transition(cp, FMD_CASE_RESOLVED, 0); 1146 fmd_case_rele(cp); 1147 } 1148 1149 fmd_module_unlock(mp); 1150 } 1151 1152 static int 1153 fmd_case_instate(fmd_hdl_t *hdl, fmd_case_t *cp, uint_t state) 1154 { 1155 fmd_module_t *mp = fmd_api_module_lock(hdl); 1156 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1157 int rv = cip->ci_state >= state; 1158 1159 fmd_module_unlock(mp); 1160 return (rv); 1161 } 1162 1163 int 1164 fmd_case_solved(fmd_hdl_t *hdl, fmd_case_t *cp) 1165 { 1166 return (fmd_case_instate(hdl, cp, FMD_CASE_SOLVED)); 1167 } 1168 1169 int 1170 fmd_case_closed(fmd_hdl_t *hdl, fmd_case_t *cp) 1171 { 1172 return (fmd_case_instate(hdl, cp, FMD_CASE_CLOSE_WAIT)); 1173 } 1174 1175 void 1176 fmd_case_add_ereport(fmd_hdl_t *hdl, fmd_case_t *cp, fmd_event_t *ep) 1177 { 1178 fmd_module_t *mp = fmd_api_module_lock(hdl); 1179 1180 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1181 1182 if (fmd_case_insert_event(cp, ep)) 1183 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1184 1185 fmd_module_unlock(mp); 1186 } 1187 1188 void 1189 fmd_case_add_serd(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1190 { 1191 fmd_module_t *mp = fmd_api_module_lock(hdl); 1192 fmd_serd_elem_t *sep; 1193 fmd_serd_eng_t *sgp; 1194 1195 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1196 fmd_api_error(mp, EFMD_SERD_NAME, 1197 "failed to add events from serd engine '%s'", name); 1198 } 1199 1200 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1201 1202 for (sep = fmd_list_next(&sgp->sg_list); 1203 sep != NULL; sep = fmd_list_next(sep)) { 1204 if (fmd_case_insert_event(cp, sep->se_event)) 1205 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1206 } 1207 1208 fmd_module_unlock(mp); 1209 } 1210 1211 void 1212 fmd_case_add_suspect(fmd_hdl_t *hdl, fmd_case_t *cp, nvlist_t *nvl) 1213 { 1214 fmd_module_t *mp = fmd_api_module_lock(hdl); 1215 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1216 char *class; 1217 topo_hdl_t *thp; 1218 int err; 1219 nvlist_t *rsrc = NULL, *asru = NULL, *fru = NULL; 1220 char *loc = NULL, *serial = NULL; 1221 1222 if (cip->ci_state >= FMD_CASE_SOLVED) { 1223 fmd_api_error(mp, EFMD_CASE_STATE, "cannot add suspect to " 1224 "%s: case is already solved or closed\n", cip->ci_uuid); 1225 } 1226 1227 if (nvlist_lookup_string(nvl, FM_CLASS, &class) != 0 || 1228 class == NULL || *class == '\0') { 1229 fmd_api_error(mp, EFMD_CASE_EVENT, "cannot add suspect to " 1230 "%s: suspect event is missing a class\n", cip->ci_uuid); 1231 } 1232 1233 thp = fmd_module_topo_hold(mp); 1234 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_RESOURCE, &rsrc); 1235 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, &asru); 1236 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_FRU, &fru); 1237 if (rsrc != NULL) { 1238 if (strncmp(class, "defect", 6) == 0) { 1239 if (asru == NULL && topo_fmri_getprop(thp, rsrc, 1240 TOPO_PGROUP_IO, TOPO_IO_MODULE, rsrc, 1241 &asru, &err) == 0) { 1242 (void) nvlist_add_nvlist(nvl, FM_FAULT_ASRU, 1243 asru); 1244 nvlist_free(asru); 1245 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, 1246 &asru); 1247 } 1248 } else { 1249 if (topo_fmri_asru(thp, rsrc, &asru, &err) == 0) { 1250 (void) nvlist_remove(nvl, FM_FAULT_ASRU, 1251 DATA_TYPE_NVLIST); 1252 (void) nvlist_add_nvlist(nvl, FM_FAULT_ASRU, 1253 asru); 1254 nvlist_free(asru); 1255 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_ASRU, 1256 &asru); 1257 } 1258 if (topo_fmri_fru(thp, rsrc, &fru, &err) == 0) { 1259 (void) nvlist_remove(nvl, FM_FAULT_FRU, 1260 DATA_TYPE_NVLIST); 1261 (void) nvlist_add_nvlist(nvl, FM_FAULT_FRU, 1262 fru); 1263 nvlist_free(fru); 1264 (void) nvlist_lookup_nvlist(nvl, FM_FAULT_FRU, 1265 &fru); 1266 } 1267 } 1268 } 1269 1270 /* 1271 * Try to find the location label for this resource 1272 */ 1273 if (fru != NULL) 1274 (void) topo_fmri_label(thp, fru, &loc, &err); 1275 else if (rsrc != NULL) 1276 (void) topo_fmri_label(thp, rsrc, &loc, &err); 1277 if (loc != NULL) { 1278 (void) nvlist_remove(nvl, FM_FAULT_LOCATION, DATA_TYPE_STRING); 1279 (void) nvlist_add_string(nvl, FM_FAULT_LOCATION, loc); 1280 topo_hdl_strfree(thp, loc); 1281 } 1282 1283 /* 1284 * In some cases, serial information for the resource will not be 1285 * available at enumeration but may instead be available by invoking 1286 * a dynamic property method on the FRU. In order to ensure the serial 1287 * number is persisted properly in the ASRU cache, we'll fetch the 1288 * property, if it exists, and add it to the resource and fru fmris. 1289 */ 1290 if (fru != NULL) { 1291 (void) topo_fmri_serial(thp, fru, &serial, &err); 1292 if (serial != NULL) { 1293 if (rsrc != NULL) 1294 (void) nvlist_add_string(rsrc, "serial", 1295 serial); 1296 (void) nvlist_add_string(fru, "serial", serial); 1297 topo_hdl_strfree(thp, serial); 1298 } 1299 } 1300 1301 err = fmd_module_topo_rele(mp, thp); 1302 ASSERT(err == 0); 1303 1304 fmd_case_insert_suspect(cp, nvl); 1305 fmd_module_unlock(mp); 1306 } 1307 1308 void 1309 fmd_case_setspecific(fmd_hdl_t *hdl, fmd_case_t *cp, void *data) 1310 { 1311 fmd_module_t *mp = fmd_api_module_lock(hdl); 1312 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1313 1314 (void) pthread_mutex_lock(&cip->ci_lock); 1315 cip->ci_data = data; 1316 (void) pthread_mutex_unlock(&cip->ci_lock); 1317 1318 fmd_module_unlock(mp); 1319 } 1320 1321 void * 1322 fmd_case_getspecific(fmd_hdl_t *hdl, fmd_case_t *cp) 1323 { 1324 fmd_module_t *mp = fmd_api_module_lock(hdl); 1325 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1326 void *data; 1327 1328 (void) pthread_mutex_lock(&cip->ci_lock); 1329 data = cip->ci_data; 1330 (void) pthread_mutex_unlock(&cip->ci_lock); 1331 1332 fmd_module_unlock(mp); 1333 return (data); 1334 } 1335 1336 void 1337 fmd_case_setprincipal(fmd_hdl_t *hdl, fmd_case_t *cp, fmd_event_t *ep) 1338 { 1339 fmd_module_t *mp = fmd_api_module_lock(hdl); 1340 1341 (void) fmd_api_case_impl(mp, cp); /* validate 'cp' */ 1342 1343 if (fmd_case_insert_principal(cp, ep)) 1344 mp->mod_stats->ms_accepted.fmds_value.ui64++; 1345 1346 fmd_module_unlock(mp); 1347 } 1348 1349 fmd_event_t * 1350 fmd_case_getprincipal(fmd_hdl_t *hdl, fmd_case_t *cp) 1351 { 1352 fmd_module_t *mp = fmd_api_module_lock(hdl); 1353 fmd_case_impl_t *cip = fmd_api_case_impl(mp, cp); 1354 fmd_event_t *ep; 1355 1356 (void) pthread_mutex_lock(&cip->ci_lock); 1357 ep = cip->ci_principal; 1358 (void) pthread_mutex_unlock(&cip->ci_lock); 1359 1360 fmd_module_unlock(mp); 1361 return (ep); 1362 } 1363 1364 fmd_case_t * 1365 fmd_case_next(fmd_hdl_t *hdl, fmd_case_t *cp) 1366 { 1367 fmd_module_t *mp = fmd_api_module_lock(hdl); 1368 1369 if (cp != NULL) 1370 cp = fmd_list_next(fmd_api_case_impl(mp, cp)); 1371 else 1372 cp = fmd_list_next(&mp->mod_cases); 1373 1374 fmd_module_unlock(mp); 1375 return (cp); 1376 } 1377 1378 fmd_case_t * 1379 fmd_case_prev(fmd_hdl_t *hdl, fmd_case_t *cp) 1380 { 1381 fmd_module_t *mp = fmd_api_module_lock(hdl); 1382 1383 if (cp != NULL) 1384 cp = fmd_list_prev(fmd_api_case_impl(mp, cp)); 1385 else 1386 cp = fmd_list_prev(&mp->mod_cases); 1387 1388 fmd_module_unlock(mp); 1389 return (cp); 1390 } 1391 1392 /* 1393 * Utility function for fmd_buf_* routines. If a case is specified, use the 1394 * case's ci_bufs hash; otherwise use the module's global mod_bufs hash. 1395 */ 1396 static fmd_buf_hash_t * 1397 fmd_buf_gethash(fmd_module_t *mp, fmd_case_t *cp) 1398 { 1399 return (cp ? &fmd_api_case_impl(mp, cp)->ci_bufs : &mp->mod_bufs); 1400 } 1401 1402 void 1403 fmd_buf_create(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name, size_t size) 1404 { 1405 fmd_module_t *mp = fmd_api_module_lock(hdl); 1406 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1407 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1408 1409 if (bp == NULL) { 1410 if (fmd_strbadid(name, FMD_B_TRUE) != NULL || size == 0) { 1411 fmd_api_error(mp, EFMD_BUF_INVAL, "cannot create '%s' " 1412 "(size %lu): %s\n", name, (ulong_t)size, 1413 fmd_strerror(EFMD_BUF_INVAL)); 1414 } 1415 1416 if (mp->mod_stats->ms_buflimit.fmds_value.ui64 - 1417 mp->mod_stats->ms_buftotal.fmds_value.ui64 < size) { 1418 fmd_api_error(mp, EFMD_BUF_LIMIT, "cannot create '%s': " 1419 "buf limit exceeded (%llu)\n", name, (u_longlong_t) 1420 mp->mod_stats->ms_buflimit.fmds_value.ui64); 1421 } 1422 1423 mp->mod_stats->ms_buftotal.fmds_value.ui64 += size; 1424 bp = fmd_buf_insert(bhp, name, size); 1425 1426 } else { 1427 fmd_api_error(mp, EFMD_BUF_EXISTS, 1428 "cannot create '%s': buffer already exists\n", name); 1429 } 1430 1431 if (cp != NULL) 1432 fmd_case_setdirty(cp); 1433 else 1434 fmd_module_setdirty(mp); 1435 1436 fmd_module_unlock(mp); 1437 } 1438 1439 void 1440 fmd_buf_destroy(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1441 { 1442 fmd_module_t *mp = fmd_api_module_lock(hdl); 1443 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1444 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1445 1446 if (bp != NULL) { 1447 mp->mod_stats->ms_buftotal.fmds_value.ui64 -= bp->buf_size; 1448 fmd_buf_delete(bhp, name); 1449 1450 if (cp != NULL) 1451 fmd_case_setdirty(cp); 1452 else 1453 fmd_module_setdirty(mp); 1454 } 1455 1456 fmd_module_unlock(mp); 1457 } 1458 1459 void 1460 fmd_buf_read(fmd_hdl_t *hdl, fmd_case_t *cp, 1461 const char *name, void *buf, size_t size) 1462 { 1463 fmd_module_t *mp = fmd_api_module_lock(hdl); 1464 fmd_buf_t *bp = fmd_buf_lookup(fmd_buf_gethash(mp, cp), name); 1465 1466 if (bp == NULL) { 1467 fmd_api_error(mp, EFMD_BUF_NOENT, "no buf named '%s' is " 1468 "associated with %s\n", name, cp ? "case" : "module"); 1469 } 1470 1471 bcopy(bp->buf_data, buf, MIN(bp->buf_size, size)); 1472 if (size > bp->buf_size) 1473 bzero((char *)buf + bp->buf_size, size - bp->buf_size); 1474 1475 fmd_module_unlock(mp); 1476 } 1477 1478 void 1479 fmd_buf_write(fmd_hdl_t *hdl, fmd_case_t *cp, 1480 const char *name, const void *buf, size_t size) 1481 { 1482 fmd_module_t *mp = fmd_api_module_lock(hdl); 1483 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1484 fmd_buf_t *bp = fmd_buf_lookup(bhp, name); 1485 1486 if (bp == NULL) { 1487 if (fmd_strbadid(name, FMD_B_TRUE) != NULL || size == 0) { 1488 fmd_api_error(mp, EFMD_BUF_INVAL, "cannot write '%s' " 1489 "(size %lu): %s\n", name, (ulong_t)size, 1490 fmd_strerror(EFMD_BUF_INVAL)); 1491 } 1492 1493 if (mp->mod_stats->ms_buflimit.fmds_value.ui64 - 1494 mp->mod_stats->ms_buftotal.fmds_value.ui64 < size) { 1495 fmd_api_error(mp, EFMD_BUF_LIMIT, "cannot write '%s': " 1496 "buf limit exceeded (%llu)\n", name, (u_longlong_t) 1497 mp->mod_stats->ms_buflimit.fmds_value.ui64); 1498 } 1499 1500 mp->mod_stats->ms_buftotal.fmds_value.ui64 += size; 1501 bp = fmd_buf_insert(bhp, name, size); 1502 1503 } else if (size > bp->buf_size) { 1504 fmd_api_error(mp, EFMD_BUF_OFLOW, 1505 "write to buf '%s' overflows buf size (%lu > %lu)\n", 1506 name, (ulong_t)size, (ulong_t)bp->buf_size); 1507 } 1508 1509 bcopy(buf, bp->buf_data, MIN(bp->buf_size, size)); 1510 bp->buf_flags |= FMD_BUF_DIRTY; 1511 1512 if (cp != NULL) 1513 fmd_case_setdirty(cp); 1514 else 1515 fmd_module_setdirty(mp); 1516 1517 fmd_module_unlock(mp); 1518 } 1519 1520 size_t 1521 fmd_buf_size(fmd_hdl_t *hdl, fmd_case_t *cp, const char *name) 1522 { 1523 fmd_module_t *mp = fmd_api_module_lock(hdl); 1524 fmd_buf_hash_t *bhp = fmd_buf_gethash(mp, cp); 1525 1526 fmd_buf_t *bp; 1527 size_t size; 1528 1529 if ((bp = fmd_buf_lookup(bhp, name)) != NULL) 1530 size = bp->buf_size; 1531 else 1532 size = 0; 1533 1534 fmd_module_unlock(mp); 1535 return (size); 1536 } 1537 1538 void 1539 fmd_serd_create(fmd_hdl_t *hdl, const char *name, uint_t n, hrtime_t t) 1540 { 1541 fmd_module_t *mp = fmd_api_module_lock(hdl); 1542 1543 if (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL) { 1544 fmd_api_error(mp, EFMD_SERD_EXISTS, 1545 "failed to create serd engine '%s': %s\n", 1546 name, fmd_strerror(EFMD_SERD_EXISTS)); 1547 } 1548 1549 (void) fmd_serd_eng_insert(&mp->mod_serds, name, n, t); 1550 fmd_module_setdirty(mp); 1551 fmd_module_unlock(mp); 1552 } 1553 1554 void 1555 fmd_serd_destroy(fmd_hdl_t *hdl, const char *name) 1556 { 1557 fmd_module_t *mp = fmd_api_module_lock(hdl); 1558 1559 fmd_serd_eng_delete(&mp->mod_serds, name); 1560 fmd_module_setdirty(mp); 1561 fmd_module_unlock(mp); 1562 } 1563 1564 int 1565 fmd_serd_exists(fmd_hdl_t *hdl, const char *name) 1566 { 1567 fmd_module_t *mp = fmd_api_module_lock(hdl); 1568 int rv = (fmd_serd_eng_lookup(&mp->mod_serds, name) != NULL); 1569 fmd_module_unlock(mp); 1570 1571 return (rv); 1572 } 1573 1574 void 1575 fmd_serd_reset(fmd_hdl_t *hdl, const char *name) 1576 { 1577 fmd_module_t *mp = fmd_api_module_lock(hdl); 1578 fmd_serd_eng_t *sgp; 1579 1580 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1581 fmd_api_error(mp, EFMD_SERD_NAME, 1582 "serd engine '%s' does not exist\n", name); 1583 } 1584 1585 fmd_serd_eng_reset(sgp); 1586 fmd_module_setdirty(mp); 1587 fmd_module_unlock(mp); 1588 } 1589 1590 int 1591 fmd_serd_record(fmd_hdl_t *hdl, const char *name, fmd_event_t *ep) 1592 { 1593 fmd_module_t *mp = fmd_api_module_lock(hdl); 1594 fmd_serd_eng_t *sgp; 1595 int err; 1596 1597 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1598 fmd_api_error(mp, EFMD_SERD_NAME, 1599 "failed to add record to serd engine '%s'", name); 1600 } 1601 1602 err = fmd_serd_eng_record(sgp, ep); 1603 1604 if (sgp->sg_flags & FMD_SERD_DIRTY) 1605 fmd_module_setdirty(mp); 1606 1607 fmd_module_unlock(mp); 1608 return (err); 1609 } 1610 1611 int 1612 fmd_serd_fired(fmd_hdl_t *hdl, const char *name) 1613 { 1614 fmd_module_t *mp = fmd_api_module_lock(hdl); 1615 fmd_serd_eng_t *sgp; 1616 int err; 1617 1618 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1619 fmd_api_error(mp, EFMD_SERD_NAME, 1620 "serd engine '%s' does not exist\n", name); 1621 } 1622 1623 err = fmd_serd_eng_fired(sgp); 1624 fmd_module_unlock(mp); 1625 return (err); 1626 } 1627 1628 int 1629 fmd_serd_empty(fmd_hdl_t *hdl, const char *name) 1630 { 1631 fmd_module_t *mp = fmd_api_module_lock(hdl); 1632 fmd_serd_eng_t *sgp; 1633 int empty; 1634 1635 if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { 1636 fmd_api_error(mp, EFMD_SERD_NAME, 1637 "serd engine '%s' does not exist\n", name); 1638 } 1639 1640 empty = fmd_serd_eng_empty(sgp); 1641 fmd_module_unlock(mp); 1642 return (empty); 1643 } 1644 1645 pthread_t 1646 fmd_thr_create(fmd_hdl_t *hdl, void (*func)(void *), void *arg) 1647 { 1648 fmd_module_t *mp = fmd_api_module_lock(hdl); 1649 fmd_thread_t *tp; 1650 pthread_t tid; 1651 1652 if (mp->mod_stats->ms_thrtotal.fmds_value.ui32 >= 1653 mp->mod_stats->ms_thrlimit.fmds_value.ui32) { 1654 fmd_api_error(mp, EFMD_THR_LIMIT, "%s request to create an " 1655 "auxiliary thread exceeds module thread limit (%u)\n", 1656 mp->mod_name, mp->mod_stats->ms_thrlimit.fmds_value.ui32); 1657 } 1658 1659 if ((tp = fmd_thread_create(mp, func, arg)) == NULL) { 1660 fmd_api_error(mp, EFMD_THR_CREATE, 1661 "failed to create auxiliary thread"); 1662 } 1663 1664 tid = tp->thr_tid; 1665 mp->mod_stats->ms_thrtotal.fmds_value.ui32++; 1666 (void) fmd_idspace_xalloc(mp->mod_threads, tid, tp); 1667 1668 fmd_module_unlock(mp); 1669 return (tid); 1670 } 1671 1672 void 1673 fmd_thr_destroy(fmd_hdl_t *hdl, pthread_t tid) 1674 { 1675 fmd_module_t *mp = fmd_api_module_lock(hdl); 1676 fmd_thread_t *tp; 1677 int err; 1678 1679 if (pthread_self() == tid) { 1680 fmd_api_error(mp, EFMD_THR_INVAL, "auxiliary thread tried to " 1681 "destroy itself (tid %u)\n", tid); 1682 } 1683 1684 if ((tp = fmd_idspace_getspecific(mp->mod_threads, tid)) == NULL) { 1685 fmd_api_error(mp, EFMD_THR_INVAL, "auxiliary thread tried to " 1686 "destroy an invalid thread (tid %u)\n", tid); 1687 } 1688 1689 /* 1690 * Wait for the specified thread to exit and then join with it. Since 1691 * the thread may need to make API calls in order to complete its work 1692 * we must sleep with the module lock unheld, and then reacquire it. 1693 */ 1694 fmd_module_unlock(mp); 1695 err = pthread_join(tid, NULL); 1696 mp = fmd_api_module_lock(hdl); 1697 1698 /* 1699 * Since pthread_join() was called without the module lock held, if 1700 * multiple callers attempted to destroy the same auxiliary thread 1701 * simultaneously, one will succeed and the others will get ESRCH. 1702 * Therefore we silently ignore ESRCH but only allow the caller who 1703 * succeessfully joined with the auxiliary thread to destroy it. 1704 */ 1705 if (err != 0 && err != ESRCH) { 1706 fmd_api_error(mp, EFMD_THR_JOIN, 1707 "failed to join with auxiliary thread %u\n", tid); 1708 } 1709 1710 if (err == 0) { 1711 fmd_thread_destroy(tp, FMD_THREAD_NOJOIN); 1712 mp->mod_stats->ms_thrtotal.fmds_value.ui32--; 1713 (void) fmd_idspace_free(mp->mod_threads, tid); 1714 } 1715 1716 fmd_module_unlock(mp); 1717 } 1718 1719 void 1720 fmd_thr_signal(fmd_hdl_t *hdl, pthread_t tid) 1721 { 1722 fmd_module_t *mp = fmd_api_module_lock(hdl); 1723 1724 if (tid != mp->mod_thread->thr_tid && 1725 fmd_idspace_getspecific(mp->mod_threads, tid) == NULL) { 1726 fmd_api_error(mp, EFMD_THR_INVAL, "tid %u is not a valid " 1727 "thread id for module %s\n", tid, mp->mod_name); 1728 } 1729 1730 (void) pthread_kill(tid, fmd.d_thr_sig); 1731 fmd_module_unlock(mp); 1732 } 1733 1734 void 1735 fmd_thr_checkpoint(fmd_hdl_t *hdl) 1736 { 1737 fmd_module_t *mp = fmd_api_module_lock(hdl); 1738 pthread_t tid = pthread_self(); 1739 1740 if (tid == mp->mod_thread->thr_tid || 1741 fmd_idspace_getspecific(mp->mod_threads, tid) == NULL) { 1742 fmd_api_error(mp, EFMD_THR_INVAL, "tid %u is not a valid " 1743 "auxiliary thread id for module %s\n", tid, mp->mod_name); 1744 } 1745 1746 fmd_ckpt_save(mp); 1747 1748 fmd_module_unlock(mp); 1749 } 1750 1751 id_t 1752 fmd_timer_install(fmd_hdl_t *hdl, void *arg, fmd_event_t *ep, hrtime_t delta) 1753 { 1754 fmd_module_t *mp = fmd_api_module_lock(hdl); 1755 fmd_modtimer_t *t; 1756 id_t id; 1757 1758 if (delta < 0) { 1759 fmd_api_error(mp, EFMD_TIMER_INVAL, 1760 "timer delta %lld is not a valid interval\n", delta); 1761 } 1762 1763 t = fmd_alloc(sizeof (fmd_modtimer_t), FMD_SLEEP); 1764 t->mt_mod = mp; 1765 t->mt_arg = arg; 1766 t->mt_id = -1; 1767 1768 if ((id = fmd_timerq_install(fmd.d_timers, mp->mod_timerids, 1769 (fmd_timer_f *)fmd_module_timeout, t, ep, delta)) == -1) { 1770 fmd_free(t, sizeof (fmd_modtimer_t)); 1771 fmd_api_error(mp, EFMD_TIMER_LIMIT, 1772 "failed to install timer +%lld", delta); 1773 } 1774 1775 fmd_module_unlock(mp); 1776 return (id); 1777 } 1778 1779 void 1780 fmd_timer_remove(fmd_hdl_t *hdl, id_t id) 1781 { 1782 fmd_module_t *mp = fmd_api_module_lock(hdl); 1783 fmd_modtimer_t *t; 1784 1785 if (!fmd_idspace_valid(mp->mod_timerids, id)) { 1786 fmd_api_error(mp, EFMD_TIMER_INVAL, 1787 "id %ld is not a valid timer id\n", id); 1788 } 1789 1790 /* 1791 * If the timer has not fired (t != NULL), remove it from the timer 1792 * queue. If the timer has fired (t == NULL), we could be in one of 1793 * two situations: a) we are processing the timer callback or b) 1794 * the timer event is on the module queue awaiting dispatch. For a), 1795 * fmd_timerq_remove() will wait for the timer callback function 1796 * to complete and queue an event for dispatch. For a) and b), 1797 * we cancel the outstanding timer event from the module's dispatch 1798 * queue. 1799 */ 1800 if ((t = fmd_timerq_remove(fmd.d_timers, mp->mod_timerids, id)) != NULL) 1801 fmd_free(t, sizeof (fmd_modtimer_t)); 1802 fmd_module_unlock(mp); 1803 1804 fmd_eventq_cancel(mp->mod_queue, FMD_EVT_TIMEOUT, (void *)id); 1805 } 1806 1807 nvlist_t * 1808 fmd_nvl_create_fault(fmd_hdl_t *hdl, const char *class, 1809 uint8_t certainty, nvlist_t *asru, nvlist_t *fru, nvlist_t *rsrc) 1810 { 1811 fmd_module_t *mp; 1812 nvlist_t *nvl; 1813 1814 mp = fmd_api_module_lock(hdl); 1815 if (class == NULL || class[0] == '\0') 1816 fmd_api_error(mp, EFMD_NVL_INVAL, "invalid fault class\n"); 1817 1818 nvl = fmd_protocol_fault(class, certainty, asru, fru, rsrc, NULL); 1819 1820 fmd_module_unlock(mp); 1821 1822 return (nvl); 1823 } 1824 1825 int 1826 fmd_nvl_class_match(fmd_hdl_t *hdl, nvlist_t *nvl, const char *pattern) 1827 { 1828 fmd_module_t *mp = fmd_api_module_lock(hdl); 1829 char *class; 1830 int rv; 1831 1832 rv = (nvl != NULL && nvlist_lookup_string(nvl, 1833 FM_CLASS, &class) == 0 && fmd_strmatch(class, pattern)); 1834 1835 fmd_module_unlock(mp); 1836 return (rv); 1837 } 1838 1839 int 1840 fmd_nvl_fmri_expand(fmd_hdl_t *hdl, nvlist_t *nvl) 1841 { 1842 fmd_module_t *mp = fmd_api_module_lock(hdl); 1843 int rv; 1844 1845 if (nvl == NULL) { 1846 fmd_api_error(mp, EFMD_NVL_INVAL, 1847 "invalid nvlist %p\n", (void *)nvl); 1848 } 1849 1850 rv = fmd_fmri_expand(nvl); 1851 fmd_module_unlock(mp); 1852 return (rv); 1853 } 1854 1855 int 1856 fmd_nvl_fmri_present(fmd_hdl_t *hdl, nvlist_t *nvl) 1857 { 1858 fmd_module_t *mp = fmd_api_module_lock(hdl); 1859 int rv; 1860 1861 if (nvl == NULL) { 1862 fmd_api_error(mp, EFMD_NVL_INVAL, 1863 "invalid nvlist %p\n", (void *)nvl); 1864 } 1865 1866 rv = fmd_fmri_present(nvl); 1867 fmd_module_unlock(mp); 1868 1869 if (rv < 0) { 1870 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1871 "fmd_nvl_fmri_present\n"); 1872 } 1873 1874 return (rv); 1875 } 1876 1877 int 1878 fmd_nvl_fmri_replaced(fmd_hdl_t *hdl, nvlist_t *nvl) 1879 { 1880 fmd_module_t *mp = fmd_api_module_lock(hdl); 1881 int rv; 1882 1883 if (nvl == NULL) { 1884 fmd_api_error(mp, EFMD_NVL_INVAL, 1885 "invalid nvlist %p\n", (void *)nvl); 1886 } 1887 1888 rv = fmd_fmri_replaced(nvl); 1889 fmd_module_unlock(mp); 1890 1891 return (rv); 1892 } 1893 1894 int 1895 fmd_nvl_fmri_unusable(fmd_hdl_t *hdl, nvlist_t *nvl) 1896 { 1897 fmd_module_t *mp = fmd_api_module_lock(hdl); 1898 int rv; 1899 1900 if (nvl == NULL) { 1901 fmd_api_error(mp, EFMD_NVL_INVAL, 1902 "invalid nvlist %p\n", (void *)nvl); 1903 } 1904 1905 rv = fmd_fmri_unusable(nvl); 1906 fmd_module_unlock(mp); 1907 1908 if (rv < 0) { 1909 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1910 "fmd_nvl_fmri_unusable\n"); 1911 } 1912 1913 return (rv); 1914 } 1915 1916 int 1917 fmd_nvl_fmri_retire(fmd_hdl_t *hdl, nvlist_t *nvl) 1918 { 1919 fmd_module_t *mp = fmd_api_module_lock(hdl); 1920 int rv; 1921 1922 if (nvl == NULL) { 1923 fmd_api_error(mp, EFMD_NVL_INVAL, 1924 "invalid nvlist %p\n", (void *)nvl); 1925 } 1926 1927 rv = fmd_fmri_retire(nvl); 1928 fmd_module_unlock(mp); 1929 1930 return (rv); 1931 } 1932 1933 int 1934 fmd_nvl_fmri_unretire(fmd_hdl_t *hdl, nvlist_t *nvl) 1935 { 1936 fmd_module_t *mp = fmd_api_module_lock(hdl); 1937 int rv; 1938 1939 if (nvl == NULL) { 1940 fmd_api_error(mp, EFMD_NVL_INVAL, 1941 "invalid nvlist %p\n", (void *)nvl); 1942 } 1943 1944 rv = fmd_fmri_unretire(nvl); 1945 fmd_module_unlock(mp); 1946 1947 return (rv); 1948 } 1949 1950 int 1951 fmd_nvl_fmri_service_state(fmd_hdl_t *hdl, nvlist_t *nvl) 1952 { 1953 fmd_module_t *mp = fmd_api_module_lock(hdl); 1954 int rv; 1955 1956 if (nvl == NULL) { 1957 fmd_api_error(mp, EFMD_NVL_INVAL, 1958 "invalid nvlist %p\n", (void *)nvl); 1959 } 1960 1961 rv = fmd_fmri_service_state(nvl); 1962 if (rv < 0) 1963 rv = fmd_fmri_unusable(nvl) ? FMD_SERVICE_STATE_UNUSABLE : 1964 FMD_SERVICE_STATE_OK; 1965 fmd_module_unlock(mp); 1966 1967 if (rv < 0) { 1968 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 1969 "fmd_nvl_fmri_service_state\n"); 1970 } 1971 1972 return (rv); 1973 } 1974 1975 typedef struct { 1976 const char *class; 1977 int *rvp; 1978 } fmd_has_fault_arg_t; 1979 1980 static void 1981 fmd_rsrc_has_fault(fmd_asru_link_t *alp, void *arg) 1982 { 1983 fmd_has_fault_arg_t *fhfp = (fmd_has_fault_arg_t *)arg; 1984 char *class; 1985 1986 if (fhfp->class == NULL) { 1987 if (alp->al_flags & FMD_ASRU_FAULTY) 1988 *fhfp->rvp = 1; 1989 } else { 1990 if ((alp->al_flags & FMD_ASRU_FAULTY) && 1991 alp->al_event != NULL && nvlist_lookup_string(alp->al_event, 1992 FM_CLASS, &class) == 0 && fmd_strmatch(class, fhfp->class)) 1993 *fhfp->rvp = 1; 1994 } 1995 } 1996 1997 int 1998 fmd_nvl_fmri_has_fault(fmd_hdl_t *hdl, nvlist_t *nvl, int type, char *class) 1999 { 2000 fmd_module_t *mp = fmd_api_module_lock(hdl); 2001 fmd_asru_hash_t *ahp = fmd.d_asrus; 2002 int rv = 0; 2003 char *name; 2004 int namelen; 2005 fmd_has_fault_arg_t fhf; 2006 2007 if (nvl == NULL) { 2008 fmd_api_error(mp, EFMD_NVL_INVAL, 2009 "invalid nvlist %p\n", (void *)nvl); 2010 } 2011 if ((namelen = fmd_fmri_nvl2str(nvl, NULL, 0)) == -1) 2012 fmd_api_error(mp, EFMD_NVL_INVAL, 2013 "invalid nvlist: %p\n", (void *)nvl); 2014 name = fmd_alloc(namelen + 1, FMD_SLEEP); 2015 if (fmd_fmri_nvl2str(nvl, name, namelen + 1) == -1) { 2016 if (name != NULL) 2017 fmd_free(name, namelen + 1); 2018 fmd_api_error(mp, EFMD_NVL_INVAL, 2019 "invalid nvlist: %p\n", (void *)nvl); 2020 } 2021 2022 fhf.class = class; 2023 fhf.rvp = &rv; 2024 if (type == FMD_HAS_FAULT_RESOURCE) 2025 fmd_asru_hash_apply_by_rsrc(ahp, name, fmd_rsrc_has_fault, 2026 &fhf); 2027 else if (type == FMD_HAS_FAULT_ASRU) 2028 fmd_asru_hash_apply_by_asru(ahp, name, fmd_rsrc_has_fault, 2029 &fhf); 2030 else if (type == FMD_HAS_FAULT_FRU) 2031 fmd_asru_hash_apply_by_fru(ahp, name, fmd_rsrc_has_fault, 2032 &fhf); 2033 2034 if (name != NULL) 2035 fmd_free(name, namelen + 1); 2036 fmd_module_unlock(mp); 2037 return (rv); 2038 } 2039 2040 int 2041 fmd_nvl_fmri_contains(fmd_hdl_t *hdl, nvlist_t *n1, nvlist_t *n2) 2042 { 2043 fmd_module_t *mp = fmd_api_module_lock(hdl); 2044 int rv; 2045 2046 if (n1 == NULL || n2 == NULL) { 2047 fmd_api_error(mp, EFMD_NVL_INVAL, 2048 "invalid nvlist(s): %p, %p\n", (void *)n1, (void *)n2); 2049 } 2050 2051 rv = fmd_fmri_contains(n1, n2); 2052 fmd_module_unlock(mp); 2053 2054 if (rv < 0) { 2055 fmd_api_error(mp, EFMD_FMRI_OP, "invalid fmri for " 2056 "fmd_nvl_fmri_contains\n"); 2057 } 2058 2059 return (rv); 2060 } 2061 2062 nvlist_t * 2063 fmd_nvl_fmri_translate(fmd_hdl_t *hdl, nvlist_t *fmri, nvlist_t *auth) 2064 { 2065 fmd_module_t *mp = fmd_api_module_lock(hdl); 2066 nvlist_t *xfmri; 2067 2068 if (fmri == NULL || auth == NULL) { 2069 fmd_api_error(mp, EFMD_NVL_INVAL, 2070 "invalid nvlist(s): %p, %p\n", (void *)fmri, (void *)auth); 2071 } 2072 2073 xfmri = fmd_fmri_translate(fmri, auth); 2074 fmd_module_unlock(mp); 2075 return (xfmri); 2076 } 2077 2078 static int 2079 fmd_nvl_op_init(nv_alloc_t *ops, va_list ap) 2080 { 2081 fmd_module_t *mp = va_arg(ap, fmd_module_t *); 2082 2083 ops->nva_arg = mp; 2084 2085 return (0); 2086 } 2087 2088 static void * 2089 fmd_nvl_op_alloc_sleep(nv_alloc_t *ops, size_t size) 2090 { 2091 fmd_module_t *mp = ops->nva_arg; 2092 2093 return (fmd_hdl_alloc_locked(mp, size, FMD_SLEEP)); 2094 } 2095 2096 static void * 2097 fmd_nvl_op_alloc_nosleep(nv_alloc_t *ops, size_t size) 2098 { 2099 fmd_module_t *mp = ops->nva_arg; 2100 2101 return (fmd_hdl_alloc_locked(mp, size, FMD_NOSLEEP)); 2102 } 2103 2104 static void 2105 fmd_nvl_op_free(nv_alloc_t *ops, void *data, size_t size) 2106 { 2107 fmd_module_t *mp = ops->nva_arg; 2108 2109 fmd_hdl_free_locked(mp, data, size); 2110 } 2111 2112 nv_alloc_ops_t fmd_module_nva_ops_sleep = { 2113 fmd_nvl_op_init, 2114 NULL, 2115 fmd_nvl_op_alloc_sleep, 2116 fmd_nvl_op_free, 2117 NULL 2118 }; 2119 2120 nv_alloc_ops_t fmd_module_nva_ops_nosleep = { 2121 fmd_nvl_op_init, 2122 NULL, 2123 fmd_nvl_op_alloc_nosleep, 2124 fmd_nvl_op_free, 2125 NULL 2126 }; 2127 2128 nvlist_t * 2129 fmd_nvl_alloc(fmd_hdl_t *hdl, int flags) 2130 { 2131 fmd_module_t *mp = fmd_api_module_lock(hdl); 2132 nv_alloc_t *nva; 2133 nvlist_t *nvl; 2134 int ret; 2135 2136 if (flags == FMD_SLEEP) 2137 nva = &mp->mod_nva_sleep; 2138 else 2139 nva = &mp->mod_nva_nosleep; 2140 2141 ret = nvlist_xalloc(&nvl, NV_UNIQUE_NAME, nva); 2142 2143 fmd_module_unlock(mp); 2144 2145 if (ret != 0) 2146 return (NULL); 2147 else 2148 return (nvl); 2149 } 2150 2151 nvlist_t * 2152 fmd_nvl_dup(fmd_hdl_t *hdl, nvlist_t *src, int flags) 2153 { 2154 fmd_module_t *mp = fmd_api_module_lock(hdl); 2155 nv_alloc_t *nva; 2156 nvlist_t *nvl; 2157 int ret; 2158 2159 if (flags == FMD_SLEEP) 2160 nva = &mp->mod_nva_sleep; 2161 else 2162 nva = &mp->mod_nva_nosleep; 2163 2164 ret = nvlist_xdup(src, &nvl, nva); 2165 2166 fmd_module_unlock(mp); 2167 2168 if (ret != 0) 2169 return (NULL); 2170 else 2171 return (nvl); 2172 } 2173 2174 int 2175 fmd_event_local(fmd_hdl_t *hdl, fmd_event_t *ep) 2176 { 2177 if (hdl == NULL || ep == NULL) { 2178 fmd_api_error(fmd_api_module_lock(hdl), EFMD_EVENT_INVAL, 2179 "NULL parameter specified to fmd_event_local\n"); 2180 } 2181 2182 return (((fmd_event_impl_t *)ep)->ev_flags & FMD_EVF_LOCAL); 2183 } 2184 2185 /*ARGSUSED*/ 2186 uint64_t 2187 fmd_event_ena_create(fmd_hdl_t *hdl) 2188 { 2189 return (fmd_ena()); 2190 } 2191 2192 fmd_xprt_t * 2193 fmd_xprt_open(fmd_hdl_t *hdl, uint_t flags, nvlist_t *auth, void *data) 2194 { 2195 fmd_module_t *mp = fmd_api_module_lock(hdl); 2196 fmd_xprt_t *xp; 2197 2198 if (flags & ~FMD_XPRT_CMASK) { 2199 fmd_api_error(mp, EFMD_XPRT_INVAL, 2200 "invalid transport flags 0x%x\n", flags); 2201 } 2202 2203 if ((flags & FMD_XPRT_RDWR) != FMD_XPRT_RDWR && 2204 (flags & FMD_XPRT_RDWR) != FMD_XPRT_RDONLY) { 2205 fmd_api_error(mp, EFMD_XPRT_INVAL, 2206 "cannot open write-only transport\n"); 2207 } 2208 2209 if (mp->mod_stats->ms_xprtopen.fmds_value.ui32 >= 2210 mp->mod_stats->ms_xprtlimit.fmds_value.ui32) { 2211 fmd_api_error(mp, EFMD_XPRT_LIMIT, "%s request to create a " 2212 "transport exceeds module transport limit (%u)\n", 2213 mp->mod_name, mp->mod_stats->ms_xprtlimit.fmds_value.ui32); 2214 } 2215 2216 if ((xp = fmd_xprt_create(mp, flags, auth, data)) == NULL) 2217 fmd_api_error(mp, errno, "cannot create transport"); 2218 2219 fmd_module_unlock(mp); 2220 return (xp); 2221 } 2222 2223 void 2224 fmd_xprt_close(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2225 { 2226 fmd_module_t *mp = fmd_api_module_lock(hdl); 2227 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2228 2229 /* 2230 * Although this could be supported, it doesn't seem necessary or worth 2231 * the trouble. For now, just detect this and trigger a module abort. 2232 * If it is needed, transports should grow reference counts and a new 2233 * event type will need to be enqueued for the main thread to reap it. 2234 */ 2235 if (xip->xi_thread != NULL && 2236 xip->xi_thread->thr_tid == pthread_self()) { 2237 fmd_api_error(mp, EFMD_XPRT_INVAL, 2238 "fmd_xprt_close() cannot be called from fmdo_send()\n"); 2239 } 2240 2241 fmd_xprt_destroy(xp); 2242 fmd_module_unlock(mp); 2243 } 2244 2245 void 2246 fmd_xprt_post(fmd_hdl_t *hdl, fmd_xprt_t *xp, nvlist_t *nvl, hrtime_t hrt) 2247 { 2248 nv_alloc_t *nva = nvlist_lookup_nv_alloc(nvl); 2249 fmd_module_t *mp = fmd_api_module(hdl); 2250 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2251 nvlist_t *tmp; 2252 2253 /* 2254 * If this event was allocated using the module-specific nvlist ops, we 2255 * need to create a copy using the standard fmd nvlist ops. Otherwise, 2256 * the event may persist after the module has been unloaded and we'll 2257 * die when attempting to free the nvlist. 2258 */ 2259 if (nva == &mp->mod_nva_sleep || nva == &mp->mod_nva_nosleep) { 2260 (void) nvlist_xdup(nvl, &tmp, &fmd.d_nva); 2261 nvlist_free(nvl); 2262 nvl = tmp; 2263 } 2264 2265 /* 2266 * fmd_xprt_recv() must block during startup waiting for fmd to globally 2267 * clear FMD_XPRT_DSUSPENDED. As such, we can't allow it to be called 2268 * from a module's _fmd_init() routine, because that would block 2269 * fmd from completing initial module loading, resulting in a deadlock. 2270 */ 2271 if ((xip->xi_flags & FMD_XPRT_ISUSPENDED) && 2272 (pthread_self() == xip->xi_queue->eq_mod->mod_thread->thr_tid)) { 2273 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2274 "fmd_xprt_post() cannot be called from _fmd_init()\n"); 2275 } 2276 2277 fmd_xprt_recv(xp, nvl, hrt, FMD_B_FALSE); 2278 } 2279 2280 void 2281 fmd_xprt_log(fmd_hdl_t *hdl, fmd_xprt_t *xp, nvlist_t *nvl, hrtime_t hrt) 2282 { 2283 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2284 2285 /* 2286 * fmd_xprt_recv() must block during startup waiting for fmd to globally 2287 * clear FMD_XPRT_DSUSPENDED. As such, we can't allow it to be called 2288 * from a module's _fmd_init() routine, because that would block 2289 * fmd from completing initial module loading, resulting in a deadlock. 2290 */ 2291 if ((xip->xi_flags & FMD_XPRT_ISUSPENDED) && 2292 (pthread_self() == xip->xi_queue->eq_mod->mod_thread->thr_tid)) { 2293 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2294 "fmd_xprt_log() cannot be called from _fmd_init()\n"); 2295 } 2296 2297 fmd_xprt_recv(xp, nvl, hrt, FMD_B_TRUE); 2298 } 2299 2300 void 2301 fmd_xprt_suspend(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2302 { 2303 (void) fmd_api_transport_impl(hdl, xp); /* validate 'xp' */ 2304 fmd_xprt_xsuspend(xp, FMD_XPRT_SUSPENDED); 2305 } 2306 2307 void 2308 fmd_xprt_resume(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2309 { 2310 (void) fmd_api_transport_impl(hdl, xp); /* validate 'xp' */ 2311 fmd_xprt_xresume(xp, FMD_XPRT_SUSPENDED); 2312 } 2313 2314 int 2315 fmd_xprt_error(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2316 { 2317 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2318 return (xip->xi_state == _fmd_xprt_state_err); 2319 } 2320 2321 /* 2322 * Translate all FMRIs in the specified name-value pair list for the specified 2323 * FMRI authority, and return a new name-value pair list for the translation. 2324 * This function is the recursive engine used by fmd_xprt_translate(), below. 2325 */ 2326 static nvlist_t * 2327 fmd_xprt_xtranslate(nvlist_t *nvl, nvlist_t *auth) 2328 { 2329 uint_t i, j, n; 2330 nvpair_t *nvp, **nvps; 2331 uint_t nvpslen = 0; 2332 char *name; 2333 size_t namelen = 0; 2334 2335 nvlist_t **a, **b; 2336 nvlist_t *l, *r; 2337 data_type_t type; 2338 char *s; 2339 int err; 2340 2341 (void) nvlist_xdup(nvl, &nvl, &fmd.d_nva); 2342 2343 /* 2344 * Count up the number of name-value pairs in 'nvl' and compute the 2345 * maximum length of a name used in this list for use below. 2346 */ 2347 for (nvp = nvlist_next_nvpair(nvl, NULL); 2348 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp), nvpslen++) { 2349 size_t len = strlen(nvpair_name(nvp)); 2350 namelen = MAX(namelen, len); 2351 } 2352 2353 nvps = alloca(sizeof (nvpair_t *) * nvpslen); 2354 name = alloca(namelen + 1); 2355 2356 /* 2357 * Store a snapshot of the name-value pairs in 'nvl' into nvps[] so 2358 * that we can iterate over the original pairs in the loop below while 2359 * performing arbitrary insert and delete operations on 'nvl' itself. 2360 */ 2361 for (i = 0, nvp = nvlist_next_nvpair(nvl, NULL); 2362 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) 2363 nvps[i++] = nvp; 2364 2365 /* 2366 * Now iterate over the snapshot of the name-value pairs. If we find a 2367 * value that is of type NVLIST or NVLIST_ARRAY, we translate that 2368 * object by either calling ourself recursively on it, or calling into 2369 * fmd_fmri_translate() if the object is an FMRI. We then rip out the 2370 * original name-value pair and replace it with the translated one. 2371 */ 2372 for (i = 0; i < nvpslen; i++) { 2373 nvp = nvps[i]; 2374 type = nvpair_type(nvp); 2375 2376 switch (type) { 2377 case DATA_TYPE_NVLIST_ARRAY: 2378 if (nvpair_value_nvlist_array(nvp, &a, &n) != 0 || 2379 a == NULL || n == 0) 2380 continue; /* array is zero-sized; skip it */ 2381 2382 b = fmd_alloc(sizeof (nvlist_t *) * n, FMD_SLEEP); 2383 2384 /* 2385 * If the first array nvlist element looks like an FMRI 2386 * then assume the other elements are FMRIs as well. 2387 * If any b[j]'s can't be translated, then EINVAL will 2388 * be returned from nvlist_add_nvlist_array() below. 2389 */ 2390 if (nvlist_lookup_string(*a, FM_FMRI_SCHEME, &s) == 0) { 2391 for (j = 0; j < n; j++) 2392 b[j] = fmd_fmri_translate(a[j], auth); 2393 } else { 2394 for (j = 0; j < n; j++) 2395 b[j] = fmd_xprt_xtranslate(a[j], auth); 2396 } 2397 2398 (void) strcpy(name, nvpair_name(nvp)); 2399 (void) nvlist_remove(nvl, name, type); 2400 err = nvlist_add_nvlist_array(nvl, name, b, n); 2401 2402 for (j = 0; j < n; j++) 2403 nvlist_free(b[j]); 2404 2405 fmd_free(b, sizeof (nvlist_t *) * n); 2406 2407 if (err != 0) { 2408 nvlist_free(nvl); 2409 errno = err; 2410 return (NULL); 2411 } 2412 break; 2413 2414 case DATA_TYPE_NVLIST: 2415 if (nvpair_value_nvlist(nvp, &l) == 0 && 2416 nvlist_lookup_string(l, FM_FMRI_SCHEME, &s) == 0) 2417 r = fmd_fmri_translate(l, auth); 2418 else 2419 r = fmd_xprt_xtranslate(l, auth); 2420 2421 if (r == NULL) { 2422 nvlist_free(nvl); 2423 return (NULL); 2424 } 2425 2426 (void) strcpy(name, nvpair_name(nvp)); 2427 (void) nvlist_remove(nvl, name, type); 2428 (void) nvlist_add_nvlist(nvl, name, r); 2429 2430 nvlist_free(r); 2431 break; 2432 } 2433 } 2434 2435 return (nvl); 2436 } 2437 2438 nvlist_t * 2439 fmd_xprt_translate(fmd_hdl_t *hdl, fmd_xprt_t *xp, fmd_event_t *ep) 2440 { 2441 fmd_xprt_impl_t *xip = fmd_api_transport_impl(hdl, xp); 2442 2443 if (xip->xi_auth == NULL) { 2444 fmd_api_error(fmd_api_module_lock(hdl), EFMD_XPRT_INVAL, 2445 "no authority defined for transport %p\n", (void *)xp); 2446 } 2447 2448 return (fmd_xprt_xtranslate(FMD_EVENT_NVL(ep), xip->xi_auth)); 2449 } 2450 2451 void 2452 fmd_xprt_setspecific(fmd_hdl_t *hdl, fmd_xprt_t *xp, void *data) 2453 { 2454 fmd_api_transport_impl(hdl, xp)->xi_data = data; 2455 } 2456 2457 void * 2458 fmd_xprt_getspecific(fmd_hdl_t *hdl, fmd_xprt_t *xp) 2459 { 2460 return (fmd_api_transport_impl(hdl, xp)->xi_data); 2461 } 2462