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