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