xref: /titanic_41/usr/src/lib/fm/topo/libtopo/common/hc.c (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)
1 /*
2  *
3  * CDDL HEADER START
4  *
5  * The contents of this file are subject to the terms of the
6  * Common Development and Distribution License (the "License").
7  * You may not use this file except in compliance with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <ctype.h>
32 #include <alloca.h>
33 #include <assert.h>
34 #include <limits.h>
35 #include <zone.h>
36 #include <fm/topo_mod.h>
37 #include <fm/topo_hc.h>
38 #include <fm/fmd_fmri.h>
39 #include <sys/param.h>
40 #include <sys/systeminfo.h>
41 #include <sys/fm/protocol.h>
42 #include <sys/stat.h>
43 #include <sys/systeminfo.h>
44 #include <sys/utsname.h>
45 
46 #include <topo_method.h>
47 #include <topo_module.h>
48 #include <topo_subr.h>
49 #include <topo_prop.h>
50 #include <topo_tree.h>
51 #include <hc.h>
52 
53 static int hc_enum(topo_mod_t *, tnode_t *, const char *, topo_instance_t,
54     topo_instance_t, void *, void *);
55 static void hc_release(topo_mod_t *, tnode_t *);
56 static int hc_fmri_nvl2str(topo_mod_t *, tnode_t *, topo_version_t,
57     nvlist_t *, nvlist_t **);
58 static int hc_fmri_str2nvl(topo_mod_t *, tnode_t *, topo_version_t,
59     nvlist_t *, nvlist_t **);
60 static int hc_compare(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
61     nvlist_t **);
62 static int hc_fmri_present(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
63     nvlist_t **);
64 static int hc_fmri_replaced(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
65     nvlist_t **);
66 static int hc_fmri_unusable(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
67     nvlist_t **);
68 static int hc_fmri_expand(topo_mod_t *, tnode_t *, topo_version_t,
69     nvlist_t *, nvlist_t **);
70 static int hc_fmri_retire(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
71     nvlist_t **);
72 static int hc_fmri_unretire(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
73     nvlist_t **);
74 static int hc_fmri_service_state(topo_mod_t *, tnode_t *, topo_version_t,
75     nvlist_t *, nvlist_t **);
76 static int hc_fmri_create_meth(topo_mod_t *, tnode_t *, topo_version_t,
77     nvlist_t *, nvlist_t **);
78 static int hc_fmri_prop_get(topo_mod_t *, tnode_t *, topo_version_t,
79     nvlist_t *, nvlist_t **);
80 static int hc_fmri_prop_set(topo_mod_t *, tnode_t *, topo_version_t,
81     nvlist_t *, nvlist_t **);
82 static int hc_fmri_pgrp_get(topo_mod_t *, tnode_t *, topo_version_t,
83     nvlist_t *, nvlist_t **);
84 static int hc_fmri_facility(topo_mod_t *, tnode_t *, topo_version_t,
85     nvlist_t *, nvlist_t **);
86 
87 static nvlist_t *hc_fmri_create(topo_mod_t *, nvlist_t *, int, const char *,
88     topo_instance_t inst, const nvlist_t *, const char *, const char *,
89     const char *);
90 
91 const topo_method_t hc_methods[] = {
92 	{ TOPO_METH_NVL2STR, TOPO_METH_NVL2STR_DESC, TOPO_METH_NVL2STR_VERSION,
93 	    TOPO_STABILITY_INTERNAL, hc_fmri_nvl2str },
94 	{ TOPO_METH_STR2NVL, TOPO_METH_STR2NVL_DESC, TOPO_METH_STR2NVL_VERSION,
95 	    TOPO_STABILITY_INTERNAL, hc_fmri_str2nvl },
96 	{ TOPO_METH_COMPARE, TOPO_METH_COMPARE_DESC, TOPO_METH_COMPARE_VERSION,
97 	    TOPO_STABILITY_INTERNAL, hc_compare },
98 	{ TOPO_METH_PRESENT, TOPO_METH_PRESENT_DESC, TOPO_METH_PRESENT_VERSION,
99 	    TOPO_STABILITY_INTERNAL, hc_fmri_present },
100 	{ TOPO_METH_REPLACED, TOPO_METH_REPLACED_DESC,
101 	    TOPO_METH_REPLACED_VERSION, TOPO_STABILITY_INTERNAL,
102 	    hc_fmri_replaced },
103 	{ TOPO_METH_UNUSABLE, TOPO_METH_UNUSABLE_DESC,
104 	    TOPO_METH_UNUSABLE_VERSION, TOPO_STABILITY_INTERNAL,
105 	    hc_fmri_unusable },
106 	{ TOPO_METH_EXPAND, TOPO_METH_EXPAND_DESC,
107 	    TOPO_METH_EXPAND_VERSION, TOPO_STABILITY_INTERNAL,
108 	    hc_fmri_expand },
109 	{ TOPO_METH_RETIRE, TOPO_METH_RETIRE_DESC,
110 	    TOPO_METH_RETIRE_VERSION, TOPO_STABILITY_INTERNAL,
111 	    hc_fmri_retire },
112 	{ TOPO_METH_UNRETIRE, TOPO_METH_UNRETIRE_DESC,
113 	    TOPO_METH_UNRETIRE_VERSION, TOPO_STABILITY_INTERNAL,
114 	    hc_fmri_unretire },
115 	{ TOPO_METH_SERVICE_STATE, TOPO_METH_SERVICE_STATE_DESC,
116 	    TOPO_METH_SERVICE_STATE_VERSION, TOPO_STABILITY_INTERNAL,
117 	    hc_fmri_service_state },
118 	{ TOPO_METH_FMRI, TOPO_METH_FMRI_DESC, TOPO_METH_FMRI_VERSION,
119 	    TOPO_STABILITY_INTERNAL, hc_fmri_create_meth },
120 	{ TOPO_METH_PROP_GET, TOPO_METH_PROP_GET_DESC,
121 	    TOPO_METH_PROP_GET_VERSION, TOPO_STABILITY_INTERNAL,
122 	    hc_fmri_prop_get },
123 	{ TOPO_METH_PROP_SET, TOPO_METH_PROP_SET_DESC,
124 	    TOPO_METH_PROP_SET_VERSION, TOPO_STABILITY_INTERNAL,
125 	    hc_fmri_prop_set },
126 	{ TOPO_METH_PGRP_GET, TOPO_METH_PGRP_GET_DESC,
127 	    TOPO_METH_PGRP_GET_VERSION, TOPO_STABILITY_INTERNAL,
128 	    hc_fmri_pgrp_get },
129 	{ TOPO_METH_FACILITY, TOPO_METH_FACILITY_DESC,
130 	    TOPO_METH_FACILITY_VERSION, TOPO_STABILITY_INTERNAL,
131 	    hc_fmri_facility },
132 	{ NULL }
133 };
134 
135 static const topo_modops_t hc_ops =
136 	{ hc_enum, hc_release };
137 static const topo_modinfo_t hc_info =
138 	{ HC, FM_FMRI_SCHEME_HC, HC_VERSION, &hc_ops };
139 
140 static const hcc_t hc_canon[] = {
141 	{ BANK, TOPO_STABILITY_PRIVATE },
142 	{ BAY, TOPO_STABILITY_PRIVATE },
143 	{ BLADE, TOPO_STABILITY_PRIVATE },
144 	{ BRANCH, TOPO_STABILITY_PRIVATE },
145 	{ CMP, TOPO_STABILITY_PRIVATE },
146 	{ CENTERPLANE, TOPO_STABILITY_PRIVATE },
147 	{ CHASSIS, TOPO_STABILITY_PRIVATE },
148 	{ CHIP, TOPO_STABILITY_PRIVATE },
149 	{ CHIP_SELECT, TOPO_STABILITY_PRIVATE },
150 	{ CORE, TOPO_STABILITY_PRIVATE },
151 	{ CONTROLLER, TOPO_STABILITY_PRIVATE },
152 	{ CPU, TOPO_STABILITY_PRIVATE },
153 	{ CPUBOARD, TOPO_STABILITY_PRIVATE },
154 	{ DIMM, TOPO_STABILITY_PRIVATE },
155 	{ DISK, TOPO_STABILITY_PRIVATE },
156 	{ DRAM, TOPO_STABILITY_PRIVATE },
157 	{ DRAMCHANNEL, TOPO_STABILITY_PRIVATE },
158 	{ FAN, TOPO_STABILITY_PRIVATE },
159 	{ FANBOARD, TOPO_STABILITY_PRIVATE },
160 	{ FANMODULE, TOPO_STABILITY_PRIVATE },
161 	{ HBA, TOPO_STABILITY_PRIVATE },
162 	{ HOSTBRIDGE, TOPO_STABILITY_PRIVATE },
163 	{ INTERCONNECT, TOPO_STABILITY_PRIVATE },
164 	{ IOBOARD, TOPO_STABILITY_PRIVATE },
165 	{ IPORT, TOPO_STABILITY_PRIVATE },
166 	{ MEMBOARD, TOPO_STABILITY_PRIVATE },
167 	{ MEMORYBUFFER, TOPO_STABILITY_PRIVATE },
168 	{ MEMORYCONTROL, TOPO_STABILITY_PRIVATE },
169 	{ MICROCORE, TOPO_STABILITY_PRIVATE },
170 	{ MOTHERBOARD, TOPO_STABILITY_PRIVATE },
171 	{ NIU, TOPO_STABILITY_PRIVATE },
172 	{ NIUFN, TOPO_STABILITY_PRIVATE },
173 	{ PCI_BUS, TOPO_STABILITY_PRIVATE },
174 	{ PCI_DEVICE, TOPO_STABILITY_PRIVATE },
175 	{ PCI_FUNCTION, TOPO_STABILITY_PRIVATE },
176 	{ PCIEX_BUS, TOPO_STABILITY_PRIVATE },
177 	{ PCIEX_DEVICE, TOPO_STABILITY_PRIVATE },
178 	{ PCIEX_FUNCTION, TOPO_STABILITY_PRIVATE },
179 	{ PCIEX_ROOT, TOPO_STABILITY_PRIVATE },
180 	{ PCIEX_SWUP, TOPO_STABILITY_PRIVATE },
181 	{ PCIEX_SWDWN, TOPO_STABILITY_PRIVATE },
182 	{ POWERBOARD, TOPO_STABILITY_PRIVATE },
183 	{ POWERMODULE, TOPO_STABILITY_PRIVATE },
184 	{ PSU, TOPO_STABILITY_PRIVATE },
185 	{ RANK, TOPO_STABILITY_PRIVATE },
186 	{ RECEPTACLE, TOPO_STABILITY_PRIVATE },
187 	{ RISER, TOPO_STABILITY_PRIVATE },
188 	{ SASEXPANDER, TOPO_STABILITY_PRIVATE },
189 	{ SCSI_DEVICE, TOPO_STABILITY_PRIVATE },
190 	{ SHELF, TOPO_STABILITY_PRIVATE },
191 	{ SES_ENCLOSURE, TOPO_STABILITY_PRIVATE },
192 	{ SMP_DEVICE, TOPO_STABILITY_PRIVATE },
193 	{ SP, TOPO_STABILITY_PRIVATE },
194 	{ STRAND, TOPO_STABILITY_PRIVATE },
195 	{ SUBCHASSIS, TOPO_STABILITY_PRIVATE },
196 	{ SYSTEMBOARD, TOPO_STABILITY_PRIVATE },
197 	{ XAUI, TOPO_STABILITY_PRIVATE },
198 	{ XFP, TOPO_STABILITY_PRIVATE }
199 };
200 
201 static int hc_ncanon = sizeof (hc_canon) / sizeof (hcc_t);
202 
203 int
hc_init(topo_mod_t * mod,topo_version_t version)204 hc_init(topo_mod_t *mod, topo_version_t version)
205 {
206 	/*
207 	 * Turn on module debugging output
208 	 */
209 	if (getenv("TOPOHCDEBUG"))
210 		topo_mod_setdebug(mod);
211 
212 	topo_mod_dprintf(mod, "initializing hc builtin\n");
213 
214 	if (version != HC_VERSION)
215 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
216 
217 	if (topo_mod_register(mod, &hc_info, TOPO_VERSION) != 0) {
218 		topo_mod_dprintf(mod, "failed to register hc: "
219 		    "%s\n", topo_mod_errmsg(mod));
220 		return (-1); /* mod errno already set */
221 	}
222 
223 	return (0);
224 }
225 
226 void
hc_fini(topo_mod_t * mod)227 hc_fini(topo_mod_t *mod)
228 {
229 	topo_mod_unregister(mod);
230 }
231 
232 
233 static const topo_pgroup_info_t sys_pgroup = {
234 	TOPO_PGROUP_SYSTEM,
235 	TOPO_STABILITY_PRIVATE,
236 	TOPO_STABILITY_PRIVATE,
237 	1
238 };
239 
240 static const topo_pgroup_info_t auth_pgroup = {
241 	FM_FMRI_AUTHORITY,
242 	TOPO_STABILITY_PRIVATE,
243 	TOPO_STABILITY_PRIVATE,
244 	1
245 };
246 
247 static void
hc_prop_set(tnode_t * node,nvlist_t * auth)248 hc_prop_set(tnode_t *node, nvlist_t *auth)
249 {
250 	int err;
251 	char isa[MAXNAMELEN];
252 	struct utsname uts;
253 	char *prod, *psn, *csn, *server;
254 
255 	if (auth == NULL)
256 		return;
257 
258 	if (topo_pgroup_create(node, &auth_pgroup, &err) != 0) {
259 		if (err != ETOPO_PROP_DEFD)
260 			return;
261 	}
262 
263 	/*
264 	 * Inherit if we can, it saves memory
265 	 */
266 	if ((topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT,
267 	    &err) != 0) && (err != ETOPO_PROP_DEFD)) {
268 		if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, &prod)
269 		    == 0)
270 			(void) topo_prop_set_string(node, FM_FMRI_AUTHORITY,
271 			    FM_FMRI_AUTH_PRODUCT, TOPO_PROP_IMMUTABLE, prod,
272 			    &err);
273 	}
274 	if ((topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_PRODUCT_SN,
275 	    &err) != 0) && (err != ETOPO_PROP_DEFD)) {
276 		if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT_SN, &psn)
277 		    == 0)
278 			(void) topo_prop_set_string(node, FM_FMRI_AUTHORITY,
279 			    FM_FMRI_AUTH_PRODUCT_SN, TOPO_PROP_IMMUTABLE, psn,
280 			    &err);
281 	}
282 	if ((topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_CHASSIS,
283 	    &err) != 0) && (err != ETOPO_PROP_DEFD)) {
284 		if (nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, &csn) == 0)
285 			(void) topo_prop_set_string(node, FM_FMRI_AUTHORITY,
286 			    FM_FMRI_AUTH_CHASSIS, TOPO_PROP_IMMUTABLE, csn,
287 			    &err);
288 	}
289 	if ((topo_prop_inherit(node, FM_FMRI_AUTHORITY, FM_FMRI_AUTH_SERVER,
290 	    &err) != 0) && (err != ETOPO_PROP_DEFD)) {
291 		if (nvlist_lookup_string(auth, FM_FMRI_AUTH_SERVER, &server)
292 		    == 0)
293 			(void) topo_prop_set_string(node, FM_FMRI_AUTHORITY,
294 			    FM_FMRI_AUTH_SERVER, TOPO_PROP_IMMUTABLE, server,
295 			    &err);
296 	}
297 
298 	if (topo_pgroup_create(node, &sys_pgroup, &err) != 0)
299 		return;
300 
301 	isa[0] = '\0';
302 	(void) sysinfo(SI_ARCHITECTURE, isa, sizeof (isa));
303 	(void) uname(&uts);
304 	(void) topo_prop_set_string(node, TOPO_PGROUP_SYSTEM, TOPO_PROP_ISA,
305 	    TOPO_PROP_IMMUTABLE, isa, &err);
306 	(void) topo_prop_set_string(node, TOPO_PGROUP_SYSTEM, TOPO_PROP_MACHINE,
307 	    TOPO_PROP_IMMUTABLE, uts.machine, &err);
308 }
309 
310 /*ARGSUSED*/
311 int
hc_enum(topo_mod_t * mod,tnode_t * pnode,const char * name,topo_instance_t min,topo_instance_t max,void * notused1,void * notused2)312 hc_enum(topo_mod_t *mod, tnode_t *pnode, const char *name, topo_instance_t min,
313     topo_instance_t max, void *notused1, void *notused2)
314 {
315 	int isglobal = (getzoneid() == GLOBAL_ZONEID);
316 	nvlist_t *pfmri = NULL;
317 	nvlist_t *nvl;
318 	nvlist_t *auth;
319 	tnode_t *node;
320 	int err;
321 	/*
322 	 * Register root node methods
323 	 */
324 	if (strcmp(name, HC) == 0) {
325 		(void) topo_method_register(mod, pnode, hc_methods);
326 		return (0);
327 	}
328 	if (min != max) {
329 		topo_mod_dprintf(mod,
330 		    "Request to enumerate %s component with an "
331 		    "ambiguous instance number, min (%d) != max (%d).\n",
332 		    HC, min, max);
333 		return (topo_mod_seterrno(mod, EINVAL));
334 	}
335 
336 	if (!isglobal)
337 		return (0);
338 
339 	(void) topo_node_resource(pnode, &pfmri, &err);
340 	auth = topo_mod_auth(mod, pnode);
341 	nvl = hc_fmri_create(mod, pfmri, FM_HC_SCHEME_VERSION, name, min,
342 	    auth, NULL, NULL, NULL);
343 	nvlist_free(pfmri);	/* callee ignores NULLs */
344 	if (nvl == NULL) {
345 		nvlist_free(auth);
346 		return (-1);
347 	}
348 
349 	if ((node = topo_node_bind(mod, pnode, name, min, nvl)) == NULL) {
350 		topo_mod_dprintf(mod, "topo_node_bind failed: %s\n",
351 		    topo_strerror(topo_mod_errno(mod)));
352 		nvlist_free(auth);
353 		nvlist_free(nvl);
354 		return (-1);
355 	}
356 
357 	/*
358 	 * Set FRU for the motherboard node
359 	 */
360 	if (strcmp(name, MOTHERBOARD) == 0)
361 		(void) topo_node_fru_set(node, nvl, 0, &err);
362 
363 	hc_prop_set(node, auth);
364 	nvlist_free(nvl);
365 	nvlist_free(auth);
366 
367 	return (0);
368 }
369 
370 /*ARGSUSED*/
371 static void
hc_release(topo_mod_t * mp,tnode_t * node)372 hc_release(topo_mod_t *mp, tnode_t *node)
373 {
374 	topo_method_unregister_all(mp, node);
375 }
376 
377 static int
fmri_compare(topo_mod_t * mod,nvlist_t * nv1,nvlist_t * nv2)378 fmri_compare(topo_mod_t *mod, nvlist_t *nv1, nvlist_t *nv2)
379 {
380 	uint8_t v1, v2;
381 	nvlist_t **hcp1, **hcp2;
382 	nvlist_t *f1 = NULL, *f2 = NULL;
383 	int err, i;
384 	uint_t nhcp1, nhcp2;
385 	char *f1str, *f2str;
386 
387 	if (nvlist_lookup_uint8(nv1, FM_VERSION, &v1) != 0 ||
388 	    nvlist_lookup_uint8(nv2, FM_VERSION, &v2) != 0 ||
389 	    v1 > FM_HC_SCHEME_VERSION || v2 > FM_HC_SCHEME_VERSION)
390 		return (topo_mod_seterrno(mod, EMOD_FMRI_VERSION));
391 
392 	err = nvlist_lookup_nvlist_array(nv1, FM_FMRI_HC_LIST, &hcp1, &nhcp1);
393 	err |= nvlist_lookup_nvlist_array(nv2, FM_FMRI_HC_LIST, &hcp2, &nhcp2);
394 	if (err != 0)
395 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
396 
397 	if (nhcp1 != nhcp2)
398 		return (0);
399 
400 	for (i = 0; i < nhcp1; i++) {
401 		char *nm1 = NULL;
402 		char *nm2 = NULL;
403 		char *id1 = NULL;
404 		char *id2 = NULL;
405 
406 		(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_NAME, &nm1);
407 		(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_NAME, &nm2);
408 		(void) nvlist_lookup_string(hcp1[i], FM_FMRI_HC_ID, &id1);
409 		(void) nvlist_lookup_string(hcp2[i], FM_FMRI_HC_ID, &id2);
410 		if (nm1 == NULL || nm2 == NULL || id1 == NULL || id2 == NULL)
411 			return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
412 
413 		if (strcmp(nm1, nm2) == 0 && strcmp(id1, id2) == 0)
414 			continue;
415 
416 		return (0);
417 	}
418 
419 	/*
420 	 * Finally, check if the FMRI's represent a facility node.  If so, then
421 	 * verify that the facilty type ("sensor"|"indicator") and facility
422 	 * name match.
423 	 */
424 	(void) nvlist_lookup_nvlist(nv1, FM_FMRI_FACILITY, &f1);
425 	(void) nvlist_lookup_nvlist(nv2, FM_FMRI_FACILITY, &f2);
426 
427 	if (f1 == NULL && f2 == NULL)
428 		return (1);
429 	else if (f1 == NULL || f2 == NULL)
430 		return (0);
431 
432 	if (nvlist_lookup_string(f1, FM_FMRI_FACILITY_NAME, &f1str) == 0 &&
433 	    nvlist_lookup_string(f2, FM_FMRI_FACILITY_NAME, &f2str) == 0 &&
434 	    strcmp(f1str, f2str) == 0 &&
435 	    nvlist_lookup_string(f1, FM_FMRI_FACILITY_TYPE, &f1str) == 0 &&
436 	    nvlist_lookup_string(f2, FM_FMRI_FACILITY_TYPE, &f2str) == 0 &&
437 	    strcmp(f1str, f2str) == 0) {
438 		return (1);
439 	}
440 	return (0);
441 }
442 
443 /*ARGSUSED*/
444 static int
hc_compare(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)445 hc_compare(topo_mod_t *mod, tnode_t *node, topo_version_t version,
446     nvlist_t *in, nvlist_t **out)
447 {
448 	int ret;
449 	uint32_t compare;
450 	nvlist_t *nv1, *nv2;
451 
452 	if (version > TOPO_METH_COMPARE_VERSION)
453 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
454 
455 	if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NV1, &nv1) != 0 ||
456 	    nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NV2, &nv2) != 0)
457 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
458 
459 	ret = fmri_compare(mod, nv1, nv2);
460 	if (ret < 0)
461 		return (-1);
462 
463 	compare = ret;
464 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) == 0) {
465 		if (nvlist_add_uint32(*out, TOPO_METH_COMPARE_RET,
466 		    compare) == 0)
467 			return (0);
468 		else
469 			nvlist_free(*out);
470 	}
471 
472 	return (-1);
473 }
474 
475 static ssize_t
fmri_nvl2str(nvlist_t * nvl,char * buf,size_t buflen)476 fmri_nvl2str(nvlist_t *nvl, char *buf, size_t buflen)
477 {
478 	nvlist_t **hcprs = NULL;
479 	nvlist_t *hcsp = NULL;
480 	nvlist_t *anvl = NULL;
481 	nvpair_t *apair;
482 	nvlist_t *fnvl;
483 	uint8_t version;
484 	ssize_t size = 0;
485 	uint_t hcnprs;
486 	char *serial = NULL;
487 	char *part = NULL;
488 	char *root = NULL;
489 	char *rev = NULL;
490 	char *aname, *aval;
491 	char *fname = NULL, *ftype = NULL;
492 	int err, i;
493 
494 	if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 ||
495 	    version > FM_HC_SCHEME_VERSION)
496 		return (0);
497 
498 	/* Get authority, if present */
499 	err = nvlist_lookup_nvlist(nvl, FM_FMRI_AUTHORITY, &anvl);
500 	if (err != 0 && err != ENOENT)
501 		return (0);
502 
503 	(void) nvlist_lookup_string(nvl, FM_FMRI_HC_ROOT, &root);
504 
505 	err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcprs, &hcnprs);
506 	if (err != 0 || hcprs == NULL)
507 		return (0);
508 
509 	(void) nvlist_lookup_string(nvl, FM_FMRI_HC_SERIAL_ID, &serial);
510 	(void) nvlist_lookup_string(nvl, FM_FMRI_HC_PART, &part);
511 	(void) nvlist_lookup_string(nvl, FM_FMRI_HC_REVISION, &rev);
512 
513 	/* hc:// */
514 	topo_fmristr_build(&size, buf, buflen, FM_FMRI_SCHEME_HC, NULL, "://");
515 
516 	/* authority, if any */
517 	if (anvl != NULL) {
518 		for (apair = nvlist_next_nvpair(anvl, NULL);
519 		    apair != NULL; apair = nvlist_next_nvpair(anvl, apair)) {
520 			if (nvpair_type(apair) != DATA_TYPE_STRING ||
521 			    nvpair_value_string(apair, &aval) != 0)
522 				continue;
523 			aname = nvpair_name(apair);
524 			topo_fmristr_build(&size, buf, buflen, ":", NULL, NULL);
525 			topo_fmristr_build(&size, buf, buflen, "=",
526 			    aname, aval);
527 		}
528 	}
529 
530 	/* hardware-id part */
531 	topo_fmristr_build(&size,
532 	    buf, buflen, serial, ":" FM_FMRI_HC_SERIAL_ID "=", NULL);
533 	topo_fmristr_build(&size,
534 	    buf, buflen, part, ":" FM_FMRI_HC_PART "=", NULL);
535 	topo_fmristr_build(&size,
536 	    buf, buflen, rev, ":" FM_FMRI_HC_REVISION "=", NULL);
537 
538 	/* separating slash */
539 	topo_fmristr_build(&size, buf, buflen, "/", NULL, NULL);
540 
541 	/* hc-root */
542 	if (root)
543 		topo_fmristr_build(&size, buf, buflen, root, NULL, NULL);
544 
545 	/* all the pairs */
546 	for (i = 0; i < hcnprs; i++) {
547 		char *nm = NULL;
548 		char *id = NULL;
549 
550 		if (i > 0)
551 			topo_fmristr_build(&size,
552 			    buf, buflen, "/", NULL, NULL);
553 		(void) nvlist_lookup_string(hcprs[i], FM_FMRI_HC_NAME, &nm);
554 		(void) nvlist_lookup_string(hcprs[i], FM_FMRI_HC_ID, &id);
555 		if (nm == NULL || id == NULL)
556 			return (0);
557 		topo_fmristr_build(&size, buf, buflen, nm, NULL, "=");
558 		topo_fmristr_build(&size, buf, buflen, id, NULL, NULL);
559 	}
560 
561 	/* append offset/physaddr if it exists in hc-specific */
562 	if (nvlist_lookup_nvlist(nvl, FM_FMRI_HC_SPECIFIC, &hcsp) == 0) {
563 		char *hcsn = NULL;
564 		char hexstr[17];
565 		uint64_t val;
566 
567 		if (nvlist_lookup_uint64(hcsp, FM_FMRI_HC_SPECIFIC_OFFSET,
568 		    &val) == 0 || nvlist_lookup_uint64(hcsp,
569 		    "asru-" FM_FMRI_HC_SPECIFIC_OFFSET, &val) == 0)
570 			hcsn = FM_FMRI_HC_SPECIFIC_OFFSET;
571 		else if (nvlist_lookup_uint64(hcsp,
572 		    FM_FMRI_HC_SPECIFIC_PHYSADDR, &val) == 0 ||
573 		    nvlist_lookup_uint64(hcsp,
574 		    "asru-" FM_FMRI_HC_SPECIFIC_PHYSADDR, &val) == 0)
575 			hcsn = FM_FMRI_HC_SPECIFIC_PHYSADDR;
576 
577 		if (hcsn != NULL) {
578 			(void) snprintf(hexstr, sizeof (hexstr), "%llx", val);
579 			topo_fmristr_build(&size, buf, buflen, "/", NULL, NULL);
580 			topo_fmristr_build(&size, buf, buflen, "=", hcsn,
581 			    hexstr);
582 		}
583 	}
584 
585 	/*
586 	 * If the nvlist represents a facility node, then we append the
587 	 * facility type and name to the end of the string representation using
588 	 * the format below:
589 	 *
590 	 * ?<ftype>=<fname>
591 	 */
592 	if (nvlist_lookup_nvlist(nvl, FM_FMRI_FACILITY, &fnvl) == 0) {
593 		if (nvlist_lookup_string(fnvl, FM_FMRI_FACILITY_NAME,
594 		    &fname) != 0 || nvlist_lookup_string(fnvl,
595 		    FM_FMRI_FACILITY_TYPE, &ftype) != 0)
596 			return (0);
597 		topo_fmristr_build(&size, buf, buflen, "?", NULL, NULL);
598 		topo_fmristr_build(&size, buf, buflen, "=", ftype, fname);
599 	}
600 
601 	return (size);
602 }
603 
604 /*ARGSUSED*/
605 static int
hc_fmri_nvl2str(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * nvl,nvlist_t ** out)606 hc_fmri_nvl2str(topo_mod_t *mod, tnode_t *node, topo_version_t version,
607     nvlist_t *nvl, nvlist_t **out)
608 {
609 	ssize_t len;
610 	char *name = NULL;
611 	nvlist_t *fmristr;
612 
613 	if (version > TOPO_METH_NVL2STR_VERSION)
614 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
615 
616 	if ((len = fmri_nvl2str(nvl, NULL, 0)) == 0 ||
617 	    (name = topo_mod_alloc(mod, len + 1)) == NULL ||
618 	    fmri_nvl2str(nvl, name, len + 1) == 0) {
619 		if (name != NULL)
620 			topo_mod_free(mod, name, len + 1);
621 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
622 	}
623 
624 	if (topo_mod_nvalloc(mod, &fmristr, NV_UNIQUE_NAME) != 0) {
625 		topo_mod_free(mod, name, len + 1);
626 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
627 	}
628 	if (nvlist_add_string(fmristr, "fmri-string", name) != 0) {
629 		topo_mod_free(mod, name, len + 1);
630 		nvlist_free(fmristr);
631 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
632 	}
633 	topo_mod_free(mod, name, len + 1);
634 	*out = fmristr;
635 
636 	return (0);
637 }
638 
639 static nvlist_t *
hc_base_fmri_create(topo_mod_t * mod,const nvlist_t * auth,const char * part,const char * rev,const char * serial)640 hc_base_fmri_create(topo_mod_t *mod, const nvlist_t *auth, const char *part,
641     const char *rev, const char *serial)
642 {
643 	nvlist_t *fmri;
644 	int err = 0;
645 
646 	/*
647 	 * Create base HC nvlist
648 	 */
649 	if (topo_mod_nvalloc(mod, &fmri, NV_UNIQUE_NAME) != 0)
650 		return (NULL);
651 
652 	err = nvlist_add_uint8(fmri, FM_VERSION, FM_HC_SCHEME_VERSION);
653 	err |= nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC);
654 	err |= nvlist_add_string(fmri, FM_FMRI_HC_ROOT, "");
655 	if (err != 0) {
656 		nvlist_free(fmri);
657 		return (NULL);
658 	}
659 
660 	/*
661 	 * Add optional payload members
662 	 */
663 	if (serial != NULL)
664 		(void) nvlist_add_string(fmri, FM_FMRI_HC_SERIAL_ID, serial);
665 	if (part != NULL)
666 		(void) nvlist_add_string(fmri, FM_FMRI_HC_PART, part);
667 	if (rev != NULL)
668 		(void) nvlist_add_string(fmri, FM_FMRI_HC_REVISION, rev);
669 	if (auth != NULL)
670 		(void) nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
671 		    (nvlist_t *)auth);
672 
673 	return (fmri);
674 }
675 
676 static nvlist_t **
make_hc_pairs(topo_mod_t * mod,char * fmri,int * num)677 make_hc_pairs(topo_mod_t *mod, char *fmri, int *num)
678 {
679 	nvlist_t **pa;
680 	char *hc, *fromstr;
681 	char *starti, *startn, *endi, *endi2;
682 	char *ne, *ns;
683 	char *cname = NULL;
684 	char *find;
685 	char *cid = NULL;
686 	int nslashes = 0;
687 	int npairs = 0;
688 	int i, hclen;
689 
690 	if ((hc = topo_mod_strdup(mod, fmri + 5)) == NULL)
691 		return (NULL);
692 
693 	hclen = strlen(hc) + 1;
694 
695 	/*
696 	 * Count equal signs and slashes to determine how many
697 	 * hc-pairs will be present in the final FMRI.  There should
698 	 * be at least as many slashes as equal signs.  There can be
699 	 * more, though if the string after an = includes them.
700 	 */
701 	if ((fromstr = strchr(hc, '/')) == NULL)
702 		return (NULL);
703 
704 	find = fromstr;
705 	while ((ne = strchr(find, '=')) != NULL) {
706 		find = ne + 1;
707 		npairs++;
708 	}
709 
710 	find = fromstr;
711 	while ((ns = strchr(find, '/')) != NULL) {
712 		find = ns + 1;
713 		nslashes++;
714 	}
715 
716 	/*
717 	 * Do we appear to have a well-formed string version of the FMRI?
718 	 */
719 	if (nslashes < npairs || npairs == 0) {
720 		topo_mod_free(mod, hc, hclen);
721 		return (NULL);
722 	}
723 
724 	*num = npairs;
725 
726 	find = fromstr;
727 
728 	if ((pa = topo_mod_zalloc(mod, npairs * sizeof (nvlist_t *))) == NULL) {
729 		topo_mod_free(mod, hc, hclen);
730 		return (NULL);
731 	}
732 
733 	/*
734 	 * We go through a pretty complicated procedure to find the
735 	 * name and id for each pair.  That's because, unfortunately,
736 	 * we have some ids that can have slashes within them.  So
737 	 * we can't just search for the next slash after the equal sign
738 	 * and decide that starts a new pair.  Instead we have to find
739 	 * an equal sign for the next pair and work our way back to the
740 	 * slash from there.
741 	 */
742 	for (i = 0; i < npairs; i++) {
743 		startn = strchr(find, '/');
744 		if (startn == NULL)
745 			break;
746 		startn++;
747 		starti = strchr(find, '=');
748 		if (starti == NULL)
749 			break;
750 		*starti = '\0';
751 		if ((cname = topo_mod_strdup(mod, startn)) == NULL)
752 			break;
753 		*starti++ = '=';
754 		endi = strchr(starti, '=');
755 		if (endi != NULL) {
756 			*endi = '\0';
757 			endi2 = strrchr(starti, '/');
758 			if (endi2 == NULL)
759 				break;
760 			*endi = '=';
761 			*endi2 = '\0';
762 			if ((cid = topo_mod_strdup(mod, starti)) == NULL)
763 				break;
764 			*endi2 = '/';
765 			find = endi2;
766 		} else {
767 			if ((cid = topo_mod_strdup(mod, starti)) == NULL)
768 				break;
769 			find = starti + strlen(starti);
770 		}
771 		if (topo_mod_nvalloc(mod, &pa[i], NV_UNIQUE_NAME) < 0)
772 			break;
773 
774 		if (nvlist_add_string(pa[i], FM_FMRI_HC_NAME, cname) ||
775 		    nvlist_add_string(pa[i], FM_FMRI_HC_ID, cid))
776 			break;
777 
778 		topo_mod_strfree(mod, cname);
779 		topo_mod_strfree(mod, cid);
780 		cname = NULL;
781 		cid = NULL;
782 	}
783 
784 	topo_mod_strfree(mod, cname);
785 	topo_mod_strfree(mod, cid);
786 
787 	if (i < npairs) {
788 		for (i = 0; i < npairs; i++)
789 			nvlist_free(pa[i]);
790 		topo_mod_free(mod, pa, npairs * sizeof (nvlist_t *));
791 		topo_mod_free(mod, hc, hclen);
792 		return (NULL);
793 	}
794 
795 	topo_mod_free(mod, hc, hclen);
796 
797 	return (pa);
798 }
799 
800 int
make_hc_auth(topo_mod_t * mod,char * fmri,char ** serial,char ** part,char ** rev,nvlist_t ** auth)801 make_hc_auth(topo_mod_t *mod, char *fmri, char **serial, char **part,
802 char **rev, nvlist_t **auth)
803 {
804 	char *starti, *startn, *endi, *copy;
805 	char *aname = NULL, *aid = NULL, *fs;
806 	nvlist_t *na = NULL;
807 	size_t len;
808 
809 	if ((copy = topo_mod_strdup(mod, fmri + 5)) == NULL)
810 		return (-1);
811 
812 	len = strlen(copy);
813 
814 	/*
815 	 * Make sure there are a valid authority members
816 	 */
817 	startn = strchr(copy, ':');
818 	fs = strchr(copy, '/');
819 
820 	if (startn == NULL || fs == NULL) {
821 		topo_mod_strfree(mod, copy);
822 		return (0);
823 	}
824 
825 	/*
826 	 * The first colon we encounter must occur before the
827 	 * first slash
828 	 */
829 	if (startn > fs)
830 		goto hcabail;
831 
832 	do {
833 		if (++startn >= copy + len)
834 			break;
835 
836 		if ((starti = strchr(startn, '=')) == NULL)
837 			goto hcabail;
838 
839 		*starti = '\0';
840 		if (++starti > copy + len)
841 			goto hcabail;
842 
843 		if ((aname = topo_mod_strdup(mod, startn)) == NULL)
844 			goto hcabail;
845 
846 		startn = endi = strchr(starti, ':');
847 		if (endi == NULL)
848 			if ((endi = strchr(starti, '/')) == NULL)
849 				break;
850 
851 		*endi = '\0';
852 		if ((aid = topo_mod_strdup(mod, starti)) == NULL)
853 			goto hcabail;
854 
855 		/*
856 		 * Return possible serial, part and revision
857 		 */
858 		if (strcmp(aname, FM_FMRI_HC_SERIAL_ID) == 0) {
859 			*serial = topo_mod_strdup(mod, aid);
860 		} else if (strcmp(aname, FM_FMRI_HC_PART) == 0) {
861 			*part = topo_mod_strdup(mod, aid);
862 		} else if (strcmp(aname, FM_FMRI_HC_REVISION) == 0) {
863 			*rev = topo_mod_strdup(mod, aid);
864 		} else {
865 			if (na == NULL) {
866 				if (topo_mod_nvalloc(mod, &na,
867 				    NV_UNIQUE_NAME) == 0) {
868 					(void) nvlist_add_string(na, aname,
869 					    aid);
870 				}
871 			} else {
872 				(void) nvlist_add_string(na, aname, aid);
873 			}
874 		}
875 		topo_mod_strfree(mod, aname);
876 		topo_mod_strfree(mod, aid);
877 		aname = aid = NULL;
878 
879 	} while (startn != NULL);
880 
881 	*auth = na;
882 
883 	topo_mod_free(mod, copy, len + 1);
884 	return (0);
885 
886 hcabail:
887 	topo_mod_free(mod, copy, len + 1);
888 	topo_mod_strfree(mod, aname);
889 	topo_mod_strfree(mod, aid);
890 	nvlist_free(na);
891 	return (-1);
892 }
893 
894 
895 /*
896  * This function creates an nvlist to represent the facility portion of an
897  * hc-scheme node, given a string representation of the fmri.  This is called by
898  * hc_fmri_str2nvl.  If the string does not contain a facility component
899  * (e.g. ?<ftype>=<fname>) then it bails early and returns 0.
900  *
901  * On failure it returns -1 and sets the topo mod errno
902  */
903 int
make_facility(topo_mod_t * mod,char * str,nvlist_t ** nvl)904 make_facility(topo_mod_t *mod, char *str, nvlist_t **nvl)
905 {
906 	char *fac, *copy, *fname, *ftype;
907 	nvlist_t *nf = NULL;
908 	size_t len;
909 
910 	if ((fac = strchr(str, '?')) == NULL)
911 		return (0);
912 
913 	++fac;
914 	if ((copy = topo_mod_strdup(mod, fac)) == NULL)
915 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
916 
917 	fac = copy;
918 	len = strlen(fac);
919 
920 	if ((fname = strchr(fac, '=')) == NULL) {
921 		topo_mod_free(mod, copy, len + 1);
922 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
923 	}
924 
925 	fname[0] = '\0';
926 	++fname;
927 	ftype = fac;
928 
929 	if (topo_mod_nvalloc(mod, &nf, NV_UNIQUE_NAME) != 0) {
930 		topo_mod_free(mod, copy, len + 1);
931 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
932 	}
933 
934 	if (nvlist_add_string(nf, FM_FMRI_FACILITY_NAME, fname) != 0 ||
935 	    nvlist_add_string(nf, FM_FMRI_FACILITY_TYPE, ftype) != 0) {
936 		topo_mod_free(mod, copy, len + 1);
937 		return (topo_mod_seterrno(mod, EMOD_FMRI_NVL));
938 	}
939 
940 	topo_mod_free(mod, copy, len + 1);
941 
942 	*nvl = nf;
943 
944 	return (0);
945 }
946 
947 /*ARGSUSED*/
948 static int
hc_fmri_str2nvl(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)949 hc_fmri_str2nvl(topo_mod_t *mod, tnode_t *node, topo_version_t version,
950     nvlist_t *in, nvlist_t **out)
951 {
952 	nvlist_t **pa = NULL;
953 	nvlist_t *nf = NULL;
954 	nvlist_t *auth = NULL;
955 	nvlist_t *fac = NULL;
956 	char *str;
957 	char *serial = NULL, *part = NULL, *rev = NULL, *hcsn = NULL;
958 	int npairs, n;
959 	int i, e;
960 
961 	if (version > TOPO_METH_STR2NVL_VERSION)
962 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
963 
964 	if (nvlist_lookup_string(in, "fmri-string", &str) != 0)
965 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
966 
967 	/* We're expecting a string version of an hc scheme FMRI */
968 	if (strncmp(str, "hc://", 5) != 0)
969 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
970 
971 	if ((pa = make_hc_pairs(mod, str, &npairs)) == NULL)
972 		return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
973 
974 	if (make_hc_auth(mod, str, &serial, &part, &rev, &auth) < 0)
975 		goto hcfmbail;
976 
977 	if ((nf = hc_base_fmri_create(mod, auth, part, rev, serial)) == NULL)
978 		goto hcfmbail;
979 
980 	n = npairs;
981 
982 	/*
983 	 * If the last pair in hc-list is offset or physaddr, we move
984 	 * it to hc-specific.
985 	 */
986 	(void) nvlist_lookup_string(pa[npairs - 1], FM_FMRI_HC_NAME, &hcsn);
987 	if (strcmp(hcsn, FM_FMRI_HC_SPECIFIC_OFFSET) == 0 ||
988 	    strcmp(hcsn, FM_FMRI_HC_SPECIFIC_PHYSADDR) == 0) {
989 		char *hcid;
990 		nvlist_t *hcsp;
991 		uint64_t val;
992 
993 		(void) nvlist_lookup_string(pa[npairs - 1], FM_FMRI_HC_ID,
994 		    &hcid);
995 		val = strtoull(hcid, NULL, 16);
996 		if (topo_mod_nvalloc(mod, &hcsp, NV_UNIQUE_NAME) != 0)
997 			goto hcfmbail;
998 		if (nvlist_add_uint64(hcsp, hcsn, val) != 0 ||
999 		    nvlist_add_nvlist(nf, FM_FMRI_HC_SPECIFIC, hcsp) != 0) {
1000 			nvlist_free(hcsp);
1001 			goto hcfmbail;
1002 		}
1003 
1004 		nvlist_free(hcsp);
1005 		n--;
1006 	}
1007 
1008 	if ((e = nvlist_add_uint32(nf, FM_FMRI_HC_LIST_SZ, n)) == 0)
1009 		e = nvlist_add_nvlist_array(nf, FM_FMRI_HC_LIST, pa, n);
1010 	if (e != 0) {
1011 		topo_mod_dprintf(mod, "construction of new hc nvl failed");
1012 		goto hcfmbail;
1013 	}
1014 
1015 	/*
1016 	 * Clean-up
1017 	 */
1018 	for (i = 0; i < npairs; i++)
1019 		nvlist_free(pa[i]);
1020 	topo_mod_free(mod, pa, npairs * sizeof (nvlist_t *));
1021 	topo_mod_strfree(mod, serial);
1022 	topo_mod_strfree(mod, part);
1023 	topo_mod_strfree(mod, rev);
1024 	nvlist_free(auth);
1025 
1026 	if (make_facility(mod, str, &fac) == -1)
1027 		goto hcfmbail;
1028 
1029 	if (fac != NULL) {
1030 		if (nvlist_add_nvlist(nf, FM_FMRI_FACILITY, fac) != 0)
1031 			goto hcfmbail;
1032 	}
1033 
1034 	*out = nf;
1035 
1036 	return (0);
1037 
1038 hcfmbail:
1039 	if (nf != NULL)
1040 		nvlist_free(nf);
1041 	for (i = 0; i < npairs; i++)
1042 		nvlist_free(pa[i]);
1043 	topo_mod_free(mod, pa, npairs * sizeof (nvlist_t *));
1044 
1045 	topo_mod_strfree(mod, serial);
1046 	topo_mod_strfree(mod, part);
1047 	topo_mod_strfree(mod, rev);
1048 	nvlist_free(auth);
1049 	nvlist_free(nf);
1050 	return (topo_mod_seterrno(mod, EMOD_FMRI_MALFORM));
1051 }
1052 
1053 static nvlist_t *
hc_list_create(topo_mod_t * mod,const char * name,char * inst)1054 hc_list_create(topo_mod_t *mod, const char *name, char *inst)
1055 {
1056 	int err;
1057 	nvlist_t *hc;
1058 
1059 	if (topo_mod_nvalloc(mod, &hc, NV_UNIQUE_NAME) != 0)
1060 		return (NULL);
1061 
1062 	err = nvlist_add_string(hc, FM_FMRI_HC_NAME, name);
1063 	err |= nvlist_add_string(hc, FM_FMRI_HC_ID, inst);
1064 	if (err != 0) {
1065 		nvlist_free(hc);
1066 		return (NULL);
1067 	}
1068 
1069 	return (hc);
1070 }
1071 
1072 static nvlist_t *
hc_create_seterror(topo_mod_t * mod,nvlist_t ** hcl,int n,nvlist_t * fmri,int err)1073 hc_create_seterror(topo_mod_t *mod, nvlist_t **hcl, int n, nvlist_t *fmri,
1074     int err)
1075 {
1076 	int i;
1077 
1078 	if (hcl != NULL) {
1079 		for (i = 0; i < n + 1; ++i)
1080 			nvlist_free(hcl[i]);
1081 
1082 		topo_mod_free(mod, hcl, sizeof (nvlist_t *) * (n + 1));
1083 	}
1084 
1085 	nvlist_free(fmri);
1086 
1087 	(void) topo_mod_seterrno(mod, err);
1088 
1089 	topo_mod_dprintf(mod, "unable to create hc FMRI: %s\n",
1090 	    topo_mod_errmsg(mod));
1091 
1092 	return (NULL);
1093 }
1094 
1095 static int
hc_name_canonical(topo_mod_t * mod,const char * name)1096 hc_name_canonical(topo_mod_t *mod, const char *name)
1097 {
1098 	int i;
1099 
1100 	if (getenv("NOHCCHECK") != NULL)
1101 		return (1);
1102 
1103 	/*
1104 	 * Only enumerate elements with correct canonical names
1105 	 */
1106 	for (i = 0; i < hc_ncanon; i++) {
1107 		if (strcmp(name, hc_canon[i].hcc_name) == 0)
1108 			break;
1109 	}
1110 	if (i >= hc_ncanon) {
1111 		topo_mod_dprintf(mod, "non-canonical name %s\n",
1112 		    name);
1113 		return (0);
1114 	} else {
1115 		return (1);
1116 	}
1117 }
1118 
1119 static nvlist_t *
hc_fmri_create(topo_mod_t * mod,nvlist_t * pfmri,int version,const char * name,topo_instance_t inst,const nvlist_t * auth,const char * part,const char * rev,const char * serial)1120 hc_fmri_create(topo_mod_t *mod, nvlist_t *pfmri, int version, const char *name,
1121     topo_instance_t inst, const nvlist_t *auth, const char *part,
1122     const char *rev, const char *serial)
1123 {
1124 	int i;
1125 	char str[21]; /* sizeof (UINT64_MAX) + '\0' */
1126 	uint_t pelems = 0;
1127 	nvlist_t **phcl = NULL;
1128 	nvlist_t **hcl = NULL;
1129 	nvlist_t *fmri = NULL;
1130 
1131 	if (version > FM_HC_SCHEME_VERSION)
1132 		return (hc_create_seterror(mod,
1133 		    hcl, pelems, fmri, EMOD_VER_OLD));
1134 	else if (version < FM_HC_SCHEME_VERSION)
1135 		return (hc_create_seterror(mod,
1136 		    hcl, pelems, fmri, EMOD_VER_NEW));
1137 
1138 	/*
1139 	 * Check that the requested name is in our canonical list
1140 	 */
1141 	if (hc_name_canonical(mod, name) == 0)
1142 		return (hc_create_seterror(mod,
1143 		    hcl, pelems, fmri, EMOD_NONCANON));
1144 	/*
1145 	 * Copy the parent's HC_LIST
1146 	 */
1147 	if (pfmri != NULL) {
1148 		if (nvlist_lookup_nvlist_array(pfmri, FM_FMRI_HC_LIST,
1149 		    &phcl, &pelems) != 0)
1150 			return (hc_create_seterror(mod,
1151 			    hcl, pelems, fmri, EMOD_FMRI_MALFORM));
1152 	}
1153 
1154 	hcl = topo_mod_zalloc(mod, sizeof (nvlist_t *) * (pelems + 1));
1155 	if (hcl == NULL)
1156 		return (hc_create_seterror(mod,  hcl, pelems, fmri,
1157 		    EMOD_NOMEM));
1158 
1159 	for (i = 0; i < pelems; ++i)
1160 		if (topo_mod_nvdup(mod, phcl[i], &hcl[i]) != 0)
1161 			return (hc_create_seterror(mod,
1162 			    hcl, pelems, fmri, EMOD_FMRI_NVL));
1163 
1164 	(void) snprintf(str, sizeof (str), "%d", inst);
1165 	if ((hcl[i] = hc_list_create(mod, name, str)) == NULL)
1166 		return (hc_create_seterror(mod,
1167 		    hcl, pelems, fmri, EMOD_FMRI_NVL));
1168 
1169 	if ((fmri = hc_base_fmri_create(mod, auth, part, rev, serial)) == NULL)
1170 		return (hc_create_seterror(mod,
1171 		    hcl, pelems, fmri, EMOD_FMRI_NVL));
1172 
1173 	if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, hcl, pelems + 1)
1174 	    != 0)
1175 		return (hc_create_seterror(mod,
1176 		    hcl, pelems, fmri, EMOD_FMRI_NVL));
1177 
1178 	if (hcl != NULL) {
1179 		for (i = 0; i < pelems + 1; ++i) {
1180 			if (hcl[i] != NULL)
1181 				nvlist_free(hcl[i]);
1182 		}
1183 		topo_mod_free(mod, hcl, sizeof (nvlist_t *) * (pelems + 1));
1184 	}
1185 
1186 	return (fmri);
1187 }
1188 
1189 /*ARGSUSED*/
1190 static int
hc_fmri_create_meth(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1191 hc_fmri_create_meth(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1192     nvlist_t *in, nvlist_t **out)
1193 {
1194 	int ret;
1195 	nvlist_t *args, *pfmri = NULL;
1196 	nvlist_t *auth;
1197 	uint32_t inst;
1198 	char *name, *serial, *rev, *part;
1199 
1200 	if (version > TOPO_METH_FMRI_VERSION)
1201 		return (topo_mod_seterrno(mod, EMOD_VER_NEW));
1202 
1203 	/* First the must-have fields */
1204 	if (nvlist_lookup_string(in, TOPO_METH_FMRI_ARG_NAME, &name) != 0)
1205 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1206 	if (nvlist_lookup_uint32(in, TOPO_METH_FMRI_ARG_INST, &inst) != 0)
1207 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1208 
1209 	/*
1210 	 * args is optional
1211 	 */
1212 	pfmri = NULL;
1213 	auth = NULL;
1214 	serial = rev = part = NULL;
1215 	if ((ret = nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NVL, &args))
1216 	    != 0) {
1217 		if (ret != ENOENT)
1218 			return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1219 	} else {
1220 
1221 		/* And then optional arguments */
1222 		(void) nvlist_lookup_nvlist(args, TOPO_METH_FMRI_ARG_PARENT,
1223 		    &pfmri);
1224 		(void) nvlist_lookup_nvlist(args, TOPO_METH_FMRI_ARG_AUTH,
1225 		    &auth);
1226 		(void) nvlist_lookup_string(args, TOPO_METH_FMRI_ARG_PART,
1227 		    &part);
1228 		(void) nvlist_lookup_string(args, TOPO_METH_FMRI_ARG_REV, &rev);
1229 		(void) nvlist_lookup_string(args, TOPO_METH_FMRI_ARG_SER,
1230 		    &serial);
1231 	}
1232 
1233 	*out = hc_fmri_create(mod, pfmri, version, name, inst, auth, part,
1234 	    rev, serial);
1235 	if (*out == NULL)
1236 		return (-1);
1237 	return (0);
1238 }
1239 
1240 struct hc_walk {
1241 	topo_mod_walk_cb_t hcw_cb;
1242 	void *hcw_priv;
1243 	topo_walk_t *hcw_wp;
1244 	nvlist_t **hcw_list;
1245 	nvlist_t *hcw_fmri;
1246 	nvlist_t *hcw_fac;
1247 	uint_t hcw_index;
1248 	uint_t hcw_end;
1249 };
1250 
1251 /*
1252  * Returns true if the given node is beneath the specified FMRI.  This uses
1253  * the TOPO_METH_CONTAINS method, because some enumerators (such as external
1254  * enclosures) may want to do a comparison based on chassis WWN instead of the
1255  * instance ID.  If this comparison function fails or is not supported, then we
1256  * fall back to a direct name/instance comparison.
1257  */
1258 static int
hc_match(topo_mod_t * mod,tnode_t * node,nvlist_t * fmri,const char * name,topo_instance_t inst,boolean_t * result)1259 hc_match(topo_mod_t *mod, tnode_t *node, nvlist_t *fmri, const char *name,
1260     topo_instance_t inst, boolean_t *result)
1261 {
1262 	nvlist_t *rsrc;
1263 	nvlist_t *arg, *nvl;
1264 	uint32_t match = 0;
1265 	int err;
1266 
1267 	if (topo_node_resource(node, &rsrc, &err) != 0)
1268 		return (-1);
1269 
1270 	if (topo_mod_nvalloc(mod, &arg, NV_UNIQUE_NAME) != 0 ||
1271 	    nvlist_add_nvlist(arg, TOPO_METH_FMRI_ARG_FMRI,
1272 	    rsrc) != 0 ||
1273 	    nvlist_add_nvlist(arg, TOPO_METH_FMRI_ARG_SUBFMRI,
1274 	    fmri) != 0) {
1275 		nvlist_free(rsrc);
1276 		(void) topo_mod_seterrno(mod, EMOD_NOMEM);
1277 		return (-1);
1278 	}
1279 
1280 	nvlist_free(rsrc);
1281 
1282 	if (topo_method_invoke(node, TOPO_METH_CONTAINS,
1283 	    TOPO_METH_CONTAINS_VERSION, arg, &nvl, &err) != 0) {
1284 		nvlist_free(arg);
1285 		if (err == ETOPO_METHOD_NOTSUP) {
1286 			match = (strcmp(name,
1287 			    topo_node_name(node)) == 0 &&
1288 			    inst == topo_node_instance(node));
1289 		} else {
1290 			return (-1);
1291 		}
1292 	} else {
1293 		nvlist_free(arg);
1294 		if (nvlist_lookup_uint32(nvl, TOPO_METH_CONTAINS_RET,
1295 		    &match) != 0) {
1296 			nvlist_free(nvl);
1297 			(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
1298 			return (-1);
1299 		}
1300 		nvlist_free(nvl);
1301 	}
1302 
1303 	*result = (match != 0);
1304 	return (0);
1305 }
1306 
1307 /*
1308  * Ideally, we should just be able to call topo_walk_bysibling().  But that
1309  * code assumes that the name/instance pair will match, so we need to
1310  * explicitly iterate over children of the parent looking for a matching value.
1311  */
1312 static int
hc_walk_sibling(topo_mod_t * mod,tnode_t * node,struct hc_walk * hwp,const char * name,topo_instance_t inst)1313 hc_walk_sibling(topo_mod_t *mod, tnode_t *node, struct hc_walk *hwp,
1314     const char *name, topo_instance_t inst)
1315 {
1316 	tnode_t *pnp = topo_node_parent(node);
1317 	topo_walk_t *wp = hwp->hcw_wp;
1318 	tnode_t *np;
1319 	boolean_t matched;
1320 	int status;
1321 
1322 	for (np = topo_child_first(pnp); np != NULL;
1323 	    np = topo_child_next(pnp, np)) {
1324 		topo_node_hold(np);
1325 		if (hc_match(mod, np, hwp->hcw_fmri, name, inst,
1326 		    &matched) == 0 && matched) {
1327 			wp->tw_node = np;
1328 			if (wp->tw_mod != NULL)
1329 				status = wp->tw_cb(mod, np, hwp);
1330 			else
1331 				status = wp->tw_cb(wp->tw_thp, np, hwp);
1332 			topo_node_rele(np);
1333 			wp->tw_node = node;
1334 			return (status);
1335 		}
1336 
1337 		topo_node_rele(np);
1338 	}
1339 
1340 	return (TOPO_WALK_TERMINATE);
1341 }
1342 
1343 /*
1344  * Generic walker for the hc-scheme topo tree.  This function uses the
1345  * hierachical nature of the hc-scheme to efficiently step through
1346  * the topo hc tree.  Node lookups are done by topo_walk_byid() and
1347  * topo_walk_bysibling()  at each component level to avoid unnecessary
1348  * traversal of the tree.  hc_walker() never returns TOPO_WALK_NEXT, so
1349  * whether TOPO_WALK_CHILD or TOPO_WALK_SIBLING is specified by
1350  * topo_walk_step() doesn't affect the traversal.
1351  */
1352 static int
hc_walker(topo_mod_t * mod,tnode_t * node,void * pdata)1353 hc_walker(topo_mod_t *mod, tnode_t *node, void *pdata)
1354 {
1355 	int i, err;
1356 	struct hc_walk *hwp = (struct hc_walk *)pdata;
1357 	char *name, *id;
1358 	char *fname, *ftype;
1359 	topo_instance_t inst;
1360 	boolean_t match;
1361 
1362 	i = hwp->hcw_index;
1363 	if (i > hwp->hcw_end) {
1364 		if (hwp->hcw_fac != NULL) {
1365 			if ((err = hwp->hcw_cb(mod, node, hwp->hcw_priv))
1366 			    != 0) {
1367 				(void) topo_mod_seterrno(mod, err);
1368 				topo_mod_dprintf(mod, "hc_walker: callback "
1369 				    "failed: %s\n ", topo_mod_errmsg(mod));
1370 				return (TOPO_WALK_ERR);
1371 			}
1372 			topo_mod_dprintf(mod, "hc_walker: callback "
1373 			    "complete: terminate walk\n");
1374 			return (TOPO_WALK_TERMINATE);
1375 		} else {
1376 			topo_mod_dprintf(mod, "hc_walker: node not found\n");
1377 			return (TOPO_WALK_TERMINATE);
1378 		}
1379 	}
1380 
1381 	err = nvlist_lookup_string(hwp->hcw_list[i], FM_FMRI_HC_NAME, &name);
1382 	err |= nvlist_lookup_string(hwp->hcw_list[i], FM_FMRI_HC_ID, &id);
1383 
1384 	if (err != 0) {
1385 		(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
1386 		return (TOPO_WALK_ERR);
1387 	}
1388 
1389 	inst = atoi(id);
1390 
1391 	/*
1392 	 * Check to see if our node matches the requested FMRI.  If it doesn't
1393 	 * (because the enumerator determines matching based on something other
1394 	 * than name/instance, or because we're at the first level below the
1395 	 * root), then iterate over siblings to find the matching node.
1396 	 */
1397 	if (hc_match(mod, node, hwp->hcw_fmri, name, inst, &match) != 0)
1398 		return (TOPO_WALK_ERR);
1399 
1400 	if (!match)
1401 		return (hc_walk_sibling(mod, node, hwp, name, inst));
1402 
1403 	topo_mod_dprintf(mod, "hc_walker: walking node:%s=%d for hc:"
1404 	    "%s=%d at %d, end at %d \n", topo_node_name(node),
1405 	    topo_node_instance(node), name, inst, i, hwp->hcw_end);
1406 
1407 	if (i == hwp->hcw_end) {
1408 
1409 		/*
1410 		 * We are at the end of the hc-list.  Now, check for
1411 		 * a facility leaf and walk one more time.
1412 		 */
1413 		if (hwp->hcw_fac != NULL) {
1414 			err = nvlist_lookup_string(hwp->hcw_fac,
1415 			    FM_FMRI_FACILITY_NAME, &fname);
1416 			err |= nvlist_lookup_string(hwp->hcw_fac,
1417 			    FM_FMRI_FACILITY_TYPE, &ftype);
1418 			if (err != 0) {
1419 				(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
1420 				return (TOPO_WALK_ERR);
1421 			}
1422 			hwp->hcw_index++;
1423 			topo_mod_dprintf(mod, "hc_walker: walk to facility "
1424 			    "node:%s=%s\n", fname, ftype);
1425 			return (topo_walk_byid(hwp->hcw_wp, fname, 0));
1426 		}
1427 
1428 		/*
1429 		 * Otherwise, this is the node we're looking for.
1430 		 */
1431 		if ((err = hwp->hcw_cb(mod, node, hwp->hcw_priv)) != 0) {
1432 			(void) topo_mod_seterrno(mod, err);
1433 			topo_mod_dprintf(mod, "hc_walker: callback "
1434 			    "failed: %s\n ", topo_mod_errmsg(mod));
1435 			return (TOPO_WALK_ERR);
1436 		} else {
1437 			topo_mod_dprintf(mod, "hc_walker: callback "
1438 			    "complete: terminate walk\n");
1439 			return (TOPO_WALK_TERMINATE);
1440 		}
1441 	}
1442 
1443 	/*
1444 	 * Move on to the next component in the hc-list
1445 	 */
1446 	hwp->hcw_index = ++i;
1447 	err = nvlist_lookup_string(hwp->hcw_list[i], FM_FMRI_HC_NAME, &name);
1448 	err |= nvlist_lookup_string(hwp->hcw_list[i], FM_FMRI_HC_ID, &id);
1449 	if (err != 0) {
1450 		(void) topo_mod_seterrno(mod, err);
1451 		return (TOPO_WALK_ERR);
1452 	}
1453 	inst = atoi(id);
1454 
1455 	return (topo_walk_byid(hwp->hcw_wp, name, inst));
1456 
1457 }
1458 
1459 static struct hc_walk *
hc_walk_init(topo_mod_t * mod,tnode_t * node,nvlist_t * rsrc,topo_mod_walk_cb_t cb,void * pdata)1460 hc_walk_init(topo_mod_t *mod, tnode_t *node, nvlist_t *rsrc,
1461     topo_mod_walk_cb_t cb, void *pdata)
1462 {
1463 	int err, ret;
1464 	uint_t sz;
1465 	struct hc_walk *hwp;
1466 	topo_walk_t *wp;
1467 
1468 	if ((hwp = topo_mod_alloc(mod, sizeof (struct hc_walk))) == NULL) {
1469 		(void) topo_mod_seterrno(mod, EMOD_NOMEM);
1470 		return (NULL);
1471 	}
1472 
1473 	if (nvlist_lookup_nvlist_array(rsrc, FM_FMRI_HC_LIST, &hwp->hcw_list,
1474 	    &sz) != 0) {
1475 		topo_mod_dprintf(mod, "hc_walk_init: failed to lookup %s "
1476 		    "nvlist\n", FM_FMRI_HC_LIST);
1477 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1478 		(void) topo_mod_seterrno(mod, EMOD_METHOD_INVAL);
1479 		return (NULL);
1480 	}
1481 	if ((ret = nvlist_lookup_nvlist(rsrc, FM_FMRI_FACILITY, &hwp->hcw_fac))
1482 	    != 0) {
1483 		if (ret != ENOENT) {
1484 			topo_mod_dprintf(mod, "hc_walk_init: unexpected error "
1485 			    "looking up %s nvlist", FM_FMRI_FACILITY);
1486 			topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1487 			(void) topo_mod_seterrno(mod, EMOD_METHOD_INVAL);
1488 			return (NULL);
1489 		} else {
1490 			hwp->hcw_fac = NULL;
1491 		}
1492 	}
1493 
1494 	hwp->hcw_fmri = rsrc;
1495 	hwp->hcw_end = sz - 1;
1496 	hwp->hcw_index = 0;
1497 	hwp->hcw_priv = pdata;
1498 	hwp->hcw_cb = cb;
1499 	if ((wp = topo_mod_walk_init(mod, node, hc_walker, (void *)hwp, &err))
1500 	    == NULL) {
1501 		topo_mod_dprintf(mod, "hc_walk_init: topo_mod_walk_init failed "
1502 		    "(%s)\n", topo_strerror(err));
1503 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1504 		(void) topo_mod_seterrno(mod, err);
1505 		return (NULL);
1506 	}
1507 
1508 	hwp->hcw_wp = wp;
1509 
1510 	return (hwp);
1511 }
1512 
1513 struct prop_lookup {
1514 	const char *pl_pgroup;
1515 	const char *pl_pname;
1516 	int pl_flag;
1517 	nvlist_t *pl_args;
1518 	nvlist_t *pl_rsrc;
1519 	nvlist_t *pl_prop;
1520 };
1521 
1522 /*ARGSUSED*/
1523 static int
hc_prop_get(topo_mod_t * mod,tnode_t * node,void * pdata)1524 hc_prop_get(topo_mod_t *mod, tnode_t *node, void *pdata)
1525 {
1526 	int err = 0;
1527 
1528 	struct prop_lookup *plp = (struct prop_lookup *)pdata;
1529 
1530 	(void) topo_prop_getprop(node, plp->pl_pgroup, plp->pl_pname,
1531 	    plp->pl_args, &plp->pl_prop, &err);
1532 
1533 	return (err);
1534 }
1535 
1536 static int
hc_fmri_prop_get(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1537 hc_fmri_prop_get(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1538     nvlist_t *in, nvlist_t **out)
1539 {
1540 	int err;
1541 	struct hc_walk *hwp;
1542 	struct prop_lookup *plp;
1543 
1544 	if (version > TOPO_METH_PROP_GET_VERSION)
1545 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1546 
1547 	if ((plp = topo_mod_alloc(mod, sizeof (struct prop_lookup))) == NULL)
1548 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1549 
1550 	err = nvlist_lookup_string(in, TOPO_PROP_GROUP,
1551 	    (char **)&plp->pl_pgroup);
1552 	err |= nvlist_lookup_string(in, TOPO_PROP_VAL_NAME,
1553 	    (char **)&plp->pl_pname);
1554 	err |= nvlist_lookup_nvlist(in, TOPO_PROP_RESOURCE, &plp->pl_rsrc);
1555 	if (err != 0) {
1556 		topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1557 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1558 	}
1559 
1560 	/*
1561 	 * Private args to prop method are optional
1562 	 */
1563 	if ((err = nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &plp->pl_args))
1564 	    != 0) {
1565 		if (err != ENOENT) {
1566 			topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1567 			return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1568 		} else {
1569 			plp->pl_args = NULL;
1570 		}
1571 	}
1572 
1573 	plp->pl_prop = NULL;
1574 	if ((hwp = hc_walk_init(mod, node, plp->pl_rsrc, hc_prop_get,
1575 	    (void *)plp)) != NULL) {
1576 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1577 		    TOPO_WALK_ERR)
1578 			err = -1;
1579 		else
1580 			err = 0;
1581 		topo_walk_fini(hwp->hcw_wp);
1582 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1583 	} else {
1584 		err = -1;
1585 	}
1586 
1587 	if (plp->pl_prop != NULL)
1588 		*out = plp->pl_prop;
1589 
1590 	topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1591 
1592 	return (err);
1593 }
1594 
1595 /*ARGSUSED*/
1596 static int
hc_pgrp_get(topo_mod_t * mod,tnode_t * node,void * pdata)1597 hc_pgrp_get(topo_mod_t *mod, tnode_t *node, void *pdata)
1598 {
1599 	int err = 0;
1600 
1601 	struct prop_lookup *plp = (struct prop_lookup *)pdata;
1602 
1603 	(void) topo_prop_getpgrp(node, plp->pl_pgroup, &plp->pl_prop, &err);
1604 
1605 	return (err);
1606 }
1607 
1608 static int
hc_fmri_pgrp_get(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1609 hc_fmri_pgrp_get(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1610     nvlist_t *in, nvlist_t **out)
1611 {
1612 	int err;
1613 	struct hc_walk *hwp;
1614 	struct prop_lookup *plp;
1615 
1616 	if (version > TOPO_METH_PGRP_GET_VERSION)
1617 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1618 
1619 	if ((plp = topo_mod_alloc(mod, sizeof (struct prop_lookup))) == NULL)
1620 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1621 
1622 	err = nvlist_lookup_string(in, TOPO_PROP_GROUP,
1623 	    (char **)&plp->pl_pgroup);
1624 	err |= nvlist_lookup_nvlist(in, TOPO_PROP_RESOURCE, &plp->pl_rsrc);
1625 	if (err != 0) {
1626 		topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1627 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1628 	}
1629 
1630 	plp->pl_prop = NULL;
1631 	if ((hwp = hc_walk_init(mod, node, plp->pl_rsrc, hc_pgrp_get,
1632 	    (void *)plp)) != NULL) {
1633 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1634 		    TOPO_WALK_ERR)
1635 			err = -1;
1636 		else
1637 			err = 0;
1638 		topo_walk_fini(hwp->hcw_wp);
1639 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1640 	} else {
1641 		err = -1;
1642 	}
1643 
1644 	if (plp->pl_prop != NULL)
1645 		*out = plp->pl_prop;
1646 
1647 	topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1648 
1649 	return (err);
1650 }
1651 
1652 /*ARGSUSED*/
1653 static int
hc_prop_setprop(topo_mod_t * mod,tnode_t * node,void * pdata)1654 hc_prop_setprop(topo_mod_t *mod, tnode_t *node, void *pdata)
1655 {
1656 	int err = 0;
1657 
1658 	struct prop_lookup *plp = (struct prop_lookup *)pdata;
1659 
1660 	(void) topo_prop_setprop(node, plp->pl_pgroup, plp->pl_prop,
1661 	    plp->pl_flag, plp->pl_args, &err);
1662 
1663 	return (err);
1664 }
1665 
1666 /*ARGSUSED*/
1667 static int
hc_fmri_prop_set(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1668 hc_fmri_prop_set(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1669     nvlist_t *in, nvlist_t **out)
1670 {
1671 	int err;
1672 	struct hc_walk *hwp;
1673 	struct prop_lookup *plp;
1674 
1675 	if (version > TOPO_METH_PROP_SET_VERSION)
1676 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1677 
1678 	if ((plp = topo_mod_alloc(mod, sizeof (struct prop_lookup))) == NULL)
1679 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1680 
1681 	err = nvlist_lookup_string(in, TOPO_PROP_GROUP,
1682 	    (char **)&plp->pl_pgroup);
1683 	err |= nvlist_lookup_nvlist(in, TOPO_PROP_RESOURCE, &plp->pl_rsrc);
1684 	err |= nvlist_lookup_nvlist(in, TOPO_PROP_VAL, &plp->pl_prop);
1685 	err |= nvlist_lookup_int32(in, TOPO_PROP_FLAG, &plp->pl_flag);
1686 	if (err != 0) {
1687 		topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1688 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1689 	}
1690 
1691 	/*
1692 	 * Private args to prop method are optional
1693 	 */
1694 	if ((err = nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &plp->pl_args))
1695 	    != 0) {
1696 		if (err != ENOENT)
1697 			return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
1698 		else
1699 			plp->pl_args = NULL;
1700 	}
1701 
1702 	if ((hwp = hc_walk_init(mod, node, plp->pl_rsrc, hc_prop_setprop,
1703 	    (void *)plp)) != NULL) {
1704 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1705 		    TOPO_WALK_ERR)
1706 			err = -1;
1707 		else
1708 			err = 0;
1709 		topo_walk_fini(hwp->hcw_wp);
1710 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1711 	} else {
1712 		err = -1;
1713 	}
1714 
1715 	topo_mod_free(mod, plp, sizeof (struct prop_lookup));
1716 
1717 	return (err);
1718 }
1719 
1720 struct hc_args {
1721 	nvlist_t *ha_fmri;
1722 	nvlist_t *ha_nvl;
1723 	char *ha_method_name;
1724 	topo_version_t ha_method_ver;
1725 };
1726 
1727 static int
hc_auth_changed(nvlist_t * nva,nvlist_t * nvb,const char * propname)1728 hc_auth_changed(nvlist_t *nva, nvlist_t *nvb, const char *propname)
1729 {
1730 	char *stra, *strb;
1731 
1732 	if (nvlist_lookup_string(nva, propname, &stra) != 0 ||
1733 	    nvlist_lookup_string(nvb, propname, &strb) != 0)
1734 		return (FMD_OBJ_STATE_UNKNOWN);
1735 
1736 	if (strcmp(stra, strb) != 0)
1737 		return (FMD_OBJ_STATE_REPLACED);
1738 	else
1739 		return (FMD_OBJ_STATE_STILL_PRESENT);
1740 }
1741 
1742 static int
hc_is_present(topo_mod_t * mod,tnode_t * node,void * pdata)1743 hc_is_present(topo_mod_t *mod, tnode_t *node, void *pdata)
1744 {
1745 	int err;
1746 	struct hc_args *hap = (struct hc_args *)pdata;
1747 	nvlist_t *rsrc;
1748 	boolean_t present;
1749 
1750 	/*
1751 	 * check with the enumerator that created this FMRI
1752 	 * (topo node)
1753 	 */
1754 	if (topo_method_invoke(node, TOPO_METH_PRESENT,
1755 	    TOPO_METH_PRESENT_VERSION, hap->ha_fmri, &hap->ha_nvl,
1756 	    &err) < 0) {
1757 
1758 		/*
1759 		 * If the method exists but failed for some other reason,
1760 		 * propagate the error as making any decision over presence is
1761 		 * impossible.
1762 		 */
1763 		if (err != ETOPO_METHOD_NOTSUP)
1764 			return (err);
1765 
1766 		/*
1767 		 * Check the authority information.  If the part id or serial
1768 		 * number doesn't match, then it isn't the same FMRI.
1769 		 * Otherwise, assume presence.
1770 		 */
1771 		if (topo_node_resource(node, &rsrc, &err) != 0)
1772 			return (err);
1773 
1774 		present = B_TRUE;
1775 		if (hc_auth_changed(hap->ha_fmri, rsrc,
1776 		    FM_FMRI_HC_SERIAL_ID) == FMD_OBJ_STATE_REPLACED ||
1777 		    hc_auth_changed(hap->ha_fmri, rsrc,
1778 		    FM_FMRI_HC_PART) == FMD_OBJ_STATE_REPLACED) {
1779 			present = B_FALSE;
1780 		}
1781 		nvlist_free(rsrc);
1782 
1783 		if (topo_mod_nvalloc(mod, &hap->ha_nvl, NV_UNIQUE_NAME) != 0)
1784 			return (EMOD_NOMEM);
1785 
1786 		if (nvlist_add_uint32(hap->ha_nvl,
1787 		    TOPO_METH_PRESENT_RET, present) != 0) {
1788 			nvlist_free(hap->ha_nvl);
1789 			hap->ha_nvl = NULL;
1790 			return (EMOD_NOMEM);
1791 		}
1792 	}
1793 
1794 	return (0);
1795 }
1796 
1797 static int
hc_fmri_present(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1798 hc_fmri_present(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1799     nvlist_t *in, nvlist_t **out)
1800 {
1801 	int err;
1802 	struct hc_walk *hwp;
1803 	struct hc_args *hap;
1804 
1805 	if (version > TOPO_METH_PRESENT_VERSION)
1806 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1807 
1808 	if ((hap = topo_mod_alloc(mod, sizeof (struct hc_args))) == NULL)
1809 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1810 
1811 	hap->ha_fmri = in;
1812 	hap->ha_nvl = NULL;
1813 	if ((hwp = hc_walk_init(mod, node, hap->ha_fmri, hc_is_present,
1814 	    (void *)hap)) != NULL) {
1815 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1816 		    TOPO_WALK_ERR)
1817 			err = -1;
1818 		else
1819 			err = 0;
1820 		topo_walk_fini(hwp->hcw_wp);
1821 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1822 	} else {
1823 		err = -1;
1824 	}
1825 
1826 	if (hap->ha_nvl != NULL)
1827 		*out = hap->ha_nvl;
1828 
1829 	topo_mod_free(mod, hap, sizeof (struct hc_args));
1830 
1831 	return (err);
1832 }
1833 
1834 static int
hc_is_replaced(topo_mod_t * mod,tnode_t * node,void * pdata)1835 hc_is_replaced(topo_mod_t *mod, tnode_t *node, void *pdata)
1836 {
1837 	int err;
1838 	struct hc_args *hap = (struct hc_args *)pdata;
1839 	uint32_t present = 0;
1840 	nvlist_t *rsrc;
1841 	uint32_t rval = FMD_OBJ_STATE_UNKNOWN;
1842 
1843 	/*
1844 	 * check with the enumerator that created this FMRI
1845 	 * (topo node)
1846 	 */
1847 	if (topo_method_invoke(node, TOPO_METH_REPLACED,
1848 	    TOPO_METH_REPLACED_VERSION, hap->ha_fmri, &hap->ha_nvl,
1849 	    &err) < 0) {
1850 		/*
1851 		 * If the method exists but failed for some other
1852 		 * reason, propagate the error as making any decision
1853 		 * over presence is impossible.
1854 		 */
1855 		if (err != ETOPO_METHOD_NOTSUP)
1856 			return (err);
1857 
1858 		/*
1859 		 * Enumerator didn't provide "replaced" method -
1860 		 * try "present" method
1861 		 */
1862 		if (topo_method_invoke(node, TOPO_METH_PRESENT,
1863 		    TOPO_METH_PRESENT_VERSION, hap->ha_fmri, &hap->ha_nvl,
1864 		    &err) < 0) {
1865 			/*
1866 			 * If the method exists but failed for some other
1867 			 * reason, propagate the error as making any decision
1868 			 * over presence is impossible.
1869 			 */
1870 			if (err != ETOPO_METHOD_NOTSUP)
1871 				return (err);
1872 
1873 			/*
1874 			 * Enumerator didn't provide "present" method either -
1875 			 * so check the authority information.  If the part id
1876 			 * or serial number doesn't match, then it isn't the
1877 			 * same FMRI. Otherwise, if we have a serial number and
1878 			 * it hasn't changed, then assume it is the same FMRI.
1879 			 */
1880 			if (topo_node_resource(node, &rsrc, &err) != 0)
1881 				return (err);
1882 			rval = hc_auth_changed(hap->ha_fmri, rsrc,
1883 			    FM_FMRI_HC_PART);
1884 			if (rval != FMD_OBJ_STATE_REPLACED)
1885 				rval = hc_auth_changed(hap->ha_fmri, rsrc,
1886 				    FM_FMRI_HC_SERIAL_ID);
1887 			nvlist_free(rsrc);
1888 			if (topo_mod_nvalloc(mod, &hap->ha_nvl,
1889 			    NV_UNIQUE_NAME) != 0)
1890 				return (EMOD_NOMEM);
1891 			if (nvlist_add_uint32(hap->ha_nvl,
1892 			    TOPO_METH_REPLACED_RET, rval) != 0) {
1893 				nvlist_free(hap->ha_nvl);
1894 				hap->ha_nvl = NULL;
1895 				return (ETOPO_PROP_NVL);
1896 			}
1897 		} else {
1898 			(void) nvlist_lookup_uint32(hap->ha_nvl,
1899 			    TOPO_METH_PRESENT_RET, &present);
1900 			(void) nvlist_remove(hap->ha_nvl,
1901 			    TOPO_METH_PRESENT_RET, DATA_TYPE_UINT32);
1902 			if (nvlist_add_uint32(hap->ha_nvl,
1903 			    TOPO_METH_REPLACED_RET,
1904 			    present ? FMD_OBJ_STATE_UNKNOWN :
1905 			    FMD_OBJ_STATE_NOT_PRESENT) != 0) {
1906 				nvlist_free(hap->ha_nvl);
1907 				hap->ha_nvl = NULL;
1908 				return (ETOPO_PROP_NVL);
1909 			}
1910 		}
1911 	}
1912 	return (0);
1913 }
1914 
1915 static int
hc_fmri_replaced(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1916 hc_fmri_replaced(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1917     nvlist_t *in, nvlist_t **out)
1918 {
1919 	int err;
1920 	struct hc_walk *hwp;
1921 	struct hc_args *hap;
1922 
1923 	if (version > TOPO_METH_REPLACED_VERSION)
1924 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1925 
1926 	if ((hap = topo_mod_alloc(mod, sizeof (struct hc_args))) == NULL)
1927 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1928 
1929 	hap->ha_fmri = in;
1930 	hap->ha_nvl = NULL;
1931 	if ((hwp = hc_walk_init(mod, node, hap->ha_fmri, hc_is_replaced,
1932 	    (void *)hap)) != NULL) {
1933 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1934 		    TOPO_WALK_ERR)
1935 			err = -1;
1936 		else
1937 			err = 0;
1938 		topo_walk_fini(hwp->hcw_wp);
1939 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
1940 	} else {
1941 		err = -1;
1942 	}
1943 
1944 	if (hap->ha_nvl != NULL)
1945 		*out = hap->ha_nvl;
1946 
1947 	topo_mod_free(mod, hap, sizeof (struct hc_args));
1948 
1949 	return (err);
1950 }
1951 
1952 static int
hc_unusable(topo_mod_t * mod,tnode_t * node,void * pdata)1953 hc_unusable(topo_mod_t *mod, tnode_t *node, void *pdata)
1954 {
1955 	int err;
1956 	struct hc_args *hap = (struct hc_args *)pdata;
1957 
1958 	/*
1959 	 * check with the enumerator that created this FMRI
1960 	 * (topo node)
1961 	 */
1962 	if (topo_method_invoke(node, TOPO_METH_UNUSABLE,
1963 	    TOPO_METH_UNUSABLE_VERSION, hap->ha_fmri, &hap->ha_nvl,
1964 	    &err) < 0) {
1965 
1966 		/*
1967 		 * Err on the side of caution and return usable
1968 		 */
1969 		if (topo_mod_nvalloc(mod, &hap->ha_nvl, NV_UNIQUE_NAME) == 0)
1970 			if (nvlist_add_uint32(hap->ha_nvl,
1971 			    TOPO_METH_UNUSABLE_RET, 0) == 0)
1972 				return (0);
1973 
1974 		return (ETOPO_PROP_NVL);
1975 	}
1976 
1977 	return (0);
1978 }
1979 
1980 static int
hc_fmri_unusable(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)1981 hc_fmri_unusable(topo_mod_t *mod, tnode_t *node, topo_version_t version,
1982     nvlist_t *in, nvlist_t **out)
1983 {
1984 	int err;
1985 	struct hc_walk *hwp;
1986 	struct hc_args *hap;
1987 
1988 	if (version > TOPO_METH_UNUSABLE_VERSION)
1989 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
1990 
1991 	if ((hap = topo_mod_alloc(mod, sizeof (struct hc_args))) == NULL)
1992 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
1993 
1994 	hap->ha_fmri = in;
1995 	hap->ha_nvl = NULL;
1996 	if ((hwp = hc_walk_init(mod, node, hap->ha_fmri, hc_unusable,
1997 	    (void *)hap)) != NULL) {
1998 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
1999 		    TOPO_WALK_ERR)
2000 			err = -1;
2001 		else
2002 			err = 0;
2003 		topo_walk_fini(hwp->hcw_wp);
2004 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
2005 	} else {
2006 		err = -1;
2007 	}
2008 
2009 	if (hap->ha_nvl != NULL)
2010 		*out = hap->ha_nvl;
2011 
2012 	topo_mod_free(mod, hap, sizeof (struct hc_args));
2013 
2014 	return (err);
2015 }
2016 
2017 struct fac_lookup {
2018 	const char *fl_fac_type;
2019 	uint32_t fl_fac_subtype;
2020 #ifdef _LP64
2021 	uint64_t fl_callback;
2022 	uint64_t fl_callback_args;
2023 #else
2024 	uint32_t fl_callback;
2025 	uint32_t fl_callback_args;
2026 #endif
2027 	nvlist_t *fl_rsrc;
2028 	nvlist_t *fl_fac_rsrc;
2029 };
2030 
2031 static int
hc_fac_get(topo_mod_t * mod,tnode_t * node,void * pdata)2032 hc_fac_get(topo_mod_t *mod, tnode_t *node, void *pdata)
2033 {
2034 	struct fac_lookup *flp = (struct fac_lookup *)pdata;
2035 	topo_walk_cb_t cb = (topo_walk_cb_t)flp->fl_callback;
2036 	topo_faclist_t faclist, *tmp;
2037 	int err, ret = 0;
2038 
2039 	/*
2040 	 * Lookup the specified facility node.  Return with an error if we can't
2041 	 * find it.
2042 	 */
2043 	if (topo_node_facility(mod->tm_hdl, node, flp->fl_fac_type,
2044 	    flp->fl_fac_subtype, &faclist, &err) != 0) {
2045 		topo_mod_dprintf(mod, "hc_fac_get: topo_node_facility "
2046 		    "failed\n");
2047 		return (TOPO_WALK_ERR);
2048 	}
2049 
2050 	/*
2051 	 * Invoke user's callback for each facility node in the topo list,
2052 	 * passing in a pointer to the facility node
2053 	 */
2054 	for (tmp = topo_list_next(&faclist.tf_list); tmp != NULL;
2055 	    tmp = topo_list_next(tmp)) {
2056 
2057 		if ((err = cb(mod->tm_hdl, tmp->tf_node,
2058 		    (void *)flp->fl_callback_args)) != 0) {
2059 			(void) topo_mod_seterrno(mod, err);
2060 			topo_mod_dprintf(mod, "hc_fac_get: callback failed: "
2061 			    "%s\n ", topo_mod_errmsg(mod));
2062 			ret = TOPO_WALK_ERR;
2063 			break;
2064 		}
2065 	}
2066 
2067 	while ((tmp = topo_list_next(&faclist.tf_list)) != NULL) {
2068 		topo_list_delete(&faclist.tf_list, tmp);
2069 		topo_mod_free(mod, tmp, sizeof (topo_faclist_t));
2070 	}
2071 	return (ret);
2072 }
2073 
2074 static int
hc_fmri_facility(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)2075 hc_fmri_facility(topo_mod_t *mod, tnode_t *node, topo_version_t version,
2076     nvlist_t *in, nvlist_t **out)
2077 {
2078 	int err = 0;
2079 	struct hc_walk *hwp;
2080 	struct fac_lookup *flp;
2081 
2082 	if (version > TOPO_METH_FACILITY_VERSION)
2083 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
2084 
2085 	if ((flp = topo_mod_alloc(mod, sizeof (struct fac_lookup))) == NULL)
2086 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
2087 
2088 	/*
2089 	 * lookup arguments: hw resource, facility type, facility subtype,
2090 	 *  callback and callback args
2091 	 */
2092 	err = nvlist_lookup_nvlist(in, TOPO_PROP_RESOURCE, &flp->fl_rsrc);
2093 	err |= nvlist_lookup_string(in, FM_FMRI_FACILITY_TYPE,
2094 	    (char **)&flp->fl_fac_type);
2095 	err |= nvlist_lookup_uint32(in, "type", &flp->fl_fac_subtype);
2096 #ifdef _LP64
2097 	err |= nvlist_lookup_uint64(in, "callback", &flp->fl_callback);
2098 	err |= nvlist_lookup_uint64(in, "callback-args",
2099 	    &flp->fl_callback_args);
2100 #else
2101 	err |= nvlist_lookup_uint32(in, "callback", &flp->fl_callback);
2102 	err |= nvlist_lookup_uint32(in, "callback-args",
2103 	    &flp->fl_callback_args);
2104 #endif
2105 	if (err != 0) {
2106 		topo_mod_dprintf(mod, "hc_fmri_facility: failed to construct "
2107 		    "walker arg nvlist\n");
2108 		topo_mod_free(mod, flp, sizeof (struct fac_lookup));
2109 		return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
2110 	}
2111 
2112 	flp->fl_fac_rsrc = NULL;
2113 	if ((hwp = hc_walk_init(mod, node, flp->fl_rsrc, hc_fac_get,
2114 	    (void *)flp)) != NULL) {
2115 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
2116 		    TOPO_WALK_ERR)
2117 			err = -1;
2118 		else
2119 			err = 0;
2120 		topo_walk_fini(hwp->hcw_wp);
2121 		topo_mod_free(mod, hwp, sizeof (struct hc_walk));
2122 	} else {
2123 		topo_mod_dprintf(mod, "hc_fmri_facility: failed to initialize "
2124 		    "hc walker\n");
2125 		err = -1;
2126 	}
2127 
2128 	if (flp->fl_fac_rsrc != NULL)
2129 		*out = flp->fl_fac_rsrc;
2130 
2131 	topo_mod_free(mod, flp, sizeof (struct fac_lookup));
2132 
2133 	return (err);
2134 }
2135 
2136 /* ARGSUSED */
2137 static int
hc_expand(topo_mod_t * mod,tnode_t * node,void * pdata)2138 hc_expand(topo_mod_t *mod, tnode_t *node, void *pdata)
2139 {
2140 	int err;
2141 	nvlist_t *nvl;
2142 	const char **namep;
2143 	struct hc_args *hap = (struct hc_args *)pdata;
2144 	const char *names[] = {
2145 		FM_FMRI_HC_SERIAL_ID,
2146 		FM_FMRI_HC_PART,
2147 		FM_FMRI_HC_REVISION,
2148 		NULL
2149 	};
2150 
2151 	if (topo_node_resource(node, &nvl, &err) != 0)
2152 		return (ETOPO_METHOD_FAIL);
2153 
2154 	for (namep = names; *namep != NULL; namep++) {
2155 		char *in_val, *node_val;
2156 
2157 		if (nvlist_lookup_string(nvl, *namep, &node_val) != 0)
2158 			continue;
2159 
2160 		if (nvlist_lookup_string(hap->ha_fmri, *namep, &in_val) == 0) {
2161 			if (strcmp(in_val, node_val) == 0)
2162 				continue;
2163 			(void) nvlist_remove(hap->ha_fmri, *namep,
2164 			    DATA_TYPE_STRING);
2165 		}
2166 
2167 		if (nvlist_add_string(hap->ha_fmri, *namep, node_val) != 0) {
2168 			nvlist_free(nvl);
2169 			return (ETOPO_PROP_NVL);
2170 		}
2171 	}
2172 	nvlist_free(nvl);
2173 
2174 	return (0);
2175 }
2176 
2177 /* ARGSUSED */
2178 static int
hc_fmri_expand(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)2179 hc_fmri_expand(topo_mod_t *mod, tnode_t *node, topo_version_t version,
2180     nvlist_t *in, nvlist_t **out)
2181 {
2182 	int err;
2183 	struct hc_walk *hwp;
2184 	struct hc_args *hap;
2185 
2186 	if (version > TOPO_METH_EXPAND_VERSION)
2187 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
2188 
2189 	if ((hap = topo_mod_alloc(mod, sizeof (struct hc_args))) == NULL)
2190 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
2191 
2192 	hap->ha_fmri = in;
2193 	hap->ha_nvl = NULL;
2194 	if ((hwp = hc_walk_init(mod, node, hap->ha_fmri, hc_expand,
2195 	    (void *)hap)) != NULL) {
2196 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
2197 		    TOPO_WALK_ERR)
2198 			err = -1;
2199 		else
2200 			err = 0;
2201 		topo_walk_fini(hwp->hcw_wp);
2202 	} else {
2203 		err = -1;
2204 	}
2205 
2206 	topo_mod_free(mod, hwp, sizeof (struct hc_walk));
2207 
2208 	/* expand method should not return out nvlist */
2209 	assert(hap->ha_nvl == NULL);
2210 
2211 	topo_mod_free(mod, hap, sizeof (struct hc_args));
2212 
2213 	return (err);
2214 }
2215 
2216 static int
hc_retire_subr(topo_mod_t * mod,tnode_t * node,void * pdata)2217 hc_retire_subr(topo_mod_t *mod, tnode_t *node, void *pdata)
2218 {
2219 	int err, rc;
2220 	struct hc_args *hap = (struct hc_args *)pdata;
2221 
2222 	topo_mod_dprintf(mod, "hc_retire_subr: invoking method %s\n",
2223 	    hap->ha_method_name);
2224 	/*
2225 	 * check with the enumerator that created this FMRI
2226 	 * (topo node)
2227 	 */
2228 	rc = topo_method_invoke(node, hap->ha_method_name,
2229 	    hap->ha_method_ver, hap->ha_fmri, &hap->ha_nvl, &err);
2230 
2231 	topo_mod_dprintf(mod, "hc_retire_subr: invoking method %s "
2232 	    "returned %d\n", hap->ha_method_name, rc);
2233 
2234 	return (rc < 0 ? err : 0);
2235 }
2236 
2237 static int
hc_fmri_retire_subr(topo_mod_t * mod,tnode_t * node,char * method_name,topo_version_t builtin_version,topo_version_t version,nvlist_t * in,nvlist_t ** out)2238 hc_fmri_retire_subr(topo_mod_t *mod, tnode_t *node, char *method_name,
2239     topo_version_t builtin_version, topo_version_t version, nvlist_t *in,
2240     nvlist_t **out)
2241 {
2242 	int err;
2243 	struct hc_walk *hwp;
2244 	struct hc_args *hap;
2245 
2246 	if (version > builtin_version)
2247 		return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
2248 
2249 	if ((hap = topo_mod_alloc(mod, sizeof (struct hc_args))) == NULL)
2250 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
2251 
2252 	hap->ha_fmri = in;
2253 	hap->ha_nvl = NULL;
2254 	hap->ha_method_name = method_name;
2255 	hap->ha_method_ver = version;
2256 	if ((hwp = hc_walk_init(mod, node, hap->ha_fmri, hc_retire_subr,
2257 	    (void *)hap)) != NULL) {
2258 		if (topo_walk_step(hwp->hcw_wp, TOPO_WALK_CHILD) ==
2259 		    TOPO_WALK_ERR)
2260 			err = -1;
2261 		else
2262 			err = 0;
2263 		topo_walk_fini(hwp->hcw_wp);
2264 	} else {
2265 		err = -1;
2266 	}
2267 
2268 	topo_mod_free(mod, hwp, sizeof (struct hc_walk));
2269 
2270 	if (hap->ha_nvl != NULL)
2271 		*out = hap->ha_nvl;
2272 
2273 	topo_mod_free(mod, hap, sizeof (struct hc_args));
2274 
2275 	return (err);
2276 }
2277 
2278 static int
hc_fmri_retire(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)2279 hc_fmri_retire(topo_mod_t *mod, tnode_t *node, topo_version_t version,
2280     nvlist_t *in, nvlist_t **out)
2281 {
2282 	return (hc_fmri_retire_subr(mod, node, TOPO_METH_RETIRE,
2283 	    TOPO_METH_RETIRE_VERSION, version, in, out));
2284 }
2285 
2286 static int
hc_fmri_unretire(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)2287 hc_fmri_unretire(topo_mod_t *mod, tnode_t *node, topo_version_t version,
2288     nvlist_t *in, nvlist_t **out)
2289 {
2290 	return (hc_fmri_retire_subr(mod, node, TOPO_METH_UNRETIRE,
2291 	    TOPO_METH_UNRETIRE_VERSION, version, in, out));
2292 }
2293 
2294 static int
hc_fmri_service_state(topo_mod_t * mod,tnode_t * node,topo_version_t version,nvlist_t * in,nvlist_t ** out)2295 hc_fmri_service_state(topo_mod_t *mod, tnode_t *node, topo_version_t version,
2296     nvlist_t *in, nvlist_t **out)
2297 {
2298 	return (hc_fmri_retire_subr(mod, node, TOPO_METH_SERVICE_STATE,
2299 	    TOPO_METH_SERVICE_STATE_VERSION, version, in, out));
2300 }
2301