1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright (c) 2019, Joyent, Inc.
14  */
15 
16 #include <assert.h>
17 #include <fcntl.h>
18 #include <fm/libtopo.h>
19 #include <fm/topo_mod.h>
20 #include <fm/topo_method.h>
21 #ifdef	__x86
22 #include <sys/mc.h>
23 #endif
24 #include <sys/fm/protocol.h>
25 #include <string.h>
26 #include <unistd.h>
27 
28 typedef struct smb_enum_data {
29 	topo_mod_t	*sme_mod;
30 	tnode_t		*sme_pnode;
31 	tnode_t		*sme_slotnode;
32 	topo_instance_t	sme_slot_inst;
33 	topo_instance_t	sme_slot_maxinst;
34 	smbios_info_t	*sme_smb_info;
35 	char		*sme_slot_form;
36 } smb_enum_data_t;
37 
38 static const topo_method_t slot_methods[] = {
39 	{ TOPO_METH_OCCUPIED, TOPO_METH_OCCUPIED_DESC,
40 	    TOPO_METH_OCCUPIED_VERSION, TOPO_STABILITY_INTERNAL,
41 	    topo_mod_hc_occupied },
42 	{ NULL }
43 };
44 
45 /*
46  * This function serves two purposes.  It filters out memory devices that
47  * don't have a formfactor that represents a reasonably modern DIMM-like
48  * device (and hence not a device we're interested in enumerating).  It also
49  * converts the numeric SMBIOS type representation to a more generic TOPO dimm
50  * type.
51  *
52  * Caller must free the returned string.
53  */
54 static char *
distill_dimm_form(topo_mod_t * mod,smbios_memdevice_t * smb_md)55 distill_dimm_form(topo_mod_t *mod, smbios_memdevice_t *smb_md)
56 {
57 	switch (smb_md->smbmd_form) {
58 	case (SMB_MDFF_DIMM):
59 		return (topo_mod_strdup(mod, TOPO_DIMM_SLOT_FORM_DIMM));
60 	case (SMB_MDFF_SODIMM):
61 		return (topo_mod_strdup(mod, TOPO_DIMM_SLOT_FORM_SODIMM));
62 	case (SMB_MDFF_FBDIMM):
63 		return (topo_mod_strdup(mod, TOPO_DIMM_SLOT_FORM_FBDIMM));
64 	default:
65 		topo_mod_dprintf(mod, "skipping device with form factor 0x%x",
66 		    smb_md->smbmd_form);
67 		return (NULL);
68 	}
69 }
70 
71 static char *
smbios2topotype(topo_mod_t * mod,uint8_t type)72 smbios2topotype(topo_mod_t *mod, uint8_t type)
73 {
74 	switch (type) {
75 	case (SMB_MDT_DDR):
76 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_DDR));
77 	case (SMB_MDT_DDR2):
78 	case (SMB_MDT_DDR2FBDIMM):
79 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_DDR2));
80 	case (SMB_MDT_DDR3):
81 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_DDR3));
82 	case (SMB_MDT_DDR4):
83 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_DDR4));
84 	case (SMB_MDT_LPDDR):
85 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_LPDDR));
86 	case (SMB_MDT_LPDDR2):
87 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_LPDDR2));
88 	case (SMB_MDT_LPDDR3):
89 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_LPDDR3));
90 	case (SMB_MDT_LPDDR4):
91 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_LPDDR4));
92 	default:
93 		return (topo_mod_strdup(mod, TOPO_DIMM_TYPE_UNKNOWN));
94 	}
95 }
96 
97 static boolean_t
is_valid_string(const char * str)98 is_valid_string(const char *str)
99 {
100 	if (strcmp(str, SMB_DEFAULT1) != 0 && strcmp(str, SMB_DEFAULT2) != 0 &&
101 	    strcmp(str, SMB_DEFAULT3) != 0 && strlen(str) > 0)
102 		return (B_TRUE);
103 
104 	return (B_FALSE);
105 }
106 
107 static tnode_t *
smbios_make_slot(smb_enum_data_t * smed,smbios_memdevice_t * smb_md)108 smbios_make_slot(smb_enum_data_t *smed, smbios_memdevice_t *smb_md)
109 {
110 	nvlist_t *auth, *fmri;
111 	tnode_t *slotnode;
112 	topo_mod_t *mod = smed->sme_mod;
113 	topo_pgroup_info_t pgi;
114 	int err;
115 
116 	if ((auth = topo_mod_auth(mod, smed->sme_pnode)) == NULL) {
117 		topo_mod_dprintf(mod, "topo_mod_auth() failed: %s",
118 		    topo_mod_errmsg(mod));
119 		/* errno set */
120 		return (NULL);
121 	}
122 
123 	if ((fmri = topo_mod_hcfmri(mod, smed->sme_pnode, FM_HC_SCHEME_VERSION,
124 	    SLOT, smed->sme_slot_inst, NULL, auth, NULL, NULL, NULL)) ==
125 	    NULL) {
126 		nvlist_free(auth);
127 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
128 		    topo_mod_errmsg(mod));
129 		/* errno set */
130 		return (NULL);
131 	}
132 	if ((slotnode = topo_node_bind(mod, smed->sme_pnode, SLOT,
133 	    smed->sme_slot_inst, fmri)) == NULL) {
134 		nvlist_free(auth);
135 		nvlist_free(fmri);
136 		topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
137 		    topo_mod_errmsg(mod));
138 		/* errno set */
139 		return (NULL);
140 	}
141 	nvlist_free(fmri);
142 	fmri = NULL;
143 
144 	/* Create authority and system pgroups */
145 	topo_pgroup_hcset(slotnode, auth);
146 	nvlist_free(auth);
147 
148 	if (topo_node_label_set(slotnode, (char *)smb_md->smbmd_dloc, &err) !=
149 	    0) {
150 		topo_mod_dprintf(mod, "failed to set label on %s=%d: %s",
151 		    SLOT, smed->sme_slot_inst, topo_strerror(err));
152 		(void) topo_mod_seterrno(mod, err);
153 		return (NULL);
154 	}
155 	if (topo_node_fru(smed->sme_pnode, &fmri, NULL, &err) != 0 ||
156 	    topo_node_fru_set(slotnode, fmri, 0, &err) != 0) {
157 		topo_mod_dprintf(mod, "failed to set FRU on %s=%d: %s", SLOT,
158 		    smed->sme_slot_inst, topo_strerror(err));
159 		nvlist_free(fmri);
160 		(void) topo_mod_seterrno(mod, err);
161 		return (NULL);
162 	}
163 	nvlist_free(fmri);
164 
165 	if (topo_method_register(mod, slotnode, slot_methods) != 0) {
166 		topo_mod_dprintf(mod, "topo_method_register() failed on "
167 		    "%s=%d: %s", SLOT, smed->sme_slot_inst,
168 		    topo_mod_errmsg(mod));
169 		/* errno set */
170 		return (NULL);
171 	}
172 
173 	pgi.tpi_name = TOPO_PGROUP_SLOT;
174 	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
175 	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
176 	pgi.tpi_version = TOPO_VERSION;
177 	if (topo_pgroup_create(slotnode, &pgi, &err) != 0 ||
178 	    topo_prop_set_uint32(slotnode, TOPO_PGROUP_SLOT,
179 	    TOPO_PROP_SLOT_TYPE, TOPO_PROP_IMMUTABLE, TOPO_SLOT_TYPE_DIMM,
180 	    &err)) {
181 		topo_mod_dprintf(mod, "failed to create slot properties: %s",
182 		    topo_strerror(err));
183 		(void) topo_mod_seterrno(mod, err);
184 		return (NULL);
185 	}
186 
187 	pgi.tpi_name = TOPO_PGROUP_DIMM_SLOT;
188 	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
189 	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
190 	pgi.tpi_version = TOPO_VERSION;
191 	if (topo_pgroup_create(slotnode, &pgi, &err) != 0 ||
192 	    topo_prop_set_string(slotnode, TOPO_PGROUP_DIMM_SLOT,
193 	    TOPO_PROP_DIMM_SLOT_FORM, TOPO_PROP_IMMUTABLE, smed->sme_slot_form,
194 	    &err)) {
195 		topo_mod_dprintf(mod, "failed to create slot properties: %s",
196 		    topo_strerror(err));
197 		(void) topo_mod_seterrno(mod, err);
198 		return (NULL);
199 	}
200 	return (slotnode);
201 }
202 
203 static tnode_t *
smbios_make_dimm(smb_enum_data_t * smed,smbios_memdevice_t * smb_md)204 smbios_make_dimm(smb_enum_data_t *smed, smbios_memdevice_t *smb_md)
205 {
206 	nvlist_t *auth, *fmri;
207 	smbios_info_t *smb_info = smed->sme_smb_info;
208 	tnode_t *slotnode = smed->sme_slotnode;
209 	tnode_t *dimmnode, *ret = NULL;
210 	topo_mod_t *mod = smed->sme_mod;
211 	topo_pgroup_info_t pgi;
212 	const char *part = NULL, *rev = NULL, *serial = NULL;
213 	char *type, *manuf = NULL, *prod = NULL, *asset = NULL, *loc = NULL;
214 	int err, rc = 0;
215 
216 	if ((auth = topo_mod_auth(mod, slotnode)) == NULL) {
217 		topo_mod_dprintf(mod, "topo_mod_auth() failed: %s",
218 		    topo_mod_errmsg(mod));
219 		/* errno set */
220 		return (NULL);
221 	}
222 
223 	if (smed->sme_smb_info != NULL) {
224 		if (is_valid_string(smb_info->smbi_part) == B_TRUE)
225 			part = smb_info->smbi_part;
226 		if (is_valid_string(smb_info->smbi_version) == B_TRUE)
227 			rev = smb_info->smbi_version;
228 		if (is_valid_string(smb_info->smbi_serial) == B_TRUE)
229 			serial = smb_info->smbi_serial;
230 		if (is_valid_string(smb_info->smbi_manufacturer) == B_TRUE)
231 			manuf = topo_mod_clean_str(mod,
232 			    smb_info->smbi_manufacturer);
233 		if (is_valid_string(smb_info->smbi_product) == B_TRUE)
234 			prod = topo_mod_clean_str(mod, smb_info->smbi_product);
235 		if (is_valid_string(smb_info->smbi_asset) == B_TRUE)
236 			asset = topo_mod_clean_str(mod, smb_info->smbi_asset);
237 		if (is_valid_string(smb_info->smbi_location) == B_TRUE)
238 			loc = topo_mod_clean_str(mod, smb_info->smbi_location);
239 	}
240 
241 	if ((fmri = topo_mod_hcfmri(mod, slotnode, FM_HC_SCHEME_VERSION,
242 	    DIMM, 0, NULL, auth, part, rev, serial)) == NULL) {
243 		nvlist_free(auth);
244 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
245 		    topo_mod_errmsg(mod));
246 		/* errno set */
247 		goto err;
248 	}
249 
250 	if (topo_node_range_create(mod, slotnode, DIMM, 0, 0) < 0 ||
251 	    (dimmnode = topo_node_bind(mod, slotnode, DIMM, 0, fmri)) ==
252 	    NULL) {
253 		nvlist_free(auth);
254 		nvlist_free(fmri);
255 		topo_mod_dprintf(mod, "failed to bind dimm node: %s",
256 		    topo_mod_errmsg(mod));
257 		/* errno set */
258 		goto err;
259 	}
260 
261 	/* Create authority and system pgroups */
262 	topo_pgroup_hcset(dimmnode, auth);
263 	nvlist_free(auth);
264 
265 	if (topo_node_fru_set(dimmnode, fmri, 0, &err) != 0) {
266 		topo_mod_dprintf(mod, "failed to set FRU on %s: %s",
267 		    DIMM, topo_strerror(err));
268 		nvlist_free(fmri);
269 		(void) topo_mod_seterrno(mod, err);
270 		goto err;
271 	}
272 	nvlist_free(fmri);
273 
274 	if (topo_node_label_set(dimmnode, (char *)smb_md->smbmd_dloc, &err) !=
275 	    0) {
276 		topo_mod_dprintf(mod, "failed to set label on %s: %s",
277 		    DIMM, topo_strerror(err));
278 		(void) topo_mod_seterrno(mod, err);
279 		goto err;
280 	}
281 
282 	pgi.tpi_name = TOPO_PGROUP_DIMM_PROPS;
283 	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
284 	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
285 	pgi.tpi_version = TOPO_VERSION;
286 	if (topo_pgroup_create(dimmnode, &pgi, &err) != 0) {
287 		(void) topo_mod_seterrno(mod, err);
288 		goto err;
289 	}
290 
291 	rc += topo_prop_set_uint64(dimmnode, TOPO_PGROUP_DIMM_PROPS, "size",
292 	    TOPO_PROP_IMMUTABLE, smb_md->smbmd_size, &err);
293 	if (rc == 0 && (type = smbios2topotype(mod, smb_md->smbmd_type)) !=
294 	    NULL) {
295 		rc += topo_prop_set_string(dimmnode, TOPO_PGROUP_DIMM_PROPS,
296 		    "type", TOPO_PROP_IMMUTABLE, type, &err);
297 		topo_mod_strfree(mod, type);
298 	}
299 	if (rc == 0 && smb_md->smbmd_set != 0 && smb_md->smbmd_set != 0xFF)
300 		rc += topo_prop_set_uint32(dimmnode, TOPO_PGROUP_DIMM_PROPS,
301 		    "set", TOPO_PROP_IMMUTABLE, smb_md->smbmd_set, &err);
302 	if (rc == 0 && smb_md->smbmd_rank != 0)
303 		rc += topo_prop_set_uint32(dimmnode, TOPO_PGROUP_DIMM_PROPS,
304 		    "rank", TOPO_PROP_IMMUTABLE, smb_md->smbmd_rank, &err);
305 	if (rc == 0 && smb_md->smbmd_clkspeed != 0)
306 		rc += topo_prop_set_uint32(dimmnode, TOPO_PGROUP_DIMM_PROPS,
307 		    "configured-speed", TOPO_PROP_IMMUTABLE,
308 		    smb_md->smbmd_clkspeed, &err);
309 	if (rc == 0 && smb_md->smbmd_speed != 0)
310 		rc += topo_prop_set_uint32(dimmnode, TOPO_PGROUP_DIMM_PROPS,
311 		    "maximum-speed", TOPO_PROP_IMMUTABLE, smb_md->smbmd_speed,
312 		    &err);
313 	if (rc == 0 && smb_md->smbmd_maxvolt != 0)
314 		rc += topo_prop_set_double(dimmnode, TOPO_PGROUP_DIMM_PROPS,
315 		    "maximum-voltage", TOPO_PROP_IMMUTABLE,
316 		    (smb_md->smbmd_maxvolt / 1000), &err);
317 	if (rc == 0 && smb_md->smbmd_minvolt != 0)
318 		rc += topo_prop_set_double(dimmnode, TOPO_PGROUP_DIMM_PROPS,
319 		    "minimum-voltage", TOPO_PROP_IMMUTABLE,
320 		    (smb_md->smbmd_minvolt / 1000), &err);
321 	if (rc == 0 && smb_md->smbmd_confvolt != 0)
322 		rc += topo_prop_set_double(dimmnode, TOPO_PGROUP_DIMM_PROPS,
323 		    "configured-voltage", TOPO_PROP_IMMUTABLE,
324 		    (smb_md->smbmd_confvolt / 1000), &err);
325 	if (rc == 0 && manuf != NULL)
326 		rc += topo_prop_set_string(dimmnode, TOPO_PGROUP_DIMM_PROPS,
327 		    "manufacturer", TOPO_PROP_IMMUTABLE, manuf, &err);
328 	if (rc == 0 && prod != NULL)
329 		rc += topo_prop_set_string(dimmnode, TOPO_PGROUP_DIMM_PROPS,
330 		    "product", TOPO_PROP_IMMUTABLE, prod, &err);
331 	if (rc == 0 && asset != NULL)
332 		rc += topo_prop_set_string(dimmnode, TOPO_PGROUP_DIMM_PROPS,
333 		    "asset-tag", TOPO_PROP_IMMUTABLE, asset, &err);
334 	if (rc == 0 && loc != NULL)
335 		rc += topo_prop_set_string(dimmnode, TOPO_PGROUP_DIMM_PROPS,
336 		    "location", TOPO_PROP_IMMUTABLE, loc, &err);
337 
338 	if (rc != 0) {
339 		topo_mod_dprintf(mod, "error setting properties on %s node",
340 		    DIMM);
341 		(void) topo_mod_seterrno(mod, err);
342 		goto err;
343 	}
344 	ret = dimmnode;
345 err:
346 	topo_mod_strfree(mod, manuf);
347 	topo_mod_strfree(mod, prod);
348 	topo_mod_strfree(mod, asset);
349 	topo_mod_strfree(mod, loc);
350 	return (ret);
351 }
352 
353 static int
smbios_enum_memory(smbios_hdl_t * shp,const smbios_struct_t * sp,void * arg)354 smbios_enum_memory(smbios_hdl_t *shp, const smbios_struct_t *sp, void *arg)
355 {
356 	smbios_info_t smb_info;
357 	smbios_memdevice_t smb_md;
358 	smb_enum_data_t *smed = arg;
359 	topo_mod_t *mod = smed->sme_mod;
360 	tnode_t *slotnode;
361 
362 	if (sp->smbstr_type != SMB_TYPE_MEMDEVICE)
363 		return (0);
364 
365 	if (smbios_info_memdevice(shp, sp->smbstr_id, &smb_md) != 0) {
366 		topo_mod_dprintf(mod, "libsmbios error");
367 		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
368 	}
369 
370 	/*
371 	 * SMB_TYPE_MEMDEVICE records can also be used to represent memory
372 	 * that come in non-DIMM form factors. If we encounter something like
373 	 * that, then we skip over it.
374 	 */
375 	if ((smed->sme_slot_form = distill_dimm_form(mod, &smb_md)) == NULL)
376 		return (0);
377 
378 	if ((slotnode = smbios_make_slot(smed, &smb_md)) == NULL) {
379 		topo_mod_dprintf(mod, "failed to create %s node", SLOT);
380 		topo_mod_strfree(mod, smed->sme_slot_form);
381 		/* errno set */
382 		return (-1);
383 	}
384 	topo_mod_strfree(mod, smed->sme_slot_form);
385 	smed->sme_slotnode = slotnode;
386 
387 	/*
388 	 * A size of zero indicates that the DIMM slot is not populated, so
389 	 * we skip creating a child dimm node and return.
390 	 */
391 	if (smb_md.smbmd_size == 0) {
392 		smed->sme_slot_inst++;
393 		return (0);
394 	}
395 
396 	if (smbios_info_common(shp, sp->smbstr_id, &smb_info) == 0)
397 		smed->sme_smb_info = &smb_info;
398 
399 	if (smbios_make_dimm(smed, &smb_md) == NULL) {
400 		topo_mod_dprintf(mod, "failed to create %s node", DIMM);
401 		/* errno set */
402 		return (-1);
403 	}
404 	/*
405 	 * If we've exceeded our max inst then return non-zero to cause
406 	 * the walk to terminate.
407 	 */
408 	if (++smed->sme_slot_inst > smed->sme_slot_maxinst)
409 		return (1);
410 
411 	return (0);
412 }
413 
414 static int
smbios_enum_motherboard(smbios_hdl_t * shp,smb_enum_data_t * smed)415 smbios_enum_motherboard(smbios_hdl_t *shp, smb_enum_data_t *smed)
416 {
417 	smbios_struct_t sp;
418 	smbios_bboard_t smb_mb;
419 	smbios_bios_t smb_bios;
420 	smbios_info_t smb_info;
421 	const char *part = NULL, *rev = NULL, *serial = NULL;
422 	char *manuf = NULL, *prod = NULL, *asset = NULL;
423 	char *bios_vendor = NULL, *bios_rev = NULL, *bios_reldate = NULL;
424 	nvlist_t *auth, *fmri;
425 	topo_mod_t *mod = smed->sme_mod;
426 	tnode_t *mbnode;
427 	topo_pgroup_info_t pgi;
428 	int rc = 0, err;
429 
430 	if (smbios_lookup_type(shp, SMB_TYPE_BASEBOARD, &sp) == 0 &&
431 	    smbios_info_bboard(shp, sp.smbstr_id, &smb_mb) == 0 &&
432 	    smbios_info_common(shp, sp.smbstr_id, &smb_info) == 0) {
433 		if (is_valid_string(smb_info.smbi_part) == B_TRUE)
434 			part = smb_info.smbi_part;
435 		if (is_valid_string(smb_info.smbi_version) == B_TRUE)
436 			rev = smb_info.smbi_version;
437 		if (is_valid_string(smb_info.smbi_serial) == B_TRUE)
438 			serial = smb_info.smbi_serial;
439 		if (is_valid_string(smb_info.smbi_manufacturer) == B_TRUE)
440 			manuf = topo_mod_clean_str(mod,
441 			    smb_info.smbi_manufacturer);
442 		if (is_valid_string(smb_info.smbi_product) == B_TRUE)
443 			prod = topo_mod_clean_str(mod, smb_info.smbi_product);
444 		if (is_valid_string(smb_info.smbi_asset) == B_TRUE)
445 			asset = topo_mod_clean_str(mod, smb_info.smbi_asset);
446 	}
447 	if (smbios_lookup_type(shp, SMB_TYPE_BIOS, &sp) == 0 &&
448 	    smbios_info_bios(shp, &smb_bios) == 0) {
449 		if (is_valid_string(smb_bios.smbb_vendor) == B_TRUE)
450 			bios_vendor = topo_mod_clean_str(mod,
451 			    smb_bios.smbb_vendor);
452 		if (is_valid_string(smb_bios.smbb_version) == B_TRUE)
453 			bios_rev = topo_mod_clean_str(mod,
454 			    smb_bios.smbb_version);
455 		if (is_valid_string(smb_bios.smbb_reldate) == B_TRUE)
456 			bios_reldate = topo_mod_clean_str(mod,
457 			    smb_bios.smbb_reldate);
458 	}
459 	if ((auth = topo_mod_auth(mod, smed->sme_pnode)) == NULL) {
460 		topo_mod_dprintf(mod, "topo_mod_auth() failed: %s",
461 		    topo_mod_errmsg(mod));
462 		/* errno set */
463 		goto err;
464 	}
465 
466 	if ((fmri = topo_mod_hcfmri(mod, NULL, FM_HC_SCHEME_VERSION,
467 	    MOTHERBOARD, 0, NULL, auth, part, rev, serial)) ==
468 	    NULL) {
469 		nvlist_free(auth);
470 		topo_mod_dprintf(mod, "topo_mod_hcfmri() failed: %s",
471 		    topo_mod_errmsg(mod));
472 		/* errno set */
473 		goto err;
474 	}
475 
476 	if ((mbnode = topo_node_bind(mod, smed->sme_pnode, MOTHERBOARD, 0,
477 	    fmri)) == NULL) {
478 		nvlist_free(auth);
479 		nvlist_free(fmri);
480 		topo_mod_dprintf(mod, "topo_node_bind() failed: %s",
481 		    topo_mod_errmsg(mod));
482 		/* errno set */
483 		goto err;
484 	}
485 
486 	/* Create authority and system pgroups */
487 	topo_pgroup_hcset(mbnode, auth);
488 	nvlist_free(auth);
489 
490 	if (topo_node_fru_set(mbnode, fmri, 0, &err) != 0) {
491 		topo_mod_dprintf(mod, "failed to set FRU on %s: %s",
492 		    MOTHERBOARD, topo_strerror(err));
493 		nvlist_free(fmri);
494 		(void) topo_mod_seterrno(mod, err);
495 		goto err;
496 	}
497 	nvlist_free(fmri);
498 	fmri = NULL;
499 
500 	if (topo_node_label_set(mbnode, "MB", &err) != 0) {
501 		topo_mod_dprintf(mod, "failed to set label on %s: %s",
502 		    MOTHERBOARD, topo_strerror(err));
503 		(void) topo_mod_seterrno(mod, err);
504 		goto err;
505 	}
506 
507 	pgi.tpi_name = TOPO_PGROUP_MOTHERBOARD;
508 	pgi.tpi_namestab = TOPO_STABILITY_PRIVATE;
509 	pgi.tpi_datastab = TOPO_STABILITY_PRIVATE;
510 	pgi.tpi_version = TOPO_VERSION;
511 	rc = topo_pgroup_create(mbnode, &pgi, &err);
512 
513 	if (rc == 0 && manuf != NULL)
514 		rc += topo_prop_set_string(mbnode, TOPO_PGROUP_MOTHERBOARD,
515 		    TOPO_PROP_MB_MANUFACTURER, TOPO_PROP_IMMUTABLE, manuf,
516 		    &err);
517 	if (rc == 0 && prod != NULL)
518 		rc += topo_prop_set_string(mbnode, TOPO_PGROUP_MOTHERBOARD,
519 		    TOPO_PROP_MB_PRODUCT, TOPO_PROP_IMMUTABLE, prod, &err);
520 	if (rc == 0 && asset != NULL)
521 		rc += topo_prop_set_string(mbnode, TOPO_PGROUP_MOTHERBOARD,
522 		    TOPO_PROP_MB_ASSET, TOPO_PROP_IMMUTABLE, asset, &err);
523 
524 	if (rc != 0) {
525 		topo_mod_dprintf(mod, "error setting properties on %s node",
526 		    MOTHERBOARD);
527 		(void) topo_mod_seterrno(mod, err);
528 		goto err;
529 	}
530 	/*
531 	 * If we were able to gleen the BIOS version from SMBIOS, then set
532 	 * up a UFM node to capture that information.
533 	 */
534 	if (bios_rev != NULL) {
535 		topo_ufm_slot_info_t slotinfo = { 0 };
536 		nvlist_t *extra;
537 
538 		slotinfo.usi_version = bios_rev;
539 		slotinfo.usi_active = B_TRUE;
540 		slotinfo.usi_mode = TOPO_UFM_SLOT_MODE_NONE;
541 
542 		if (bios_vendor != NULL || bios_reldate != NULL) {
543 			if (nvlist_alloc(&extra, NV_UNIQUE_NAME, 0) != 0) {
544 				goto err;
545 			}
546 			if (bios_vendor != NULL && nvlist_add_string(extra,
547 			    TOPO_PROP_MB_FIRMWARE_VENDOR, bios_vendor) != 0) {
548 				nvlist_free(extra);
549 				goto err;
550 			}
551 			if (bios_reldate != NULL && nvlist_add_string(extra,
552 			    TOPO_PROP_MB_FIRMWARE_RELDATE, bios_reldate) !=
553 			    0) {
554 				nvlist_free(extra);
555 				goto err;
556 			}
557 			slotinfo.usi_extra = extra;
558 		}
559 		if (topo_node_range_create(mod, mbnode, UFM, 0, 0) != 0) {
560 			topo_mod_dprintf(mod, "failed to create %s range",
561 			    UFM);
562 			nvlist_free(extra);
563 			goto err;
564 		}
565 		(void) topo_mod_create_ufm(mod, mbnode, "BIOS", &slotinfo);
566 		nvlist_free(extra);
567 	}
568 
569 err:
570 	topo_mod_strfree(mod, manuf);
571 	topo_mod_strfree(mod, prod);
572 	topo_mod_strfree(mod, asset);
573 	topo_mod_strfree(mod, bios_vendor);
574 	topo_mod_strfree(mod, bios_rev);
575 	topo_mod_strfree(mod, bios_reldate);
576 
577 	return (0);
578 }
579 
580 /*
581  * A system with a functional memory controller driver will have one mc device
582  * node per chip instance, starting at instance 0.  The driver provides an
583  * ioctl interface for retrieving a snapshot of the system's memory topology.
584  * If we're able to issue this ioctl on one of the mc device nodes then we'll
585  * return B_TRUE, indicating that this system has a minimally functional memory
586  * controller driver.
587  */
588 static boolean_t
has_mc_driver()589 has_mc_driver()
590 {
591 #ifdef	__x86
592 	int mc_fd;
593 	mc_snapshot_info_t mcs;
594 
595 	if ((mc_fd = open("/dev/mc/mc0", O_RDONLY)) < 0)
596 		return (B_FALSE);
597 
598 	if (ioctl(mc_fd, MC_IOC_SNAPSHOT_INFO, &mcs) < 0) {
599 		(void) close(mc_fd);
600 		return (B_FALSE);
601 	}
602 	(void) close(mc_fd);
603 	return (B_TRUE);
604 #else
605 	return (B_TRUE);
606 #endif
607 }
608 
609 /*ARGSUSED*/
610 static int
smbios_enum(topo_mod_t * mod,tnode_t * rnode,const char * name,topo_instance_t min,topo_instance_t max,void * arg,void * unused)611 smbios_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
612     topo_instance_t min, topo_instance_t max, void *arg, void *unused)
613 {
614 	smbios_hdl_t *smbh;
615 	smb_enum_data_t smed = { 0 };
616 
617 	if ((smbh = topo_mod_smbios(mod)) == NULL) {
618 		topo_mod_dprintf(mod, "failed to get libsmbios handle");
619 		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
620 	}
621 	smed.sme_mod = mod;
622 	smed.sme_pnode = rnode;
623 	smed.sme_slot_inst = min;
624 	smed.sme_slot_maxinst = max;
625 
626 	/*
627 	 * Currently we only support enumerating dimm-slot and dimm nodes, but
628 	 * this module could be expanded in the future to enumerate other
629 	 * hardware components from SMBIOS.
630 	 */
631 	if (strcmp(name, SLOT) == 0) {
632 		/*
633 		 * If the system has a functional memory controller driver then
634 		 * we'll assume that it has responsibility for enumerating the
635 		 * memory topology.
636 		 */
637 		if (has_mc_driver() == B_TRUE)
638 			return (0);
639 		if (smbios_iter(smbh, smbios_enum_memory, &smed) < 0)
640 			/* errno set */
641 			return (-1);
642 	} else if (strcmp(name, MOTHERBOARD) == 0) {
643 		if (smbios_enum_motherboard(smbh, &smed) < 0)
644 			/* errno set */
645 			return (-1);
646 	} else {
647 		topo_mod_dprintf(mod, "smbios_enum() invoked for unsupported "
648 		    "node type: %s", name);
649 		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
650 	}
651 	return (0);
652 }
653 
654 const topo_modops_t smbios_ops = { smbios_enum, NULL };
655 
656 const topo_modinfo_t smbios_info =
657 	{ "smbios", FM_FMRI_SCHEME_HC, TOPO_VERSION, &smbios_ops };
658 
659 /*ARGSUSED*/
660 int
_topo_init(topo_mod_t * mod,topo_version_t version)661 _topo_init(topo_mod_t *mod, topo_version_t version)
662 {
663 	if (getenv("TOPOSMBIOSDEBUG") != NULL)
664 		topo_mod_setdebug(mod);
665 
666 	if (topo_mod_register(mod, &smbios_info, TOPO_VERSION) != 0) {
667 		topo_mod_dprintf(mod, "module registration failed: %s\n",
668 		    topo_mod_errmsg(mod));
669 		/* errno set */
670 		return (-1);
671 	}
672 
673 	topo_mod_dprintf(mod, "SMBIOS enumerator initialized\n");
674 	return (0);
675 }
676 
677 void
_topo_fini(topo_mod_t * mod)678 _topo_fini(topo_mod_t *mod)
679 {
680 	topo_mod_unregister(mod);
681 }
682