xref: /titanic_44/usr/src/lib/fm/topo/libtopo/common/dev.c (revision a60349c89adffc0902b2353230891d8e7f2b24d9)
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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <limits.h>
27 #include <strings.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <stdio.h>
31 #include <alloca.h>
32 #include <devid.h>
33 #include <sys/stat.h>
34 #include <libnvpair.h>
35 #include <fm/topo_mod.h>
36 #include <fm/fmd_fmri.h>
37 #include <sys/fm/protocol.h>
38 
39 #include <topo_method.h>
40 #include <topo_subr.h>
41 #include <dev.h>
42 
43 static int dev_enum(topo_mod_t *, tnode_t *, const char *, topo_instance_t,
44     topo_instance_t, void *, void *);
45 static void dev_release(topo_mod_t *, tnode_t *);
46 static int dev_fmri_nvl2str(topo_mod_t *, tnode_t *, topo_version_t,
47     nvlist_t *, nvlist_t **);
48 static int dev_fmri_str2nvl(topo_mod_t *, tnode_t *, topo_version_t,
49     nvlist_t *, nvlist_t **);
50 static int dev_fmri_create_meth(topo_mod_t *, tnode_t *, topo_version_t,
51     nvlist_t *, nvlist_t **);
52 static int dev_fmri_present(topo_mod_t *, tnode_t *, topo_version_t,
53     nvlist_t *, nvlist_t **);
54 static int dev_fmri_replaced(topo_mod_t *, tnode_t *, topo_version_t,
55     nvlist_t *, nvlist_t **);
56 static int dev_fmri_unusable(topo_mod_t *, tnode_t *, topo_version_t,
57     nvlist_t *, nvlist_t **);
58 static int dev_fmri_service_state(topo_mod_t *, tnode_t *, topo_version_t,
59     nvlist_t *, nvlist_t **);
60 
61 static const topo_method_t dev_methods[] = {
62 	{ TOPO_METH_NVL2STR, TOPO_METH_NVL2STR_DESC, TOPO_METH_NVL2STR_VERSION,
63 	    TOPO_STABILITY_INTERNAL, dev_fmri_nvl2str },
64 	{ TOPO_METH_STR2NVL, TOPO_METH_STR2NVL_DESC, TOPO_METH_STR2NVL_VERSION,
65 	    TOPO_STABILITY_INTERNAL, dev_fmri_str2nvl },
66 	{ TOPO_METH_FMRI, TOPO_METH_FMRI_DESC, TOPO_METH_FMRI_VERSION,
67 	    TOPO_STABILITY_INTERNAL, dev_fmri_create_meth },
68 	{ TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, TOPO_METH_PRESENT_VERSION,
69 	    TOPO_STABILITY_INTERNAL, dev_fmri_present },
70 	{ TOPO_METH_REPLACED, TOPO_METH_REPLACED_DESC,
71 	    TOPO_METH_REPLACED_VERSION, TOPO_STABILITY_INTERNAL,
72 	    dev_fmri_replaced },
73 	{ TOPO_METH_UNUSABLE, TOPO_METH_UNUSABLE_DESC,
74 	    TOPO_METH_UNUSABLE_VERSION, TOPO_STABILITY_INTERNAL,
75 	    dev_fmri_unusable },
76 	{ TOPO_METH_SERVICE_STATE, TOPO_METH_SERVICE_STATE_DESC,
77 	    TOPO_METH_SERVICE_STATE_VERSION, TOPO_STABILITY_INTERNAL,
78 	    dev_fmri_service_state },
79 	{ NULL }
80 };
81 
82 static const topo_modops_t dev_ops =
83 	{ dev_enum, dev_release };
84 static const topo_modinfo_t dev_info =
85 	{ "dev", FM_FMRI_SCHEME_DEV, DEV_VERSION, &dev_ops };
86 
87 int
88 dev_init(topo_mod_t *mod, topo_version_t version)
89 {
90 	if (getenv("TOPOHCDEBUG"))
91 		topo_mod_setdebug(mod);
92 	topo_mod_dprintf(mod, "initializing dev builtin\n");
93 
94 	if (version != DEV_VERSION)
95 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
96 
97 	if (topo_mod_register(mod, &dev_info, TOPO_VERSION) != 0) {
98 		topo_mod_dprintf(mod, "failed to register dev_info: "
99 		    "%s\n", topo_mod_errmsg(mod));
100 		return (-1);
101 	}
102 
103 	return (0);
104 }
105 
106 void
107 dev_fini(topo_mod_t *mod)
108 {
109 	topo_mod_unregister(mod);
110 }
111 
112 /*ARGSUSED*/
113 static int
114 dev_enum(topo_mod_t *mod, tnode_t *pnode, const char *name,
115     topo_instance_t min, topo_instance_t max, void *notused1, void *notused2)
116 {
117 	/*
118 	 * Methods are registered, but there is no enumeration.  Should
119 	 * enumeration be added be sure to cater for global vs non-global
120 	 * zones.
121 	 */
122 	(void) topo_method_register(mod, pnode, dev_methods);
123 	return (0);
124 }
125 
126 static void
127 dev_release(topo_mod_t *mod, tnode_t *node)
128 {
129 	topo_method_unregister_all(mod, node);
130 }
131 
132 static ssize_t
133 fmri_nvl2str(nvlist_t *nvl, char *buf, size_t buflen)
134 {
135 	char *devid = NULL, *tpl0id = NULL;
136 	char *devpath = NULL;
137 	ssize_t size = 0;
138 	uint8_t version;
139 	int err;
140 
141 	if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 ||
142 	    version > FM_DEV_SCHEME_VERSION)
143 		return (-1);
144 
145 	/* Get devid, if present */
146 	err = nvlist_lookup_string(nvl, FM_FMRI_DEV_ID, &devid);
147 	if (err != 0 && err != ENOENT)
148 		return (-1);
149 
150 	/* Get target-port-l0id, if present */
151 	err = nvlist_lookup_string(nvl, FM_FMRI_DEV_TGTPTLUN0, &tpl0id);
152 	if (err != 0 && err != ENOENT)
153 		return (-1);
154 
155 	/* There must be a device path present */
156 	err = nvlist_lookup_string(nvl, FM_FMRI_DEV_PATH, &devpath);
157 	if (err != 0 || devpath == NULL)
158 		return (-1);
159 
160 	/*
161 	 * dev:///
162 	 *
163 	 * The dev scheme does not render fmri authority information
164 	 * in the string form of an fmri.  It is meaningless to
165 	 * transmit a dev scheme fmri outside of the immediate fault
166 	 * manager.
167 	 */
168 	topo_fmristr_build(&size,
169 	    buf, buflen, FM_FMRI_SCHEME_DEV, NULL, ":///");
170 
171 	/* device-id part, topo_fmristr_build does nothing if devid is NULL */
172 	topo_fmristr_build(&size,
173 	    buf, buflen, devid, ":" FM_FMRI_DEV_ID "=", NULL);
174 
175 	/* target-port-l0id part */
176 	topo_fmristr_build(&size,
177 	    buf, buflen, tpl0id, ":" FM_FMRI_DEV_TGTPTLUN0 "=", NULL);
178 
179 	/*
180 	 * device-path part; the devpath should always start with a /
181 	 * so you'd think we don't need to add a further / prefix here;
182 	 * however past implementation has always added the / if
183 	 * there is a devid component so we continue to do that
184 	 * so strings match exactly as before.  So we can have:
185 	 *
186 	 *	dev:////pci@0,0/...
187 	 *	dev:///<devid-and-tpl0>//pci@0,0/...
188 	 *
189 	 *	where <devid-and-tpl0> =
190 	 *			[:devid=<devid>][:target-port-l0id=<tpl0>]
191 	 */
192 	topo_fmristr_build(&size, buf, buflen, devpath,
193 	    devid || tpl0id ? "/" : NULL, NULL);
194 
195 	return (size);
196 }
197 
198 /*ARGSUSED*/
199 static int
200 dev_fmri_nvl2str(topo_mod_t *mod, tnode_t *node, topo_version_t version,
201     nvlist_t *nvl, nvlist_t **out)
202 {
203 	ssize_t len;
204 	char *name = NULL;
205 	nvlist_t *fmristr;
206 
207 	if (version > TOPO_METH_NVL2STR_VERSION)
208 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
209 
210 	if ((len = fmri_nvl2str(nvl, NULL, 0)) == 0 ||
211 	    (name = topo_mod_alloc(mod, len + 1)) == NULL ||
212 	    fmri_nvl2str(nvl, name, len + 1) == 0) {
213 		if (name != NULL)
214 			topo_mod_free(mod, name, len + 1);
215 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
216 	}
217 
218 	if (topo_mod_nvalloc(mod, &fmristr, NV_UNIQUE_NAME) != 0)
219 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
220 	if (nvlist_add_string(fmristr, "fmri-string", name) != 0) {
221 		topo_mod_free(mod, name, len + 1);
222 		nvlist_free(fmristr);
223 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
224 	}
225 	topo_mod_free(mod, name, len + 1);
226 	*out = fmristr;
227 
228 	return (0);
229 }
230 
231 /*ARGSUSED*/
232 static int
233 dev_fmri_str2nvl(topo_mod_t *mod, tnode_t *node, topo_version_t version,
234     nvlist_t *in, nvlist_t **out)
235 {
236 	char *cur, *devid = NULL, *tpl0id = NULL;
237 	char *str, *strcp;
238 	nvlist_t *fmri;
239 	char *devpath;
240 	size_t len;
241 	int err;
242 
243 	if (version > TOPO_METH_STR2NVL_VERSION)
244 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
245 
246 	if (nvlist_lookup_string(in, "fmri-string", &str) != 0)
247 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
248 
249 	len = strlen(str);
250 
251 	/*
252 	 * We're expecting a string version of a dev scheme FMRI, and
253 	 * no fmri authority information.
254 	 *
255 	 * The shortest legal string would be "dev:////" (len 8) for a string
256 	 * with no FMRI auth info, no devid or target-port-l0id and
257 	 * an empty devpath string.
258 	 */
259 	if (len < 8 || strncmp(str, "dev:///", 7) != 0)
260 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
261 
262 	strcp = alloca(len + 1);
263 	(void) memcpy(strcp, str, len);
264 	strcp[len] = '\0';
265 	cur = strcp + 7;	/* already parsed "dev:///" */
266 
267 	/*
268 	 * If the first character after the "/" that terminates the (empty)
269 	 * fmri authority is a colon then we have devid and/or target-port-l0id
270 	 * info.  They could be in either order.
271 	 *
272 	 * If not a colon then it must be the / that begins the devpath.
273 	 */
274 	if (*cur == ':') {
275 		char *eos, *part[2];
276 		int i;
277 		/*
278 		 * Look ahead to the "/" that starts the devpath.  If not
279 		 * found or if straight after the : then we're busted.
280 		 */
281 		eos = devpath = strchr(cur, '/');
282 		if (devpath == NULL || devpath == cur + 1)
283 			return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
284 
285 		part[0] = ++cur;
286 
287 		/*
288 		 * Replace the initial "/" of the devpath with a NUL
289 		 * to terminate the string before it.  We'll undo this
290 		 * before rendering devpath.
291 		 */
292 		*eos = '\0';
293 
294 		/*
295 		 * We should now have a NUL-terminated string matching
296 		 * foo=<pat1>[:bar=<pat2>] (we stepped over the initial :)
297 		 * Look for a second colon; if found there must be space
298 		 * after it for the additional component, but no more colons.
299 		 */
300 		if ((part[1] = strchr(cur, ':')) != NULL) {
301 			if (part[1] + 1 == eos ||
302 			    strchr(part[1] + 1, ':') != NULL)
303 				return (topo_mod_seterrno(mod,
304 				    EMOD_FMRI_MALFORM));
305 			*part[1] = '\0'; /* terminate part[0] */
306 			part[1]++;
307 		}
308 
309 		for (i = 0; i < 2; i++) {
310 			char *eq;
311 
312 			if (!part[i])
313 				continue;
314 
315 			if ((eq = strchr(part[i], '=')) == NULL ||
316 			    *(eq + 1) == '\0')
317 				return (topo_mod_seterrno(mod,
318 				    EMOD_FMRI_MALFORM));
319 
320 			*eq = '\0';
321 			if (strcmp(part[i], FM_FMRI_DEV_ID) == 0)
322 				devid = eq + 1;
323 			else if (strcmp(part[i], FM_FMRI_DEV_TGTPTLUN0) == 0)
324 				tpl0id = eq + 1;
325 			else
326 				return (topo_mod_seterrno(mod,
327 				    EMOD_FMRI_MALFORM));
328 		}
329 
330 		if (devid == NULL && tpl0id == NULL)
331 			return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
332 
333 		cur = devpath;	/* initial slash is NULled */
334 	} else if (*cur != '/') {
335 		/* the device-path should start with a slash */
336 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
337 	} else {
338 		devpath = cur;
339 	}
340 
341 	if (topo_mod_nvalloc(mod, &fmri, NV_UNIQUE_NAME) != 0)
342 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
343 
344 	err = nvlist_add_uint8(fmri, FM_VERSION, FM_DEV_SCHEME_VERSION);
345 	err |= nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);
346 
347 	if (devid != NULL)
348 		err |= nvlist_add_string(fmri, FM_FMRI_DEV_ID, devid);
349 
350 	if (tpl0id != NULL)
351 		err |= nvlist_add_string(fmri, FM_FMRI_DEV_TGTPTLUN0, tpl0id);
352 
353 	if (devid != NULL || tpl0id != NULL)
354 		*devpath = '/';	/* we NULed this earlier; put it back */
355 
356 	/* step over repeated initial / in the devpath */
357 	while (*(devpath + 1) == '/')
358 		devpath++;
359 
360 	err |= nvlist_add_string(fmri, FM_FMRI_DEV_PATH, devpath);
361 
362 	if (err != 0) {
363 		nvlist_free(fmri);
364 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
365 	}
366 
367 	*out = fmri;
368 
369 	return (0);
370 }
371 
372 /*ARGSUSED*/
373 static int
374 dev_fmri_present(topo_mod_t *mod, tnode_t *node, topo_version_t version,
375     nvlist_t *in, nvlist_t **out)
376 {
377 	uint8_t fmversion;
378 	char *devpath = NULL;
379 	uint32_t present;
380 	char *devid = NULL, *path;
381 	ddi_devid_t id;
382 	ddi_devid_t matchid;
383 	di_node_t dnode;
384 	struct stat sb;
385 	int len;
386 
387 	if (version > TOPO_METH_PRESENT_VERSION)
388 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
389 
390 	if (nvlist_lookup_uint8(in, FM_VERSION, &fmversion) != 0 ||
391 	    fmversion > FM_DEV_SCHEME_VERSION ||
392 	    nvlist_lookup_string(in, FM_FMRI_DEV_PATH, &devpath) != 0)
393 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
394 
395 	(void) nvlist_lookup_string(in, FM_FMRI_DEV_ID, &devid);
396 
397 	if (devpath == NULL || strlen(devpath) == 0)
398 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
399 
400 	/*
401 	 * stat() the device node in devfs. This will tell us if the device is
402 	 * present or not. Don't stat the minor,  just the whole device.
403 	 * If the device is present and there is a devid, it must also match.
404 	 * so di_init that one node. No need for DINFOFORCE.
405 	 */
406 	len = strlen(devpath) + strlen("/devices") + 1;
407 	path = topo_mod_alloc(mod, len);
408 	(void) snprintf(path, len, "/devices%s", devpath);
409 	if (devid == NULL) {
410 		if (stat(path, &sb) != -1)
411 			present = 1;
412 		else if ((dnode = di_init("/", DINFOCACHE)) == DI_NODE_NIL)
413 			present = 0;
414 		else {
415 			if (di_lookup_node(dnode, devpath) == DI_NODE_NIL)
416 				present = 0;
417 			else
418 				present = 1;
419 			di_fini(dnode);
420 		}
421 	} else {
422 		if (stat(path, &sb) == -1)
423 			present = 0;
424 		else if ((dnode = di_init(devpath, DINFOCPYONE)) == DI_NODE_NIL)
425 			present = 0;
426 		else {
427 			if ((id = di_devid(dnode)) == NULL ||
428 			    devid_str_decode(devid, &matchid, NULL) != 0)
429 				present = 0;
430 			else {
431 				if (devid_compare(id, matchid) != 0)
432 					present = 0;
433 				else
434 					present = 1;
435 				devid_free(matchid);
436 			}
437 			di_fini(dnode);
438 		}
439 	}
440 	topo_mod_free(mod, path, len);
441 
442 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) != 0)
443 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
444 	if (nvlist_add_uint32(*out, TOPO_METH_PRESENT_RET, present) != 0) {
445 		nvlist_free(*out);
446 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
447 	}
448 
449 	return (0);
450 }
451 
452 /*ARGSUSED*/
453 static int
454 dev_fmri_replaced(topo_mod_t *mod, tnode_t *node, topo_version_t version,
455     nvlist_t *in, nvlist_t **out)
456 {
457 	uint8_t fmversion;
458 	char *devpath = NULL;
459 	uint32_t rval;
460 	char *devid = NULL, *path;
461 	ddi_devid_t id;
462 	ddi_devid_t matchid;
463 	di_node_t dnode;
464 	struct stat sb;
465 	int len;
466 
467 	if (version > TOPO_METH_REPLACED_VERSION)
468 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
469 
470 	if (nvlist_lookup_uint8(in, FM_VERSION, &fmversion) != 0 ||
471 	    fmversion > FM_DEV_SCHEME_VERSION ||
472 	    nvlist_lookup_string(in, FM_FMRI_DEV_PATH, &devpath) != 0)
473 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
474 
475 	(void) nvlist_lookup_string(in, FM_FMRI_DEV_ID, &devid);
476 
477 	if (devpath == NULL || strlen(devpath) == 0)
478 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
479 
480 	/*
481 	 * stat() the device node in devfs. This will tell us if the device is
482 	 * present or not. Don't stat the minor,  just the whole device.
483 	 * If the device is present and there is a devid, it must also match.
484 	 * so di_init that one node. No need for DINFOFORCE.
485 	 */
486 	len = strlen(devpath) + strlen("/devices") + 1;
487 	path = topo_mod_alloc(mod, len);
488 	(void) snprintf(path, len, "/devices%s", devpath);
489 	if (devid == NULL) {
490 		if (stat(path, &sb) != -1)
491 			rval = FMD_OBJ_STATE_UNKNOWN;
492 		else if ((dnode = di_init("/", DINFOCACHE)) == DI_NODE_NIL)
493 			rval = FMD_OBJ_STATE_UNKNOWN;
494 		else {
495 			if (di_lookup_node(dnode, devpath) == DI_NODE_NIL)
496 				rval = FMD_OBJ_STATE_UNKNOWN;
497 			else
498 				rval = FMD_OBJ_STATE_UNKNOWN;
499 			di_fini(dnode);
500 		}
501 	} else {
502 		if (stat(path, &sb) == -1)
503 			rval = FMD_OBJ_STATE_UNKNOWN;
504 		else if ((dnode = di_init(devpath, DINFOCPYONE)) == DI_NODE_NIL)
505 			rval = FMD_OBJ_STATE_UNKNOWN;
506 		else {
507 			if ((id = di_devid(dnode)) == NULL ||
508 			    devid_str_decode(devid, &matchid, NULL) != 0)
509 				rval = FMD_OBJ_STATE_UNKNOWN;
510 			else {
511 				if (devid_compare(id, matchid) != 0)
512 					rval = FMD_OBJ_STATE_REPLACED;
513 				else
514 					rval = FMD_OBJ_STATE_STILL_PRESENT;
515 				devid_free(matchid);
516 			}
517 			di_fini(dnode);
518 		}
519 	}
520 	topo_mod_free(mod, path, len);
521 
522 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) != 0)
523 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
524 	if (nvlist_add_uint32(*out, TOPO_METH_REPLACED_RET, rval) != 0) {
525 		nvlist_free(*out);
526 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
527 	}
528 
529 	return (0);
530 }
531 
532 /*ARGSUSED*/
533 static int
534 dev_fmri_unusable(topo_mod_t *mod, tnode_t *node, topo_version_t version,
535     nvlist_t *in, nvlist_t **out)
536 {
537 	di_node_t dnode;
538 	uint8_t fmversion;
539 	char *devpath = NULL;
540 	uint32_t unusable;
541 	uint_t state;
542 
543 	if (version > TOPO_METH_UNUSABLE_VERSION)
544 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
545 
546 	if (nvlist_lookup_uint8(in, FM_VERSION, &fmversion) != 0 ||
547 	    fmversion > FM_DEV_SCHEME_VERSION ||
548 	    nvlist_lookup_string(in, FM_FMRI_DEV_PATH, &devpath) != 0)
549 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
550 
551 	if (devpath == NULL)
552 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
553 
554 	if ((dnode = di_init(devpath, DINFOCPYONE)) == DI_NODE_NIL) {
555 		if (errno != ENXIO)
556 			return (topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM));
557 		unusable = 1;
558 	} else {
559 		uint_t retired = di_retired(dnode);
560 		state = di_state(dnode);
561 		if (retired || (state & (DI_DEVICE_OFFLINE | DI_DEVICE_DOWN |
562 		    DI_BUS_QUIESCED | DI_BUS_DOWN)))
563 			unusable = 1;
564 		else
565 			unusable = 0;
566 		di_fini(dnode);
567 	}
568 
569 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) != 0)
570 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
571 	if (nvlist_add_uint32(*out, TOPO_METH_UNUSABLE_RET, unusable) != 0) {
572 		nvlist_free(*out);
573 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
574 	}
575 
576 	return (0);
577 }
578 
579 /*ARGSUSED*/
580 static int
581 dev_fmri_service_state(topo_mod_t *mod, tnode_t *node, topo_version_t version,
582     nvlist_t *in, nvlist_t **out)
583 {
584 	di_node_t dnode;
585 	uint8_t fmversion;
586 	char *devpath = NULL;
587 	uint32_t service_state;
588 	uint_t state;
589 
590 	if (version > TOPO_METH_SERVICE_STATE_VERSION)
591 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
592 
593 	if (nvlist_lookup_uint8(in, FM_VERSION, &fmversion) != 0 ||
594 	    fmversion > FM_DEV_SCHEME_VERSION ||
595 	    nvlist_lookup_string(in, FM_FMRI_DEV_PATH, &devpath) != 0)
596 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
597 
598 	if (devpath == NULL)
599 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
600 
601 	if ((dnode = di_init(devpath, DINFOCPYONE)) == DI_NODE_NIL) {
602 		if (errno != ENXIO)
603 			return (topo_mod_seterrno(mod, EMOD_UKNOWN_ENUM));
604 		service_state = FMD_SERVICE_STATE_UNUSABLE;
605 	} else {
606 		uint_t retired = di_retired(dnode);
607 		state = di_state(dnode);
608 		if (retired || (state & (DI_DEVICE_OFFLINE | DI_DEVICE_DOWN |
609 		    DI_BUS_QUIESCED | DI_BUS_DOWN)))
610 			service_state = FMD_SERVICE_STATE_UNUSABLE;
611 		else if (state & DI_DEVICE_DEGRADED)
612 			service_state = FMD_SERVICE_STATE_DEGRADED;
613 		else
614 			service_state = FMD_SERVICE_STATE_OK;
615 		di_fini(dnode);
616 	}
617 
618 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) != 0)
619 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
620 	if (nvlist_add_uint32(*out, TOPO_METH_SERVICE_STATE_RET,
621 	    service_state) != 0) {
622 		nvlist_free(*out);
623 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
624 	}
625 
626 	return (0);
627 }
628 
629 static nvlist_t *
630 dev_fmri_create(topo_mod_t *mp, const char *id, const char *path)
631 {
632 	nvlist_t *out = NULL;
633 	int e;
634 
635 	if (topo_mod_nvalloc(mp, &out, NV_UNIQUE_NAME) != 0) {
636 		(void) topo_mod_seterrno(mp, EMOD_FMRI_NVL);
637 		return (NULL);
638 	}
639 	e = nvlist_add_string(out, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);
640 	e |= nvlist_add_uint8(out, FM_VERSION, FM_DEV_SCHEME_VERSION);
641 	e |= nvlist_add_string(out, FM_FMRI_DEV_PATH, path);
642 
643 	if (id != NULL)
644 		e |= nvlist_add_string(out, FM_FMRI_DEV_ID, id);
645 
646 	if (e == 0)
647 		return (out);
648 
649 	topo_mod_dprintf(mp, "construction of dev nvl failed");
650 	(void) topo_mod_seterrno(mp, EMOD_FMRI_NVL);
651 	nvlist_free(out);
652 	return (NULL);
653 }
654 
655 /*ARGSUSED*/
656 static int
657 dev_fmri_create_meth(topo_mod_t *mp, tnode_t *node, topo_version_t version,
658     nvlist_t *in, nvlist_t **out)
659 {
660 	nvlist_t *args = NULL;
661 	char *path, *id = NULL;
662 
663 	if (version > TOPO_METH_FMRI_VERSION)
664 		return (topo_mod_seterrno(mp, EMOD_VER_NEW));
665 
666 	if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NVL, &args) != 0 ||
667 	    nvlist_lookup_string(args, FM_FMRI_DEV_PATH, &path) != 0) {
668 		topo_mod_dprintf(mp, "no path string in method argument\n");
669 		return (topo_mod_seterrno(mp, EMOD_METHOD_INVAL));
670 	}
671 
672 	(void) nvlist_lookup_string(args, FM_FMRI_DEV_ID, &id);
673 
674 	if ((*out = dev_fmri_create(mp, id, path)) == NULL)
675 		return (-1);
676 	return (0);
677 }
678