xref: /illumos-gate/usr/src/common/smbios/smb_info.c (revision d53cdfab)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2015 OmniTI Computer Consulting, Inc.  All rights reserved.
24  * Copyright 2019 Joyent, Inc.
25  * Copyright 2021 Oxide Computer Company
26  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 /*
31  * SMBIOS Information Routines
32  *
33  * The routines in this file are used to convert from the SMBIOS data format to
34  * a more reasonable and stable set of structures offered as part of our ABI.
35  * These functions take the general form:
36  *
37  *	stp = smb_lookup_type(shp, foo);
38  *	smb_foo_t foo;
39  *
40  *	smb_info_bcopy(stp->smbst_hdr, &foo, sizeof (foo));
41  *      bzero(caller's struct);
42  *
43  *	copy/convert foo members into caller's struct
44  *
45  * We copy the internal structure on to an automatic variable so as to avoid
46  * checks everywhere for structures that the BIOS has improperly truncated, and
47  * also to automatically handle the case of a structure that has been extended.
48  * When necessary, this code can use smb_gteq() to determine whether the SMBIOS
49  * data is of a particular revision that is supposed to contain a new field.
50  *
51  * Note, when trying to bzero the caller's struct you have to be careful about
52  * versions. One can only bzero the initial version that existed in illumos. In
53  * other words, if someone passes an older library handle that doesn't support a
54  * version you cannot assume that their structures have those additional members
55  * in them. Instead, a 'base' version is introduced for such types that have
56  * differences and instead we only bzero out the base version and then handle
57  * the additional members. In general, because all additional members will be
58  * assigned, there's no reason to zero them out unless they are arrays that
59  * won't be entirely filled in.
60  *
61  * Due to history, anything added after the update from version 2.4, in other
62  * words additions from or after '5094 Update libsmbios with recent items'
63  * (4e901881) is currently being used for this. While we don't allow software
64  * compiling against this to get an older form, this was the first major update
65  * and a good starting point for us to enforce this behavior which is useful for
66  * moving forward to making this more public.
67  */
68 
69 #include <sys/smbios_impl.h>
70 #include <sys/byteorder.h>
71 #include <sys/debug.h>
72 
73 #ifdef _KERNEL
74 #include <sys/sunddi.h>
75 #else
76 #include <fcntl.h>
77 #include <unistd.h>
78 #include <string.h>
79 #endif
80 
81 #define	SMB_CONT_WORD	2		/* contained elements are word size */
82 
83 /*
84  * A large number of SMBIOS structures contain a set of common strings used to
85  * describe a h/w component's serial number, manufacturer, etc.  These fields
86  * helpfully have different names and offsets and sometimes aren't consistent.
87  * To simplify life for our clients, we factor these common things out into
88  * smbios_info_t, which can be retrieved for any structure.  The following
89  * table describes the mapping from a given structure to the smbios_info_t.
90  * Multiple SMBIOS stuctures' contained objects are also handled here.
91  */
92 static const struct smb_infospec {
93 	uint8_t is_type;		/* structure type */
94 	uint8_t is_manu;		/* manufacturer offset */
95 	uint8_t is_product;		/* product name offset */
96 	uint8_t is_version;		/* version offset */
97 	uint8_t is_serial;		/* serial number offset */
98 	uint8_t is_asset;		/* asset tag offset */
99 	uint8_t is_location;		/* location string offset */
100 	uint8_t is_part;		/* part number offset */
101 	uint8_t is_contc;		/* contained count */
102 	uint8_t is_contsz;		/* contained size */
103 	uint8_t is_contv;		/* contained objects */
104 } _smb_infospecs[] = {
105 	{ SMB_TYPE_SYSTEM,
106 		offsetof(smb_system_t, smbsi_manufacturer),
107 		offsetof(smb_system_t, smbsi_product),
108 		offsetof(smb_system_t, smbsi_version),
109 		offsetof(smb_system_t, smbsi_serial),
110 		0,
111 		0,
112 		0,
113 		0,
114 		0,
115 		0 },
116 	{ SMB_TYPE_BASEBOARD,
117 		offsetof(smb_bboard_t, smbbb_manufacturer),
118 		offsetof(smb_bboard_t, smbbb_product),
119 		offsetof(smb_bboard_t, smbbb_version),
120 		offsetof(smb_bboard_t, smbbb_serial),
121 		offsetof(smb_bboard_t, smbbb_asset),
122 		offsetof(smb_bboard_t, smbbb_location),
123 		0,
124 		offsetof(smb_bboard_t, smbbb_cn),
125 		SMB_CONT_WORD,
126 		offsetof(smb_bboard_t, smbbb_cv) },
127 	{ SMB_TYPE_CHASSIS,
128 		offsetof(smb_chassis_t, smbch_manufacturer),
129 		0,
130 		offsetof(smb_chassis_t, smbch_version),
131 		offsetof(smb_chassis_t, smbch_serial),
132 		offsetof(smb_chassis_t, smbch_asset),
133 		0,
134 		0,
135 		0,
136 		0,
137 		0 },
138 	{ SMB_TYPE_PROCESSOR,
139 		offsetof(smb_processor_t, smbpr_manufacturer),
140 		0,
141 		offsetof(smb_processor_t, smbpr_version),
142 		offsetof(smb_processor_t, smbpr_serial),
143 		offsetof(smb_processor_t, smbpr_asset),
144 		offsetof(smb_processor_t, smbpr_socket),
145 		offsetof(smb_processor_t, smbpr_part),
146 		0,
147 		0,
148 		0 },
149 	{ SMB_TYPE_CACHE,
150 		0,
151 		0,
152 		0,
153 		0,
154 		0,
155 		offsetof(smb_cache_t, smbca_socket),
156 		0,
157 		0,
158 		0,
159 		0 },
160 	{ SMB_TYPE_PORT,
161 		0,
162 		0,
163 		0,
164 		0,
165 		0,
166 		offsetof(smb_port_t, smbpo_iref),
167 		0,
168 		0,
169 		0,
170 		0 },
171 	{ SMB_TYPE_SLOT,
172 		0,
173 		0,
174 		0,
175 		0,
176 		0,
177 		offsetof(smb_slot_t, smbsl_name),
178 		0,
179 		0,
180 		0,
181 		0 },
182 	{ SMB_TYPE_MEMDEVICE,
183 		offsetof(smb_memdevice_t, smbmdev_manufacturer),
184 		0,
185 		0,
186 		offsetof(smb_memdevice_t, smbmdev_serial),
187 		offsetof(smb_memdevice_t, smbmdev_asset),
188 		offsetof(smb_memdevice_t, smbmdev_dloc),
189 		offsetof(smb_memdevice_t, smbmdev_part),
190 		0,
191 		0,
192 		0 },
193 	{ SMB_TYPE_POWERSUP,
194 		offsetof(smb_powersup_t, smbpsup_manufacturer),
195 		offsetof(smb_powersup_t, smbpsup_devname),
196 		offsetof(smb_powersup_t, smbpsup_rev),
197 		offsetof(smb_powersup_t, smbpsup_serial),
198 		offsetof(smb_powersup_t, smbpsup_asset),
199 		offsetof(smb_powersup_t, smbpsup_loc),
200 		offsetof(smb_powersup_t, smbpsup_part),
201 		0,
202 		0,
203 		0 },
204 	{ SMB_TYPE_BATTERY,
205 		offsetof(smb_battery_t, smbbat_manufacturer),
206 		offsetof(smb_battery_t, smbbat_devname),
207 		0,
208 		/*
209 		 * While the serial number is a part of the device, because of
210 		 * the fact that the battery has two different serial numbers,
211 		 * we don't include it here.
212 		 */
213 		0,
214 		0,
215 		offsetof(smb_battery_t, smbbat_loc),
216 		0,
217 		0,
218 		0,
219 		0
220 	},
221 	{ SMB_TYPE_FWINFO,
222 		offsetof(smb_fwinfo_t, smbfwii_mfg),
223 		0,
224 		offsetof(smb_fwinfo_t, smbfwii_vers),
225 		0,
226 		0,
227 		0,
228 		0,
229 		0,
230 		0,
231 		0
232 	},
233 	{ SMB_TYPE_EOT }
234 };
235 
236 static const char *
smb_info_strptr(const smb_struct_t * stp,uint8_t off,int * n)237 smb_info_strptr(const smb_struct_t *stp, uint8_t off, int *n)
238 {
239 	const uint8_t *sp = (const uint8_t *)(uintptr_t)stp->smbst_hdr;
240 
241 	if (off != 0 && sp + off < stp->smbst_end) {
242 		(*n)++; /* indicate success for caller */
243 		return (smb_strptr(stp, sp[off]));
244 	}
245 
246 	return (smb_strptr(stp, 0));
247 }
248 
249 static void
smb_info_bcopy_offset(const smb_header_t * hp,void * dst,size_t dstlen,size_t offset)250 smb_info_bcopy_offset(const smb_header_t *hp, void *dst, size_t dstlen,
251     size_t offset)
252 {
253 	if (offset >= hp->smbh_len) {
254 		bzero(dst, dstlen);
255 	} else if (offset + dstlen > hp->smbh_len) {
256 		size_t nvalid = MIN(hp->smbh_len - offset, dstlen);
257 		bcopy((char *)hp + offset, dst, nvalid);
258 		bzero((char *)dst + nvalid, dstlen - nvalid);
259 	} else {
260 		bcopy((char *)hp + offset, dst, dstlen);
261 	}
262 }
263 
264 static void
smb_info_bcopy(const smb_header_t * hp,void * dst,size_t dstlen)265 smb_info_bcopy(const smb_header_t *hp, void *dst, size_t dstlen)
266 {
267 	return (smb_info_bcopy_offset(hp, dst, dstlen, 0));
268 }
269 
270 smbios_entry_point_t
smbios_info_smbios(smbios_hdl_t * shp,smbios_entry_t * ep)271 smbios_info_smbios(smbios_hdl_t *shp, smbios_entry_t *ep)
272 {
273 	bcopy(&shp->sh_ent, ep, sizeof (smbios_entry_t));
274 	return (shp->sh_ent_type);
275 }
276 
277 void
smbios_info_smbios_version(smbios_hdl_t * shp,smbios_version_t * v)278 smbios_info_smbios_version(smbios_hdl_t *shp, smbios_version_t *v)
279 {
280 	v->smbv_major = SMB_MAJOR(shp->sh_smbvers);
281 	v->smbv_minor = SMB_MINOR(shp->sh_smbvers);
282 }
283 
284 #ifndef _KERNEL
285 static char smbios_product_override[256];
286 static boolean_t smbios_product_checked;
287 #endif
288 
289 int
smbios_info_common(smbios_hdl_t * shp,id_t id,smbios_info_t * ip)290 smbios_info_common(smbios_hdl_t *shp, id_t id, smbios_info_t *ip)
291 {
292 	const smb_struct_t *stp = smb_lookup_id(shp, id);
293 	const struct smb_infospec *isp;
294 	int n = 0;
295 
296 	if (stp == NULL)
297 		return (-1); /* errno is set for us */
298 
299 	for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) {
300 		if (isp->is_type == stp->smbst_hdr->smbh_type)
301 			break;
302 	}
303 
304 	ip->smbi_manufacturer = smb_info_strptr(stp, isp->is_manu, &n);
305 	ip->smbi_product = smb_info_strptr(stp, isp->is_product, &n);
306 	ip->smbi_version = smb_info_strptr(stp, isp->is_version, &n);
307 	ip->smbi_serial = smb_info_strptr(stp, isp->is_serial, &n);
308 	ip->smbi_asset = smb_info_strptr(stp, isp->is_asset, &n);
309 	ip->smbi_location = smb_info_strptr(stp, isp->is_location, &n);
310 	ip->smbi_part = smb_info_strptr(stp, isp->is_part, &n);
311 
312 	/*
313 	 * This private file allows developers to experiment with reporting
314 	 * different platform strings from SMBIOS.  It is not a supported
315 	 * mechanism in the long term, and does not work in the kernel.
316 	 */
317 #ifndef _KERNEL
318 	if (isp->is_type == SMB_TYPE_SYSTEM) {
319 		if (!smbios_product_checked) {
320 			int fd = open("/etc/smbios_product", O_RDONLY);
321 			if (fd >= 0) {
322 				(void) read(fd, smbios_product_override,
323 				    sizeof (smbios_product_override) - 1);
324 				(void) close(fd);
325 			}
326 			smbios_product_checked = B_TRUE;
327 		}
328 
329 		if (smbios_product_override[0] != '\0')
330 			ip->smbi_product = smbios_product_override;
331 	}
332 #endif
333 
334 	/*
335 	 * If we have a port with an empty internal reference designator string
336 	 * try using the external reference designator string instead.
337 	 */
338 	if (isp->is_type == SMB_TYPE_PORT && ip->smbi_location[0] == '\0') {
339 		ip->smbi_location = smb_info_strptr(stp,
340 		    offsetof(smb_port_t, smbpo_eref), &n);
341 	}
342 
343 	return (n ? 0 : smb_set_errno(shp, ESMB_NOINFO));
344 }
345 
346 /*
347  * Returns the actual number of contained objects.
348  *
349  * idc - number of contained objects
350  * idv - returned array of contained objects
351  */
352 int
smbios_info_contains(smbios_hdl_t * shp,id_t id,uint_t idc,id_t * idv)353 smbios_info_contains(smbios_hdl_t *shp, id_t id, uint_t idc, id_t *idv)
354 {
355 	const smb_struct_t *stp = smb_lookup_id(shp, id);
356 	const struct smb_infospec *isp;
357 	id_t *cp;
358 	uint_t size;
359 	uint8_t cnt;
360 	int i, n;
361 
362 	if (stp == NULL) {
363 		return (-1); /* errno is set for us */
364 	}
365 
366 	for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) {
367 		if (isp->is_type == stp->smbst_hdr->smbh_type)
368 			break;
369 	}
370 	if (isp->is_type == SMB_TYPE_EOT)
371 		return (smb_set_errno(shp, ESMB_TYPE));
372 
373 	size = isp->is_contsz;
374 	cnt = *((uint8_t *)(uintptr_t)stp->smbst_hdr + isp->is_contc);
375 	cp = (id_t *)((uintptr_t)stp->smbst_hdr + isp->is_contv);
376 
377 	n = MIN(cnt, idc);
378 	for (i = 0; i < n; i++) {
379 		if (size == SMB_CONT_WORD)
380 			idv[i] = *((uint16_t *)(uintptr_t)cp + (i * 2));
381 		else
382 			return (smb_set_errno(shp, ESMB_INVAL));
383 	}
384 
385 	return (cnt);
386 }
387 
388 id_t
smbios_info_bios(smbios_hdl_t * shp,smbios_bios_t * bp)389 smbios_info_bios(smbios_hdl_t *shp, smbios_bios_t *bp)
390 {
391 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BIOS);
392 	const smb_bios_t *bip;
393 
394 	if (stp == NULL)
395 		return (-1); /* errno is set for us */
396 
397 	if (stp->smbst_hdr->smbh_len < sizeof (smb_bios_t) - sizeof (uint8_t))
398 		return (smb_set_errno(shp, ESMB_CORRUPT));
399 
400 	bip = (smb_bios_t *)(uintptr_t)stp->smbst_hdr;
401 	bzero(bp, sizeof (smb_base_bios_t));
402 	if (smb_libgteq(shp, SMB_VERSION_31)) {
403 		bp->smbb_extromsize = 0;
404 	}
405 
406 	bp->smbb_vendor = smb_strptr(stp, bip->smbbi_vendor);
407 	bp->smbb_version = smb_strptr(stp, bip->smbbi_version);
408 	bp->smbb_segment = bip->smbbi_segment;
409 	bp->smbb_reldate = smb_strptr(stp, bip->smbbi_reldate);
410 	bp->smbb_romsize = 64 * 1024 * ((uint32_t)bip->smbbi_romsize + 1);
411 	bp->smbb_runsize = 16 * (0x10000 - (uint32_t)bip->smbbi_segment);
412 	bp->smbb_cflags = bip->smbbi_cflags;
413 
414 	/*
415 	 * If one or more extension bytes are present, reset smbb_xcflags to
416 	 * point to them.  Otherwise leave this member set to NULL.
417 	 */
418 	if (stp->smbst_hdr->smbh_len >= sizeof (smb_bios_t)) {
419 		bp->smbb_xcflags = bip->smbbi_xcflags;
420 		bp->smbb_nxcflags = stp->smbst_hdr->smbh_len -
421 		    sizeof (smb_bios_t) + 1;
422 
423 		if (bp->smbb_nxcflags > SMB_BIOSXB_ECFW_MIN &&
424 		    smb_gteq(shp, SMB_VERSION_24)) {
425 			bp->smbb_biosv.smbv_major =
426 			    bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MAJ];
427 			bp->smbb_biosv.smbv_minor =
428 			    bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MIN];
429 			bp->smbb_ecfwv.smbv_major =
430 			    bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MAJ];
431 			bp->smbb_ecfwv.smbv_minor =
432 			    bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MIN];
433 		}
434 
435 		if (bp->smbb_nxcflags > SMB_BIOSXB_EXTROM + 1 &&
436 		    smb_gteq(shp, SMB_VERSION_31)) {
437 			uint16_t val;
438 			uint64_t rs;
439 
440 			/*
441 			 * Because of the fact that the extended size is a
442 			 * uint16_t and we'd need to define an explicit
443 			 * endian-aware way to access it, we don't include it in
444 			 * the number of extended flags below and thus subtract
445 			 * its size.
446 			 */
447 			bp->smbb_nxcflags -= sizeof (uint16_t);
448 			bcopy(&bip->smbbi_xcflags[SMB_BIOSXB_EXTROM], &val,
449 			    sizeof (val));
450 			val = LE_16(val);
451 
452 			/*
453 			 * The upper two bits of the extended rom size are used
454 			 * to indicate whether the other 14 bits are in MB or
455 			 * GB.
456 			 */
457 			rs = SMB_BIOS_EXTROM_VALUE_MASK(val);
458 			switch (SMB_BIOS_EXTROM_SHIFT_MASK(val)) {
459 			case 0:
460 				rs *= 1024ULL * 1024ULL;
461 				break;
462 			case 1:
463 				rs *= 1024ULL * 1024ULL * 1024ULL;
464 				break;
465 			default:
466 				rs = 0;
467 				break;
468 			}
469 
470 			if (smb_libgteq(shp, SMB_VERSION_31)) {
471 				bp->smbb_extromsize = rs;
472 			}
473 		}
474 	}
475 
476 	if (smb_libgteq(shp, SMB_VERSION_31) && bp->smbb_extromsize == 0) {
477 		bp->smbb_extromsize = bp->smbb_romsize;
478 	}
479 
480 	return (stp->smbst_hdr->smbh_hdl);
481 }
482 
483 id_t
smbios_info_system(smbios_hdl_t * shp,smbios_system_t * sip)484 smbios_info_system(smbios_hdl_t *shp, smbios_system_t *sip)
485 {
486 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM);
487 	smb_system_t si;
488 
489 	if (stp == NULL)
490 		return (-1); /* errno is set for us */
491 
492 	smb_info_bcopy(stp->smbst_hdr, &si, sizeof (si));
493 	bzero(sip, sizeof (smbios_system_t));
494 
495 	sip->smbs_uuid = ((smb_system_t *)stp->smbst_hdr)->smbsi_uuid;
496 	sip->smbs_uuidlen = sizeof (si.smbsi_uuid);
497 	sip->smbs_wakeup = si.smbsi_wakeup;
498 	sip->smbs_sku = smb_strptr(stp, si.smbsi_sku);
499 	sip->smbs_family = smb_strptr(stp, si.smbsi_family);
500 
501 	return (stp->smbst_hdr->smbh_hdl);
502 }
503 
504 int
smbios_info_bboard(smbios_hdl_t * shp,id_t id,smbios_bboard_t * bbp)505 smbios_info_bboard(smbios_hdl_t *shp, id_t id, smbios_bboard_t *bbp)
506 {
507 	const smb_struct_t *stp = smb_lookup_id(shp, id);
508 	smb_bboard_t bb;
509 
510 	if (stp == NULL)
511 		return (-1); /* errno is set for us */
512 
513 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_BASEBOARD)
514 		return (smb_set_errno(shp, ESMB_TYPE));
515 
516 	smb_info_bcopy(stp->smbst_hdr, &bb, sizeof (bb));
517 	bzero(bbp, sizeof (smbios_bboard_t));
518 
519 	bbp->smbb_chassis = bb.smbbb_chassis;
520 	bbp->smbb_flags = bb.smbbb_flags;
521 	bbp->smbb_type = bb.smbbb_type;
522 	bbp->smbb_contn = bb.smbbb_cn;
523 
524 	return (0);
525 }
526 
527 int
smbios_info_chassis(smbios_hdl_t * shp,id_t id,smbios_chassis_t * chp)528 smbios_info_chassis(smbios_hdl_t *shp, id_t id, smbios_chassis_t *chp)
529 {
530 	const smb_struct_t *stp = smb_lookup_id(shp, id);
531 	smb_chassis_t ch;
532 
533 	if (stp == NULL) {
534 		return (-1); /* errno is set for us */
535 	}
536 
537 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_CHASSIS) {
538 		return (smb_set_errno(shp, ESMB_TYPE));
539 	}
540 
541 	if (stp->smbst_hdr->smbh_len < sizeof (ch)) {
542 		return (smb_set_errno(shp, ESMB_SHORT));
543 	}
544 
545 	smb_info_bcopy(stp->smbst_hdr, &ch, sizeof (ch));
546 	bzero(chp, sizeof (smb_base_chassis_t));
547 
548 	/*
549 	 * See the comments for the smb_chassis_pre35_t in sys/smbios_impl.h for
550 	 * an explanation as to why this is here. The use of smb_strptr with
551 	 * index 0 below ensures that we initialize this to an empty string.
552 	 */
553 	if (smb_libgteq(shp, SMB_VERSION_35)) {
554 		chp->smbc_sku = smb_strptr(stp, 0);
555 	} else if (smb_libgteq(shp, SMB_VERSION_27)) {
556 		smb_chassis_pre35_t *p35 = (smb_chassis_pre35_t *)chp;
557 		bzero(p35->smbc_sku, sizeof (p35->smbc_sku));
558 	}
559 
560 	chp->smbc_oemdata = ch.smbch_oemdata;
561 	chp->smbc_lock = (ch.smbch_type & SMB_CHT_LOCK) != 0;
562 	chp->smbc_type = ch.smbch_type & ~SMB_CHT_LOCK;
563 	chp->smbc_bustate = ch.smbch_bustate;
564 	chp->smbc_psstate = ch.smbch_psstate;
565 	chp->smbc_thstate = ch.smbch_thstate;
566 	chp->smbc_security = ch.smbch_security;
567 	chp->smbc_uheight = ch.smbch_uheight;
568 	chp->smbc_cords = ch.smbch_cords;
569 	chp->smbc_elems = ch.smbch_cn;
570 	chp->smbc_elemlen = ch.smbch_cm;
571 
572 	/*
573 	 * If the table is older than version 2.7 which added support for the
574 	 * chassis SKU, there's no reason to proceed.
575 	 */
576 	if (!smb_gteq(shp, SMB_VERSION_27)) {
577 		return (0);
578 	}
579 
580 	if (smb_libgteq(shp, SMB_VERSION_27)) {
581 		uint8_t strno;
582 		const char *str;
583 		off_t off = sizeof (ch) + ch.smbch_cn * ch.smbch_cm;
584 		if (stp->smbst_hdr->smbh_len < off + 1) {
585 			return (smb_set_errno(shp, ESMB_SHORT));
586 		}
587 		smb_info_bcopy_offset(stp->smbst_hdr, &strno, sizeof (strno),
588 		    off);
589 		str = smb_strptr(stp, strno);
590 		if (smb_libgteq(shp, SMB_VERSION_35)) {
591 			chp->smbc_sku = str;
592 		} else {
593 			smb_chassis_pre35_t *p35 = (smb_chassis_pre35_t *)chp;
594 			(void) strlcpy(p35->smbc_sku, str,
595 			    sizeof (p35->smbc_sku));
596 		}
597 	}
598 
599 	return (0);
600 }
601 
602 int
smbios_info_chassis_elts(smbios_hdl_t * shp,id_t id,uint_t * nentsp,smbios_chassis_entry_t ** entsp)603 smbios_info_chassis_elts(smbios_hdl_t *shp, id_t id, uint_t *nentsp,
604     smbios_chassis_entry_t **entsp)
605 {
606 	const smb_struct_t *stp = smb_lookup_id(shp, id);
607 	smbios_chassis_entry_t *entry;
608 	smb_chassis_t ch;
609 	size_t entlen;
610 	uint_t i;
611 
612 	if (stp == NULL) {
613 		return (-1); /* errno is set for us */
614 	}
615 
616 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_CHASSIS) {
617 		return (smb_set_errno(shp, ESMB_TYPE));
618 	}
619 
620 	if (stp->smbst_hdr->smbh_len < sizeof (ch)) {
621 		return (smb_set_errno(shp, ESMB_SHORT));
622 	}
623 
624 	smb_info_bcopy(stp->smbst_hdr, &ch, sizeof (ch));
625 	if (ch.smbch_cm != sizeof (smb_chassis_entry_t)) {
626 		return (smb_set_errno(shp, ESMB_CORRUPT));
627 	}
628 
629 	if (ch.smbch_cn == 0) {
630 		*nentsp = 0;
631 		*entsp = NULL;
632 		return (0);
633 	}
634 
635 	entlen = ch.smbch_cm * ch.smbch_cn;
636 	if (stp->smbst_hdr->smbh_len < sizeof (ch) + entlen) {
637 		return (smb_set_errno(shp, ESMB_SHORT));
638 	}
639 
640 	if ((entry = smb_alloc(entlen)) == NULL) {
641 		return (smb_set_errno(shp, ESMB_NOMEM));
642 	}
643 
644 	for (i = 0; i < ch.smbch_cn; i++) {
645 		smb_chassis_entry_t e;
646 		size_t off = sizeof (ch) + i * sizeof (e);
647 
648 		smb_info_bcopy_offset(stp->smbst_hdr, &e, sizeof (e), off);
649 		/*
650 		 * The top bit is used to indicate what type of record this is,
651 		 * while the lower 7-bits indicate the actual type.
652 		 */
653 		entry[i].smbce_type = e.smbce_type & 0x80 ?
654 		    SMB_CELT_SMBIOS : SMB_CELT_BBOARD;
655 		entry[i].smbce_elt = e.smbce_type & 0x7f;
656 		entry[i].smbce_min = e.smbce_min;
657 		entry[i].smbce_max = e.smbce_max;
658 	}
659 
660 	*entsp = entry;
661 	*nentsp = ch.smbch_cn;
662 
663 	return (0);
664 }
665 
666 void
smbios_info_chassis_elts_free(smbios_hdl_t * shp,uint_t nents,smbios_chassis_entry_t * ent)667 smbios_info_chassis_elts_free(smbios_hdl_t *shp, uint_t nents,
668     smbios_chassis_entry_t *ent)
669 {
670 	size_t sz = nents * sizeof (smbios_chassis_entry_t);
671 
672 	if (nents == 0) {
673 		ASSERT3P(ent, ==, NULL);
674 		return;
675 	}
676 
677 	smb_free(ent, sz);
678 }
679 
680 int
smbios_info_processor(smbios_hdl_t * shp,id_t id,smbios_processor_t * pp)681 smbios_info_processor(smbios_hdl_t *shp, id_t id, smbios_processor_t *pp)
682 {
683 	const smb_struct_t *stp = smb_lookup_id(shp, id);
684 	smb_processor_t p;
685 
686 	if (stp == NULL)
687 		return (-1); /* errno is set for us */
688 
689 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR)
690 		return (smb_set_errno(shp, ESMB_TYPE));
691 
692 	smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p));
693 	bzero(pp, sizeof (smb_base_processor_t));
694 
695 	pp->smbp_cpuid = p.smbpr_cpuid;
696 	pp->smbp_type = p.smbpr_type;
697 	pp->smbp_family = p.smbpr_family;
698 	pp->smbp_voltage = p.smbpr_voltage;
699 	pp->smbp_maxspeed = p.smbpr_maxspeed;
700 	pp->smbp_curspeed = p.smbpr_curspeed;
701 	pp->smbp_status = p.smbpr_status;
702 	pp->smbp_upgrade = p.smbpr_upgrade;
703 	pp->smbp_l1cache = p.smbpr_l1cache;
704 	pp->smbp_l2cache = p.smbpr_l2cache;
705 	pp->smbp_l3cache = p.smbpr_l3cache;
706 
707 	if (smb_libgteq(shp, SMB_VERSION_25)) {
708 		pp->smbp_corecount = p.smbpr_corecount;
709 		pp->smbp_coresenabled = p.smbpr_coresenabled;
710 		pp->smbp_threadcount = p.smbpr_threadcount;
711 		pp->smbp_cflags = p.smbpr_cflags;
712 	}
713 
714 	if (smb_libgteq(shp, SMB_VERSION_26)) {
715 		if (pp->smbp_family == 0xfe) {
716 			pp->smbp_family = p.smbpr_family2;
717 		}
718 	}
719 
720 	if (smb_libgteq(shp, SMB_VERSION_30)) {
721 		if (pp->smbp_corecount == 0xff) {
722 			pp->smbp_corecount = p.smbpr_corecount2;
723 		}
724 		if (pp->smbp_coresenabled == 0xff) {
725 			pp->smbp_coresenabled = p.smbpr_coresenabled2;
726 		}
727 		if (pp->smbp_threadcount == 0xff) {
728 			pp->smbp_threadcount = p.smbpr_threadcount2;
729 		}
730 	}
731 
732 	return (0);
733 }
734 
735 int
smbios_info_cache(smbios_hdl_t * shp,id_t id,smbios_cache_t * cap)736 smbios_info_cache(smbios_hdl_t *shp, id_t id, smbios_cache_t *cap)
737 {
738 	const smb_struct_t *stp = smb_lookup_id(shp, id);
739 	smb_cache_t c;
740 
741 	if (stp == NULL)
742 		return (-1); /* errno is set for us */
743 
744 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_CACHE)
745 		return (smb_set_errno(shp, ESMB_TYPE));
746 
747 	smb_info_bcopy(stp->smbst_hdr, &c, sizeof (c));
748 	bzero(cap, sizeof (smb_base_cache_t));
749 
750 	cap->smba_maxsize = SMB_CACHE_SIZE(c.smbca_maxsize);
751 	cap->smba_size = SMB_CACHE_SIZE(c.smbca_size);
752 	cap->smba_stype = c.smbca_stype;
753 	cap->smba_ctype = c.smbca_ctype;
754 	cap->smba_speed = c.smbca_speed;
755 	cap->smba_etype = c.smbca_etype;
756 	cap->smba_ltype = c.smbca_ltype;
757 	cap->smba_assoc = c.smbca_assoc;
758 	cap->smba_level = SMB_CACHE_CFG_LEVEL(c.smbca_config);
759 	cap->smba_mode = SMB_CACHE_CFG_MODE(c.smbca_config);
760 	cap->smba_location = SMB_CACHE_CFG_LOCATION(c.smbca_config);
761 
762 	if (SMB_CACHE_CFG_ENABLED(c.smbca_config))
763 		cap->smba_flags |= SMB_CAF_ENABLED;
764 
765 	if (SMB_CACHE_CFG_SOCKETED(c.smbca_config))
766 		cap->smba_flags |= SMB_CAF_SOCKETED;
767 
768 	if (smb_libgteq(shp, SMB_VERSION_31)) {
769 		cap->smba_maxsize2 = SMB_CACHE_EXT_SIZE(c.smbca_maxsize2);
770 		cap->smba_size2 = SMB_CACHE_EXT_SIZE(c.smbca_size2);
771 
772 		if (cap->smba_maxsize2 == 0) {
773 			cap->smba_maxsize2 = cap->smba_maxsize;
774 		}
775 
776 		if (cap->smba_size2 == 0) {
777 			cap->smba_size2 = cap->smba_size;
778 		}
779 	}
780 
781 	return (0);
782 }
783 
784 int
smbios_info_port(smbios_hdl_t * shp,id_t id,smbios_port_t * pop)785 smbios_info_port(smbios_hdl_t *shp, id_t id, smbios_port_t *pop)
786 {
787 	const smb_struct_t *stp = smb_lookup_id(shp, id);
788 	smb_port_t p;
789 
790 	if (stp == NULL)
791 		return (-1); /* errno is set for us */
792 
793 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_PORT)
794 		return (smb_set_errno(shp, ESMB_TYPE));
795 
796 	smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p));
797 	bzero(pop, sizeof (smbios_port_t));
798 
799 	pop->smbo_iref = smb_strptr(stp, p.smbpo_iref);
800 	pop->smbo_eref = smb_strptr(stp, p.smbpo_eref);
801 
802 	pop->smbo_itype = p.smbpo_itype;
803 	pop->smbo_etype = p.smbpo_etype;
804 	pop->smbo_ptype = p.smbpo_ptype;
805 
806 	return (0);
807 }
808 
809 int
smbios_info_slot(smbios_hdl_t * shp,id_t id,smbios_slot_t * sp)810 smbios_info_slot(smbios_hdl_t *shp, id_t id, smbios_slot_t *sp)
811 {
812 	const smb_struct_t *stp = smb_lookup_id(shp, id);
813 	smb_slot_t s;
814 	smb_slot_cont_t cont;
815 	size_t off;
816 
817 	if (stp == NULL)
818 		return (-1); /* errno is set for us */
819 
820 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_SLOT)
821 		return (smb_set_errno(shp, ESMB_TYPE));
822 
823 	smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
824 	bzero(sp, sizeof (smb_base_slot_t));
825 
826 	sp->smbl_name = smb_strptr(stp, s.smbsl_name);
827 	sp->smbl_type = s.smbsl_type;
828 	sp->smbl_width = s.smbsl_width;
829 	sp->smbl_usage = s.smbsl_usage;
830 	sp->smbl_length = s.smbsl_length;
831 	sp->smbl_id = s.smbsl_id;
832 	sp->smbl_ch1 = s.smbsl_ch1;
833 	sp->smbl_ch2 = s.smbsl_ch2;
834 	sp->smbl_sg = s.smbsl_sg;
835 	sp->smbl_bus = s.smbsl_bus;
836 	sp->smbl_df = s.smbsl_df;
837 
838 	if (smb_libgteq(shp, SMB_VERSION_32)) {
839 		sp->smbl_dbw = s.smbsl_dbw;
840 		sp->smbl_npeers = s.smbsl_npeers;
841 	}
842 
843 	if (!smb_libgteq(shp, SMB_VERSION_34)) {
844 		return (0);
845 	}
846 
847 	/*
848 	 * In SMBIOS 3.4, several members were added to follow the variable
849 	 * number of peers. These are defined to start at byte 0x14 + 5 *
850 	 * npeers. If the table is from before 3.4, we simple zero things out.
851 	 * Otherwise we check if the length covers the peers and this addendum
852 	 * to include it as the table length is allowed to be less than this and
853 	 * not include it.
854 	 */
855 	off = SMB_SLOT_CONT_START + 5 * s.smbsl_npeers;
856 	smb_info_bcopy_offset(stp->smbst_hdr, &cont, sizeof (cont), off);
857 	sp->smbl_info = cont.smbsl_info;
858 	sp->smbl_pwidth = cont.smbsl_pwidth;
859 	sp->smbl_pitch = cont.smbsl_pitch;
860 
861 	if (smb_libgteq(shp, SMB_VERSION_35)) {
862 		sp->smbl_height = cont.smbsl_height;
863 	}
864 
865 	return (0);
866 }
867 
868 void
smbios_info_slot_peers_free(smbios_hdl_t * shp,uint_t npeers,smbios_slot_peer_t * peer)869 smbios_info_slot_peers_free(smbios_hdl_t *shp, uint_t npeers,
870     smbios_slot_peer_t *peer)
871 {
872 	size_t sz = npeers * sizeof (smbios_slot_peer_t);
873 
874 	if (npeers == 0) {
875 		ASSERT3P(peer, ==, NULL);
876 		return;
877 	}
878 
879 	smb_free(peer, sz);
880 }
881 
882 int
smbios_info_slot_peers(smbios_hdl_t * shp,id_t id,uint_t * npeers,smbios_slot_peer_t ** peerp)883 smbios_info_slot_peers(smbios_hdl_t *shp, id_t id, uint_t *npeers,
884     smbios_slot_peer_t **peerp)
885 {
886 	const smb_struct_t *stp = smb_lookup_id(shp, id);
887 	const smb_slot_t *slotp;
888 	smbios_slot_peer_t *peer;
889 	size_t minlen;
890 	uint_t i;
891 
892 	if (stp == NULL)
893 		return (-1); /* errno is set for us */
894 
895 	slotp = (const smb_slot_t *)stp->smbst_hdr;
896 
897 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_SLOT)
898 		return (smb_set_errno(shp, ESMB_TYPE));
899 
900 	if (stp->smbst_hdr->smbh_len <= offsetof(smb_slot_t, smbsl_npeers) ||
901 	    slotp->smbsl_npeers == 0) {
902 		*npeers = 0;
903 		*peerp = NULL;
904 		return (0);
905 	}
906 
907 	/*
908 	 * Make sure that the size of the structure makes sense for the number
909 	 * of peers reported.
910 	 */
911 	minlen = slotp->smbsl_npeers * sizeof (smb_slot_peer_t) +
912 	    offsetof(smb_slot_t, smbsl_npeers);
913 	if (stp->smbst_hdr->smbh_len < minlen) {
914 		return (smb_set_errno(shp, ESMB_SHORT));
915 	}
916 
917 	if ((peer = smb_alloc(slotp->smbsl_npeers *
918 	    sizeof (smbios_slot_peer_t))) == NULL) {
919 		return (smb_set_errno(shp, ESMB_NOMEM));
920 	}
921 
922 	for (i = 0; i < slotp->smbsl_npeers; i++) {
923 		peer[i].smblp_group = slotp->smbsl_peers[i].smbspb_group_no;
924 		peer[i].smblp_bus = slotp->smbsl_peers[i].smbspb_bus;
925 		peer[i].smblp_device = slotp->smbsl_peers[i].smbspb_df >> 3;
926 		peer[i].smblp_function = slotp->smbsl_peers[i].smbspb_df & 0x7;
927 		peer[i].smblp_data_width = slotp->smbsl_peers[i].smbspb_width;
928 	}
929 
930 	*npeers = slotp->smbsl_npeers;
931 	*peerp = peer;
932 
933 	return (0);
934 }
935 
936 int
smbios_info_obdevs_ext(smbios_hdl_t * shp,id_t id,smbios_obdev_ext_t * oep)937 smbios_info_obdevs_ext(smbios_hdl_t *shp, id_t id, smbios_obdev_ext_t *oep)
938 {
939 	const smb_struct_t *stp = smb_lookup_id(shp, id);
940 	smb_obdev_ext_t obe;
941 
942 	if (stp == NULL)
943 		return (-1); /* errno is set for us */
944 
945 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVEXT)
946 		return (smb_set_errno(shp, ESMB_TYPE));
947 
948 	smb_info_bcopy(stp->smbst_hdr, &obe, sizeof (obe));
949 	bzero(oep, sizeof (smbios_obdev_ext_t));
950 
951 	oep->smboe_name = smb_strptr(stp, obe.smbobe_name);
952 	oep->smboe_dtype = obe.smbobe_dtype;
953 	oep->smboe_dti = obe.smbobe_dti;
954 	oep->smboe_sg = obe.smbobe_sg;
955 	oep->smboe_bus = obe.smbobe_bus;
956 	oep->smboe_df = obe.smbobe_df;
957 
958 	return (0);
959 }
960 
961 int
smbios_info_obdevs(smbios_hdl_t * shp,id_t id,int obc,smbios_obdev_t * obp)962 smbios_info_obdevs(smbios_hdl_t *shp, id_t id, int obc, smbios_obdev_t *obp)
963 {
964 	const smb_struct_t *stp = smb_lookup_id(shp, id);
965 	const smb_obdev_t *op;
966 	int i, m, n;
967 
968 	if (stp == NULL)
969 		return (-1); /* errno is set for us */
970 
971 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVS)
972 		return (smb_set_errno(shp, ESMB_TYPE));
973 
974 	op = (smb_obdev_t *)((uintptr_t)stp->smbst_hdr + sizeof (smb_header_t));
975 	m = (stp->smbst_hdr->smbh_len - sizeof (smb_header_t)) / sizeof (*op);
976 	n = MIN(m, obc);
977 
978 	for (i = 0; i < n; i++, op++, obp++) {
979 		obp->smbd_name = smb_strptr(stp, op->smbob_name);
980 		obp->smbd_type = op->smbob_type & ~SMB_OBT_ENABLED;
981 		obp->smbd_enabled = (op->smbob_type & SMB_OBT_ENABLED) != 0;
982 	}
983 
984 	return (m);
985 }
986 
987 /*
988  * The implementation structures for OEMSTR, SYSCONFSTR, and LANG all use the
989  * first byte to indicate the size of a string table at the end of the record.
990  * Therefore, smbios_info_strtab() can be used to retrieve the table size and
991  * strings for any of these underlying record types.
992  */
993 int
smbios_info_strtab(smbios_hdl_t * shp,id_t id,int argc,const char * argv[])994 smbios_info_strtab(smbios_hdl_t *shp, id_t id, int argc, const char *argv[])
995 {
996 	const smb_struct_t *stp = smb_lookup_id(shp, id);
997 	smb_strtab_t s;
998 	int i, n;
999 
1000 	if (stp == NULL)
1001 		return (-1); /* errno is set for us */
1002 
1003 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR &&
1004 	    stp->smbst_hdr->smbh_type != SMB_TYPE_SYSCONFSTR &&
1005 	    stp->smbst_hdr->smbh_type != SMB_TYPE_LANG)
1006 		return (smb_set_errno(shp, ESMB_TYPE));
1007 
1008 	smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
1009 	n = MIN(s.smbtb_count, argc);
1010 
1011 	for (i = 0; i < n; i++)
1012 		argv[i] = smb_strptr(stp, i + 1);
1013 
1014 	return (s.smbtb_count);
1015 }
1016 
1017 id_t
smbios_info_lang(smbios_hdl_t * shp,smbios_lang_t * lp)1018 smbios_info_lang(smbios_hdl_t *shp, smbios_lang_t *lp)
1019 {
1020 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_LANG);
1021 	smb_lang_t l;
1022 
1023 	if (stp == NULL)
1024 		return (-1); /* errno is set for us */
1025 
1026 	smb_info_bcopy(stp->smbst_hdr, &l, sizeof (l));
1027 	bzero(lp, sizeof (smbios_lang_t));
1028 
1029 	lp->smbla_cur = smb_strptr(stp, l.smblang_cur);
1030 	lp->smbla_fmt = l.smblang_flags & 1;
1031 	lp->smbla_num = l.smblang_num;
1032 
1033 	return (stp->smbst_hdr->smbh_hdl);
1034 }
1035 
1036 id_t
smbios_info_eventlog(smbios_hdl_t * shp,smbios_evlog_t * evp)1037 smbios_info_eventlog(smbios_hdl_t *shp, smbios_evlog_t *evp)
1038 {
1039 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_EVENTLOG);
1040 	const smb_sel_t *sel;
1041 	size_t len;
1042 
1043 	if (stp == NULL)
1044 		return (-1); /* errno is set for us */
1045 
1046 	if (stp->smbst_hdr->smbh_len < sizeof (smb_sel_t) - sizeof (uint8_t))
1047 		return (smb_set_errno(shp, ESMB_CORRUPT));
1048 
1049 	sel = (smb_sel_t *)(uintptr_t)stp->smbst_hdr;
1050 	len = stp->smbst_hdr->smbh_len - sizeof (smb_sel_t) + sizeof (uint8_t);
1051 	bzero(evp, sizeof (smbios_evlog_t));
1052 
1053 	if (len < sel->smbsel_typec * sel->smbsel_typesz)
1054 		return (smb_set_errno(shp, ESMB_CORRUPT));
1055 
1056 	evp->smbev_size = sel->smbsel_len;
1057 	evp->smbev_hdr = sel->smbsel_hdroff;
1058 	evp->smbev_data = sel->smbsel_dataoff;
1059 	evp->smbev_method = sel->smbsel_method;
1060 	evp->smbev_flags = sel->smbsel_status;
1061 	evp->smbev_format = sel->smbsel_format;
1062 	evp->smbev_token = sel->smbsel_token;
1063 	evp->smbev_addr.eva_addr = sel->smbsel_addr;
1064 
1065 	if (sel->smbsel_typesz == sizeof (smbios_evtype_t)) {
1066 		evp->smbev_typec = sel->smbsel_typec;
1067 		evp->smbev_typev = (void *)(uintptr_t)sel->smbsel_typev;
1068 	}
1069 
1070 	return (stp->smbst_hdr->smbh_hdl);
1071 }
1072 
1073 int
smbios_info_memarray(smbios_hdl_t * shp,id_t id,smbios_memarray_t * map)1074 smbios_info_memarray(smbios_hdl_t *shp, id_t id, smbios_memarray_t *map)
1075 {
1076 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1077 	smb_memarray_t m;
1078 
1079 	if (stp == NULL)
1080 		return (-1); /* errno is set for us */
1081 
1082 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAY)
1083 		return (smb_set_errno(shp, ESMB_TYPE));
1084 
1085 	smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
1086 	bzero(map, sizeof (smbios_memarray_t));
1087 
1088 	map->smbma_location = m.smbmarr_loc;
1089 	map->smbma_use = m.smbmarr_use;
1090 	map->smbma_ecc = m.smbmarr_ecc;
1091 	map->smbma_ndevs = m.smbmarr_ndevs;
1092 	map->smbma_err = m.smbmarr_err;
1093 
1094 	if (m.smbmarr_cap != 0x80000000)
1095 		map->smbma_size = (uint64_t)m.smbmarr_cap * 1024;
1096 	else if (m.smbmarr_extcap != 0)
1097 		map->smbma_size = m.smbmarr_extcap;
1098 	else
1099 		map->smbma_size = 0; /* unknown */
1100 
1101 	return (0);
1102 }
1103 
1104 int
smbios_info_memarrmap(smbios_hdl_t * shp,id_t id,smbios_memarrmap_t * map)1105 smbios_info_memarrmap(smbios_hdl_t *shp, id_t id, smbios_memarrmap_t *map)
1106 {
1107 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1108 	smb_memarrmap_t m;
1109 
1110 	if (stp == NULL)
1111 		return (-1); /* errno is set for us */
1112 
1113 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAYMAP)
1114 		return (smb_set_errno(shp, ESMB_TYPE));
1115 
1116 	smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
1117 	bzero(map, sizeof (smbios_memarrmap_t));
1118 
1119 	map->smbmam_array = m.smbamap_array;
1120 	map->smbmam_width = m.smbamap_width;
1121 
1122 	if (m.smbamap_start != 0xFFFFFFFF && m.smbamap_end != 0xFFFFFFFF) {
1123 		map->smbmam_addr = (uint64_t)m.smbamap_start * 1024;
1124 		map->smbmam_size = (uint64_t)
1125 		    (m.smbamap_end - m.smbamap_start + 1) * 1024;
1126 	} else if (m.smbamap_extstart != 0 && m.smbamap_extend != 0) {
1127 		map->smbmam_addr = m.smbamap_extstart;
1128 		map->smbmam_size = m.smbamap_extend - m.smbamap_extstart + 1;
1129 	}
1130 
1131 	return (0);
1132 }
1133 
1134 int
smbios_info_memdevice(smbios_hdl_t * shp,id_t id,smbios_memdevice_t * mdp)1135 smbios_info_memdevice(smbios_hdl_t *shp, id_t id, smbios_memdevice_t *mdp)
1136 {
1137 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1138 	smb_memdevice_t m;
1139 
1140 	if (stp == NULL)
1141 		return (-1); /* errno is set for us */
1142 
1143 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICE)
1144 		return (smb_set_errno(shp, ESMB_TYPE));
1145 
1146 	smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
1147 	bzero(mdp, sizeof (smb_base_memdevice_t));
1148 
1149 	mdp->smbmd_array = m.smbmdev_array;
1150 	mdp->smbmd_error = m.smbmdev_error;
1151 	mdp->smbmd_twidth = m.smbmdev_twidth == 0xFFFF ? -1U : m.smbmdev_twidth;
1152 	mdp->smbmd_dwidth = m.smbmdev_dwidth == 0xFFFF ? -1U : m.smbmdev_dwidth;
1153 
1154 	if (m.smbmdev_size == 0x7FFF) {
1155 		mdp->smbmd_size = (uint64_t)m.smbmdev_extsize;
1156 		mdp->smbmd_size *= 1024 * 1024; /* convert MB to bytes */
1157 	} else if (m.smbmdev_size != 0xFFFF) {
1158 		mdp->smbmd_size = (uint64_t)(m.smbmdev_size & ~SMB_MDS_KBYTES);
1159 		if (m.smbmdev_size & SMB_MDS_KBYTES)
1160 			mdp->smbmd_size *= 1024;
1161 		else
1162 			mdp->smbmd_size *= 1024 * 1024;
1163 	} else
1164 		mdp->smbmd_size = -1ULL; /* size unknown */
1165 
1166 	mdp->smbmd_form = m.smbmdev_form;
1167 	mdp->smbmd_set = m.smbmdev_set;
1168 	mdp->smbmd_type = m.smbmdev_type;
1169 	mdp->smbmd_speed = m.smbmdev_speed;
1170 	mdp->smbmd_flags = m.smbmdev_flags;
1171 	mdp->smbmd_dloc = smb_strptr(stp, m.smbmdev_dloc);
1172 	mdp->smbmd_bloc = smb_strptr(stp, m.smbmdev_bloc);
1173 
1174 	if (smb_libgteq(shp, SMB_VERSION_26)) {
1175 		mdp->smbmd_rank = m.smbmdev_attrs & 0x0F;
1176 	}
1177 
1178 	if (smb_libgteq(shp, SMB_VERSION_27)) {
1179 		mdp->smbmd_clkspeed = m.smbmdev_clkspeed;
1180 	}
1181 
1182 	if (smb_libgteq(shp, SMB_VERSION_28)) {
1183 		mdp->smbmd_minvolt = m.smbmdev_minvolt;
1184 		mdp->smbmd_maxvolt = m.smbmdev_maxvolt;
1185 		mdp->smbmd_confvolt = m.smbmdev_confvolt;
1186 	}
1187 
1188 	if (smb_libgteq(shp, SMB_VERSION_32)) {
1189 		mdp->smbmd_memtech = m.smbmdev_memtech;
1190 		mdp->smbmd_opcap_flags = m.smbmdev_opmode;
1191 		mdp->smbmd_firmware_rev = smb_strptr(stp,
1192 		    m.smbmdev_fwver);
1193 		mdp->smbmd_modmfg_id = m.smbmdev_modulemfgid;
1194 		mdp->smbmd_modprod_id = m.smbmdev_moduleprodid;
1195 		mdp->smbmd_cntrlmfg_id = m.smbmdev_memsysmfgid;
1196 		mdp->smbmd_cntrlprod_id = m.smbmdev_memsysprodid;
1197 		mdp->smbmd_nvsize = m.smbmdev_nvsize;
1198 		mdp->smbmd_volatile_size = m.smbmdev_volsize;
1199 		mdp->smbmd_cache_size = m.smbmdev_cachesize;
1200 		mdp->smbmd_logical_size = m.smbmdev_logicalsize;
1201 	}
1202 
1203 	if (smb_libgteq(shp, SMB_VERSION_33)) {
1204 		if (m.smbmdev_speed == 0xffff) {
1205 			mdp->smbmd_extspeed = m.smbmdev_extspeed;
1206 		} else {
1207 			mdp->smbmd_extspeed = m.smbmdev_speed;
1208 		}
1209 
1210 		if (m.smbmdev_clkspeed == 0xffff) {
1211 			mdp->smbmd_extclkspeed = m.smbmdev_extclkspeed;
1212 		} else {
1213 			mdp->smbmd_extclkspeed = m.smbmdev_clkspeed;
1214 		}
1215 	}
1216 
1217 	return (0);
1218 }
1219 
1220 int
smbios_info_memdevmap(smbios_hdl_t * shp,id_t id,smbios_memdevmap_t * mdp)1221 smbios_info_memdevmap(smbios_hdl_t *shp, id_t id, smbios_memdevmap_t *mdp)
1222 {
1223 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1224 	smb_memdevmap_t m;
1225 
1226 	if (stp == NULL)
1227 		return (-1); /* errno is set for us */
1228 
1229 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICEMAP)
1230 		return (smb_set_errno(shp, ESMB_TYPE));
1231 
1232 	smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
1233 	bzero(mdp, sizeof (smbios_memdevmap_t));
1234 
1235 	mdp->smbmdm_device = m.smbdmap_device;
1236 	mdp->smbmdm_arrmap = m.smbdmap_array;
1237 	mdp->smbmdm_rpos = m.smbdmap_rpos;
1238 	mdp->smbmdm_ipos = m.smbdmap_ipos;
1239 	mdp->smbmdm_idepth = m.smbdmap_idepth;
1240 
1241 	if (m.smbdmap_start != 0xFFFFFFFF && m.smbdmap_end != 0xFFFFFFFF) {
1242 		mdp->smbmdm_addr = (uint64_t)m.smbdmap_start * 1024;
1243 		mdp->smbmdm_size = (uint64_t)
1244 		    (m.smbdmap_end - m.smbdmap_start + 1) * 1024;
1245 	} else if (m.smbdmap_extstart != 0 && m.smbdmap_extend != 0) {
1246 		mdp->smbmdm_addr = m.smbdmap_extstart;
1247 		mdp->smbmdm_size = m.smbdmap_extend - m.smbdmap_extstart + 1;
1248 	}
1249 
1250 	return (0);
1251 }
1252 
1253 id_t
smbios_info_hwsec(smbios_hdl_t * shp,smbios_hwsec_t * hsp)1254 smbios_info_hwsec(smbios_hdl_t *shp, smbios_hwsec_t *hsp)
1255 {
1256 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SECURITY);
1257 	smb_hwsec_t hs;
1258 
1259 	if (stp == NULL)
1260 		return (-1); /* errno is set for us */
1261 
1262 	smb_info_bcopy(stp->smbst_hdr, &hs, sizeof (hs));
1263 	bzero(hsp, sizeof (smbios_hwsec_t));
1264 
1265 	hsp->smbh_pwr_ps = SMB_HWS_PWR_PS(hs.smbhs_settings);
1266 	hsp->smbh_kbd_ps = SMB_HWS_KBD_PS(hs.smbhs_settings);
1267 	hsp->smbh_adm_ps = SMB_HWS_ADM_PS(hs.smbhs_settings);
1268 	hsp->smbh_pan_ps = SMB_HWS_PAN_PS(hs.smbhs_settings);
1269 
1270 	return (stp->smbst_hdr->smbh_hdl);
1271 }
1272 
1273 id_t
smbios_info_boot(smbios_hdl_t * shp,smbios_boot_t * bp)1274 smbios_info_boot(smbios_hdl_t *shp, smbios_boot_t *bp)
1275 {
1276 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BOOT);
1277 	const smb_boot_t *b;
1278 
1279 	if (stp == NULL)
1280 		return (-1); /* errno is set for us */
1281 
1282 	bzero(bp, sizeof (smbios_boot_t));
1283 
1284 	b = (smb_boot_t *)(uintptr_t)stp->smbst_hdr;
1285 
1286 	bp->smbt_status = b->smbbo_status[0];
1287 	bp->smbt_size = stp->smbst_hdr->smbh_len - sizeof (smb_boot_t);
1288 	bp->smbt_data = bp->smbt_size ? &b->smbbo_status[1] : NULL;
1289 
1290 	return (stp->smbst_hdr->smbh_hdl);
1291 }
1292 
1293 id_t
smbios_info_ipmi(smbios_hdl_t * shp,smbios_ipmi_t * ip)1294 smbios_info_ipmi(smbios_hdl_t *shp, smbios_ipmi_t *ip)
1295 {
1296 	const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_IPMIDEV);
1297 	smb_ipmi_t i;
1298 
1299 	if (stp == NULL)
1300 		return (-1); /* errno is set for us */
1301 
1302 	smb_info_bcopy(stp->smbst_hdr, &i, sizeof (i));
1303 	bzero(ip, sizeof (smbios_ipmi_t));
1304 
1305 	ip->smbip_type = i.smbipm_type;
1306 	ip->smbip_vers.smbv_major = SMB_IPM_SPEC_MAJOR(i.smbipm_spec);
1307 	ip->smbip_vers.smbv_minor = SMB_IPM_SPEC_MINOR(i.smbipm_spec);
1308 	ip->smbip_i2c = i.smbipm_i2c;
1309 	ip->smbip_addr = i.smbipm_addr & ~SMB_IPM_ADDR_IO;
1310 	ip->smbip_intr = i.smbipm_intr;
1311 
1312 	if (i.smbipm_bus != (uint8_t)-1)
1313 		ip->smbip_bus = i.smbipm_bus;
1314 	else
1315 		ip->smbip_bus = -1u;
1316 
1317 	if (SMB_IPM_INFO_LSB(i.smbipm_info))
1318 		ip->smbip_addr |= 1; /* turn on least-significant bit of addr */
1319 
1320 	if (i.smbipm_addr & SMB_IPM_ADDR_IO) {
1321 		switch (SMB_IPM_INFO_REGS(i.smbipm_info)) {
1322 		case SMB_IPM_REGS_1B:
1323 			ip->smbip_regspacing = 1;
1324 			break;
1325 		case SMB_IPM_REGS_4B:
1326 			ip->smbip_regspacing = 4;
1327 			break;
1328 		case SMB_IPM_REGS_16B:
1329 			ip->smbip_regspacing = 16;
1330 			break;
1331 		default:
1332 			ip->smbip_regspacing = 1;
1333 		}
1334 		ip->smbip_flags |= SMB_IPMI_F_IOADDR;
1335 	}
1336 
1337 	if (SMB_IPM_INFO_ISPEC(i.smbipm_info))
1338 		ip->smbip_flags |= SMB_IPMI_F_INTRSPEC;
1339 
1340 	if (SMB_IPM_INFO_IPOL(i.smbipm_info) == SMB_IPM_IPOL_HI)
1341 		ip->smbip_flags |= SMB_IPMI_F_INTRHIGH;
1342 
1343 	if (SMB_IPM_INFO_IMODE(i.smbipm_info) == SMB_IPM_IMODE_EDGE)
1344 		ip->smbip_flags |= SMB_IPMI_F_INTREDGE;
1345 
1346 	return (stp->smbst_hdr->smbh_hdl);
1347 }
1348 
1349 static boolean_t
smbios_has_oemstr(smbios_hdl_t * shp,const char * oemstr)1350 smbios_has_oemstr(smbios_hdl_t *shp, const char *oemstr)
1351 {
1352 	const smb_struct_t *stp = shp->sh_structs;
1353 	smb_strtab_t s;
1354 	int i, j;
1355 
1356 	for (i = 0; i < shp->sh_nstructs; i++, stp++) {
1357 		if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR)
1358 			continue;
1359 
1360 		smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
1361 		for (j = 0; j < s.smbtb_count; j++)
1362 			if (strcmp(smb_strptr(stp, j + 1), oemstr) == 0)
1363 				return (B_TRUE);
1364 	}
1365 
1366 	return (B_FALSE);
1367 }
1368 
1369 static const char *
smb_serial_valid(const char * serial)1370 smb_serial_valid(const char *serial)
1371 {
1372 	char buf[MAXNAMELEN];
1373 	int i = 0;
1374 
1375 	if (serial == NULL)
1376 		return (NULL);
1377 
1378 	(void) strlcpy(buf, serial, sizeof (buf));
1379 
1380 	while (buf[i] != '\0' && buf[i] == ' ')
1381 		i++;
1382 
1383 	if (buf[i] == '\0' || strstr(buf, SMB_DEFAULT1) != NULL ||
1384 	    strstr(buf, SMB_DEFAULT2) != NULL)
1385 		return (NULL);
1386 
1387 	return (serial);
1388 }
1389 
1390 /*
1391  * Get chassis SN or product SN
1392  */
1393 static int
smb_get_sn(smbios_hdl_t * shp,const char ** psnp,const char ** csnp)1394 smb_get_sn(smbios_hdl_t *shp, const char **psnp, const char **csnp)
1395 {
1396 	const smb_struct_t *stp;
1397 	smbios_info_t s1, s3;
1398 
1399 	if (psnp == NULL || csnp == NULL)
1400 		return (smb_set_errno(shp, ESMB_INVAL));
1401 
1402 	*psnp = *csnp = NULL;
1403 
1404 	/*
1405 	 * If SMBIOS meets Sun's PRMS requirements, retrieve product SN
1406 	 * from type 1 structure, and chassis SN from type 3 structure.
1407 	 * Otherwise return SN in type 1 structure as chassis SN.
1408 	 */
1409 
1410 	/* Get type 1 SN */
1411 	if ((stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM)) == NULL ||
1412 	    smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s1) == SMB_ERR)
1413 		s1.smbi_serial = NULL;
1414 
1415 	/* Get type 3 SN */
1416 	if ((stp = smb_lookup_type(shp, SMB_TYPE_CHASSIS)) == NULL ||
1417 	    smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s3) == SMB_ERR)
1418 		s3.smbi_serial = NULL;
1419 
1420 	if (smbios_has_oemstr(shp, SMB_PRMS1)) {
1421 		*psnp = smb_serial_valid(s1.smbi_serial);
1422 		*csnp = smb_serial_valid(s3.smbi_serial);
1423 	} else {
1424 		*csnp = smb_serial_valid(s1.smbi_serial);
1425 	}
1426 
1427 	return (0);
1428 }
1429 
1430 const char *
smbios_psn(smbios_hdl_t * shp)1431 smbios_psn(smbios_hdl_t *shp)
1432 {
1433 	const char *psn, *csn;
1434 
1435 	return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : psn);
1436 }
1437 
1438 const char *
smbios_csn(smbios_hdl_t * shp)1439 smbios_csn(smbios_hdl_t *shp)
1440 {
1441 	const char *psn, *csn;
1442 
1443 	return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : csn);
1444 }
1445 
1446 int
smbios_info_extprocessor(smbios_hdl_t * shp,id_t id,smbios_processor_ext_t * epp)1447 smbios_info_extprocessor(smbios_hdl_t *shp, id_t id,
1448     smbios_processor_ext_t *epp)
1449 {
1450 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1451 	smb_processor_ext_t *exp;
1452 
1453 	if (stp == NULL)
1454 		return (-1); /* errno is set for us */
1455 
1456 	if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PROCESSOR)
1457 		return (smb_set_errno(shp, ESMB_TYPE));
1458 
1459 	exp = (smb_processor_ext_t *)(uintptr_t)stp->smbst_hdr;
1460 	bzero(epp, sizeof (smbios_processor_ext_t));
1461 
1462 	epp->smbpe_processor = exp->smbpre_processor;
1463 	epp->smbpe_fru = exp->smbpre_fru;
1464 	epp->smbpe_n = exp->smbpre_n;
1465 	epp->smbpe_apicid = exp->smbpre_apicid;
1466 
1467 	return (0);
1468 }
1469 
1470 int
smbios_info_extport(smbios_hdl_t * shp,id_t id,smbios_port_ext_t * eportp)1471 smbios_info_extport(smbios_hdl_t *shp, id_t id, smbios_port_ext_t *eportp)
1472 {
1473 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1474 	smb_port_ext_t *ep;
1475 
1476 	if (stp == NULL)
1477 		return (-1); /* errno is set for us */
1478 
1479 	if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PORT)
1480 		return (smb_set_errno(shp, ESMB_TYPE));
1481 
1482 	ep = (smb_port_ext_t *)(uintptr_t)stp->smbst_hdr;
1483 	bzero(eportp, sizeof (smbios_port_ext_t));
1484 
1485 	eportp->smbporte_chassis = ep->smbpoe_chassis;
1486 	eportp->smbporte_port = ep->smbpoe_port;
1487 	eportp->smbporte_dtype = ep->smbpoe_dtype;
1488 	eportp->smbporte_devhdl = ep->smbpoe_devhdl;
1489 	eportp->smbporte_phy = ep->smbpoe_phy;
1490 
1491 	return (0);
1492 }
1493 
1494 int
smbios_info_pciexrc(smbios_hdl_t * shp,id_t id,smbios_pciexrc_t * rcp)1495 smbios_info_pciexrc(smbios_hdl_t *shp, id_t id,
1496     smbios_pciexrc_t *rcp)
1497 {
1498 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1499 	smb_pciexrc_t rc;
1500 
1501 	if (stp == NULL)
1502 		return (-1); /* errno is set for us */
1503 
1504 	if (stp->smbst_hdr->smbh_type != SUN_OEM_PCIEXRC)
1505 		return (smb_set_errno(shp, ESMB_TYPE));
1506 
1507 	smb_info_bcopy(stp->smbst_hdr, &rc, sizeof (rc));
1508 	bzero(rcp, sizeof (smbios_pciexrc_t));
1509 
1510 	rcp->smbpcie_bb = rc.smbpciexrc_bboard;
1511 	rcp->smbpcie_bdf = rc.smbpciexrc_bdf;
1512 
1513 	return (0);
1514 }
1515 
1516 int
smbios_info_extmemarray(smbios_hdl_t * shp,id_t id,smbios_memarray_ext_t * emap)1517 smbios_info_extmemarray(smbios_hdl_t *shp, id_t id, smbios_memarray_ext_t *emap)
1518 {
1519 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1520 	smb_memarray_ext_t exma;
1521 
1522 	if (stp == NULL)
1523 		return (-1); /* errno is set for us */
1524 
1525 	if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMARRAY)
1526 		return (smb_set_errno(shp, ESMB_TYPE));
1527 
1528 	smb_info_bcopy(stp->smbst_hdr, &exma, sizeof (exma));
1529 	bzero(emap, sizeof (smbios_memarray_ext_t));
1530 
1531 	emap->smbmae_ma = exma.smbmarre_ma;
1532 	emap->smbmae_comp = exma.smbmarre_component;
1533 	emap->smbmae_bdf = exma.smbmarre_bdf;
1534 
1535 	return (0);
1536 }
1537 
1538 int
smbios_info_extmemdevice(smbios_hdl_t * shp,id_t id,smbios_memdevice_ext_t * emdp)1539 smbios_info_extmemdevice(smbios_hdl_t *shp, id_t id,
1540     smbios_memdevice_ext_t *emdp)
1541 {
1542 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1543 	smb_memdevice_ext_t exmd;
1544 
1545 	if (stp == NULL)
1546 		return (-1); /* errno is set for us */
1547 
1548 	if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMDEVICE)
1549 		return (smb_set_errno(shp, ESMB_TYPE));
1550 
1551 	smb_info_bcopy(stp->smbst_hdr, &exmd, sizeof (exmd));
1552 	bzero(emdp, sizeof (smbios_memdevice_ext_t));
1553 
1554 	emdp->smbmdeve_md = exmd.smbmdeve_mdev;
1555 	emdp->smbmdeve_drch = exmd.smbmdeve_dchan;
1556 	emdp->smbmdeve_ncs  = exmd.smbmdeve_ncs;
1557 	emdp->smbmdeve_cs = exmd.smbmdeve_cs;
1558 
1559 	return (0);
1560 }
1561 
1562 int
smbios_info_powersup(smbios_hdl_t * shp,id_t id,smbios_powersup_t * psup)1563 smbios_info_powersup(smbios_hdl_t *shp, id_t id, smbios_powersup_t *psup)
1564 {
1565 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1566 	smb_powersup_t psu;
1567 
1568 	if (stp == NULL)
1569 		return (-1); /* errno is set for us */
1570 
1571 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_POWERSUP)
1572 		return (smb_set_errno(shp, ESMB_TYPE));
1573 
1574 	/* The minimum length required by the spec is 0x10. */
1575 	if (stp->smbst_hdr->smbh_len < 0x10)
1576 		return (smb_set_errno(shp, ESMB_SHORT));
1577 
1578 	bzero(psup, sizeof (*psup));
1579 	smb_info_bcopy(stp->smbst_hdr, &psu, sizeof (psu));
1580 	psup->smbps_group = psu.smbpsup_group;
1581 	psup->smbps_maxout = psu.smbpsup_max;
1582 
1583 	if (SMB_PSU_CHARS_ISHOT(psu.smbpsup_char))
1584 		psup->smbps_flags |= SMB_POWERSUP_F_HOT;
1585 	if (SMB_PSU_CHARS_ISPRES(psu.smbpsup_char))
1586 		psup->smbps_flags |= SMB_POWERSUP_F_PRESENT;
1587 	if (SMB_PSU_CHARS_ISUNPLUG(psu.smbpsup_char))
1588 		psup->smbps_flags |= SMB_POWERSUP_F_UNPLUG;
1589 
1590 	psup->smbps_ivrs = SMB_PSU_CHARS_IVRS(psu.smbpsup_char);
1591 	psup->smbps_status = SMB_PSU_CHARS_STATUS(psu.smbpsup_char);
1592 	psup->smbps_pstype = SMB_PSU_CHARS_TYPE(psu.smbpsup_char);
1593 
1594 	if (stp->smbst_hdr->smbh_len >= 0x12) {
1595 		psup->smbps_vprobe = psu.smbpsup_vprobe;
1596 	} else {
1597 		psup->smbps_vprobe = 0xffff;
1598 	}
1599 
1600 	if (stp->smbst_hdr->smbh_len >= 0x14) {
1601 		psup->smbps_cooldev = psu.smbpsup_cooldev;
1602 	} else {
1603 		psup->smbps_cooldev = 0xffff;
1604 	}
1605 
1606 	if (stp->smbst_hdr->smbh_len >= 0x16) {
1607 		psup->smbps_iprobe = psu.smbpsup_iprobe;
1608 	} else {
1609 		psup->smbps_iprobe = 0xffff;
1610 	}
1611 
1612 	return (0);
1613 }
1614 
1615 int
smbios_info_vprobe(smbios_hdl_t * shp,id_t id,smbios_vprobe_t * vprobe)1616 smbios_info_vprobe(smbios_hdl_t *shp, id_t id, smbios_vprobe_t *vprobe)
1617 {
1618 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1619 	smb_vprobe_t vp;
1620 
1621 	if (stp == NULL)
1622 		return (-1); /* errno is set for us */
1623 
1624 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_VPROBE)
1625 		return (smb_set_errno(shp, ESMB_TYPE));
1626 
1627 	if (stp->smbst_hdr->smbh_len < SMB_VPROBE_MINLEN)
1628 		return (smb_set_errno(shp, ESMB_SHORT));
1629 
1630 	bzero(vprobe, sizeof (*vprobe));
1631 	smb_info_bcopy(stp->smbst_hdr, &vp, sizeof (vp));
1632 	vprobe->smbvp_description = smb_strptr(stp, vp.smbvpr_descr);
1633 	vprobe->smbvp_location = SMB_VPROBE_LOCATION(vp.smbvpr_locstat);
1634 	vprobe->smbvp_status = SMB_VPROBE_STATUS(vp.smbvpr_locstat);
1635 	vprobe->smbvp_maxval = vp.smbvpr_maxval;
1636 	vprobe->smbvp_minval = vp.smbvpr_minval;
1637 	vprobe->smbvp_resolution = vp.smbvpr_resolution;
1638 	vprobe->smbvp_tolerance	= vp.smbvpr_tolerance;
1639 	vprobe->smbvp_accuracy = vp.smbvpr_accuracy;
1640 
1641 	if (stp->smbst_hdr->smbh_len >= SMB_VPROBE_NOMINAL_MINLEN) {
1642 		vprobe->smbvp_nominal = vp.smbvpr_nominal;
1643 	} else {
1644 		vprobe->smbvp_nominal = SMB_PROBE_UNKNOWN_VALUE;
1645 	}
1646 
1647 	return (0);
1648 }
1649 
1650 int
smbios_info_cooldev(smbios_hdl_t * shp,id_t id,smbios_cooldev_t * cooldev)1651 smbios_info_cooldev(smbios_hdl_t *shp, id_t id, smbios_cooldev_t *cooldev)
1652 {
1653 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1654 	smb_cooldev_t cd;
1655 
1656 	if (stp == NULL)
1657 		return (-1); /* errno is set for us */
1658 
1659 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_COOLDEV)
1660 		return (smb_set_errno(shp, ESMB_TYPE));
1661 
1662 	if (stp->smbst_hdr->smbh_len < SMB_COOLDEV_MINLEN)
1663 		return (smb_set_errno(shp, ESMB_SHORT));
1664 
1665 	bzero(cooldev, sizeof (*cooldev));
1666 	smb_info_bcopy(stp->smbst_hdr, &cd, sizeof (cd));
1667 	cooldev->smbcd_tprobe = cd.smbcdev_tprobe;
1668 	cooldev->smbcd_type = SMB_COOLDEV_TYPE(cd.smbcdev_typstat);
1669 	cooldev->smbcd_status = SMB_COOLDEV_STATUS(cd.smbcdev_typstat);
1670 	cooldev->smbcd_group = cd.smbcdev_group;
1671 	cooldev->smbcd_oem = cd.smbcdev_oem;
1672 
1673 	if (stp->smbst_hdr->smbh_len >= SMB_COOLDEV_NOMINAL_MINLEN) {
1674 		cooldev->smbcd_nominal = cd.smbcdev_nominal;
1675 	} else {
1676 		cooldev->smbcd_nominal = SMB_PROBE_UNKNOWN_VALUE;
1677 	}
1678 
1679 	/*
1680 	 * The description field was added in SMBIOS version 2.7. The
1681 	 * SMB_TYPE_COOLDEV support was only added after all of the 2.7+ fields
1682 	 * were added in the spec. So while a user may request an older version,
1683 	 * we don't have to worry about old structures and just simply skip it
1684 	 * if they're not asking for it.
1685 	 */
1686 	if (smb_libgteq(shp, SMB_VERSION_27) &&
1687 	    smb_gteq(shp, SMB_VERSION_27) &&
1688 	    stp->smbst_hdr->smbh_len >= SMB_COOLDEV_DESCR_MINLEN) {
1689 		cooldev->smbcd_descr = smb_strptr(stp, cd.smbcdev_descr);
1690 	} else {
1691 		cooldev->smbcd_descr = NULL;
1692 	}
1693 
1694 	return (0);
1695 }
1696 
1697 int
smbios_info_tprobe(smbios_hdl_t * shp,id_t id,smbios_tprobe_t * tprobe)1698 smbios_info_tprobe(smbios_hdl_t *shp, id_t id, smbios_tprobe_t *tprobe)
1699 {
1700 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1701 	smb_tprobe_t tp;
1702 
1703 	if (stp == NULL)
1704 		return (-1); /* errno is set for us */
1705 
1706 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_TPROBE)
1707 		return (smb_set_errno(shp, ESMB_TYPE));
1708 
1709 	if (stp->smbst_hdr->smbh_len < SMB_TPROBE_MINLEN)
1710 		return (smb_set_errno(shp, ESMB_SHORT));
1711 
1712 	bzero(tprobe, sizeof (*tprobe));
1713 	smb_info_bcopy(stp->smbst_hdr, &tp, sizeof (tp));
1714 	tprobe->smbtp_description = smb_strptr(stp, tp.smbtpr_descr);
1715 	tprobe->smbtp_location = SMB_TPROBE_LOCATION(tp.smbtpr_locstat);
1716 	tprobe->smbtp_status = SMB_TPROBE_STATUS(tp.smbtpr_locstat);
1717 	tprobe->smbtp_maxval = tp.smbtpr_maxval;
1718 	tprobe->smbtp_minval = tp.smbtpr_minval;
1719 	tprobe->smbtp_resolution = tp.smbtpr_resolution;
1720 	tprobe->smbtp_tolerance	= tp.smbtpr_tolerance;
1721 	tprobe->smbtp_accuracy = tp.smbtpr_accuracy;
1722 
1723 	if (stp->smbst_hdr->smbh_len >= SMB_TPROBE_NOMINAL_MINLEN) {
1724 		tprobe->smbtp_nominal = tp.smbtpr_nominal;
1725 	} else {
1726 		tprobe->smbtp_nominal = SMB_PROBE_UNKNOWN_VALUE;
1727 	}
1728 
1729 	return (0);
1730 }
1731 
1732 int
smbios_info_iprobe(smbios_hdl_t * shp,id_t id,smbios_iprobe_t * iprobe)1733 smbios_info_iprobe(smbios_hdl_t *shp, id_t id, smbios_iprobe_t *iprobe)
1734 {
1735 	const smb_struct_t *sip = smb_lookup_id(shp, id);
1736 	smb_iprobe_t ip;
1737 
1738 	if (sip == NULL)
1739 		return (-1); /* errno is set for us */
1740 
1741 	if (sip->smbst_hdr->smbh_type != SMB_TYPE_IPROBE)
1742 		return (smb_set_errno(shp, ESMB_TYPE));
1743 
1744 	if (sip->smbst_hdr->smbh_len < SMB_IPROBE_MINLEN)
1745 		return (smb_set_errno(shp, ESMB_SHORT));
1746 
1747 	bzero(iprobe, sizeof (*iprobe));
1748 	smb_info_bcopy(sip->smbst_hdr, &ip, sizeof (ip));
1749 	iprobe->smbip_description = smb_strptr(sip, ip.smbipr_descr);
1750 	iprobe->smbip_location = SMB_IPROBE_LOCATION(ip.smbipr_locstat);
1751 	iprobe->smbip_status = SMB_IPROBE_STATUS(ip.smbipr_locstat);
1752 	iprobe->smbip_maxval = ip.smbipr_maxval;
1753 	iprobe->smbip_minval = ip.smbipr_minval;
1754 	iprobe->smbip_resolution = ip.smbipr_resolution;
1755 	iprobe->smbip_tolerance	= ip.smbipr_tolerance;
1756 	iprobe->smbip_accuracy = ip.smbipr_accuracy;
1757 
1758 	if (sip->smbst_hdr->smbh_len >= SMB_IPROBE_NOMINAL_MINLEN) {
1759 		iprobe->smbip_nominal = ip.smbipr_nominal;
1760 	} else {
1761 		iprobe->smbip_nominal = SMB_PROBE_UNKNOWN_VALUE;
1762 	}
1763 
1764 	return (0);
1765 }
1766 
1767 int
smbios_info_processor_info(smbios_hdl_t * shp,id_t id,smbios_processor_info_t * proc)1768 smbios_info_processor_info(smbios_hdl_t *shp, id_t id,
1769     smbios_processor_info_t *proc)
1770 {
1771 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1772 	smb_processor_info_t pi;
1773 
1774 	if (stp == NULL)
1775 		return (-1); /* errno is set for us */
1776 
1777 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR_INFO)
1778 		return (smb_set_errno(shp, ESMB_TYPE));
1779 
1780 	if (stp->smbst_hdr->smbh_len < sizeof (pi))
1781 		return (smb_set_errno(shp, ESMB_SHORT));
1782 
1783 	bzero(proc, sizeof (*proc));
1784 	smb_info_bcopy(stp->smbst_hdr, &pi, sizeof (pi));
1785 
1786 	if (sizeof (pi) + pi.smbpai_len > stp->smbst_hdr->smbh_len)
1787 		return (smb_set_errno(shp, ESMB_CORRUPT));
1788 
1789 	proc->smbpi_processor = pi.smbpai_proc;
1790 	proc->smbpi_ptype = pi.smbpai_type;
1791 
1792 	return (0);
1793 }
1794 
1795 int
smbios_info_processor_riscv(smbios_hdl_t * shp,id_t id,smbios_processor_info_riscv_t * riscv)1796 smbios_info_processor_riscv(smbios_hdl_t *shp, id_t id,
1797     smbios_processor_info_riscv_t *riscv)
1798 {
1799 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1800 	const smb_processor_info_t *proc;
1801 	const smb_processor_info_riscv_t *rv;
1802 
1803 	if (stp == NULL) {
1804 		return (-1); /* errno is set for us */
1805 	}
1806 
1807 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR_INFO) {
1808 		return (smb_set_errno(shp, ESMB_TYPE));
1809 	}
1810 
1811 	if (stp->smbst_hdr->smbh_len < sizeof (*proc)) {
1812 		return (smb_set_errno(shp, ESMB_SHORT));
1813 	}
1814 
1815 	proc = (const smb_processor_info_t *)stp->smbst_hdr;
1816 	if (sizeof (*proc) + proc->smbpai_len > stp->smbst_hdr->smbh_len) {
1817 		return (smb_set_errno(shp, ESMB_CORRUPT));
1818 	}
1819 
1820 	switch (proc->smbpai_type) {
1821 	case SMB_PROCINFO_T_RV32:
1822 	case SMB_PROCINFO_T_RV64:
1823 	case SMB_PROCINFO_T_RV128:
1824 		break;
1825 	default:
1826 		return (smb_set_errno(shp, ESMB_TYPE));
1827 	}
1828 
1829 	if (stp->smbst_hdr->smbh_len < sizeof (*proc) + sizeof (*rv)) {
1830 		return (smb_set_errno(shp, ESMB_SHORT));
1831 	}
1832 	rv = (const smb_processor_info_riscv_t *)&proc->smbpai_data[0];
1833 	if (rv->smbpairv_len != sizeof (*rv)) {
1834 		return (smb_set_errno(shp, ESMB_CORRUPT));
1835 	}
1836 
1837 	bcopy(rv->smbpairv_hartid, riscv->smbpirv_hartid,
1838 	    sizeof (riscv->smbpirv_hartid));
1839 	bcopy(rv->smbpairv_vendid, riscv->smbpirv_vendid,
1840 	    sizeof (riscv->smbpirv_vendid));
1841 	bcopy(rv->smbpairv_archid, riscv->smbpirv_archid,
1842 	    sizeof (riscv->smbpirv_archid));
1843 	bcopy(rv->smbpairv_machid, riscv->smbpirv_machid,
1844 	    sizeof (riscv->smbpirv_machid));
1845 	bcopy(rv->smbpairv_metdi, riscv->smbpirv_metdi,
1846 	    sizeof (riscv->smbpirv_metdi));
1847 	bcopy(rv->smbpairv_mitdi, riscv->smbpirv_mitdi,
1848 	    sizeof (riscv->smbpirv_mitdi));
1849 	riscv->smbpirv_isa = rv->smbpairv_isa;
1850 	riscv->smbpirv_privlvl = rv->smbpairv_privlvl;
1851 	riscv->smbpirv_boothart = rv->smbpairv_boot;
1852 	riscv->smbpirv_xlen = rv->smbpairv_xlen;
1853 	riscv->smbpirv_mxlen = rv->smbpairv_mxlen;
1854 	riscv->smbpirv_sxlen = rv->smbpairv_sxlen;
1855 	riscv->smbpirv_uxlen = rv->smbpairv_uxlen;
1856 
1857 	return (0);
1858 }
1859 
1860 int
smbios_info_pointdev(smbios_hdl_t * shp,id_t id,smbios_pointdev_t * pd)1861 smbios_info_pointdev(smbios_hdl_t *shp, id_t id, smbios_pointdev_t *pd)
1862 {
1863 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1864 	smb_pointdev_t point;
1865 
1866 	if (stp == NULL) {
1867 		return (-1); /* errno is set for us */
1868 	}
1869 
1870 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_POINTDEV) {
1871 		return (smb_set_errno(shp, ESMB_TYPE));
1872 	}
1873 
1874 	if (stp->smbst_hdr->smbh_len < sizeof (point)) {
1875 		return (smb_set_errno(shp, ESMB_SHORT));
1876 	}
1877 
1878 	bzero(pd, sizeof (*pd));
1879 	smb_info_bcopy(stp->smbst_hdr, &point, sizeof (point));
1880 
1881 	pd->smbpd_type = point.smbpdev_type;
1882 	pd->smbpd_iface = point.smbpdev_iface;
1883 	pd->smbpd_nbuttons = point.smbpdev_nbuttons;
1884 
1885 	return (0);
1886 }
1887 
1888 int
smbios_info_battery(smbios_hdl_t * shp,id_t id,smbios_battery_t * bp)1889 smbios_info_battery(smbios_hdl_t *shp, id_t id, smbios_battery_t *bp)
1890 {
1891 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1892 	smb_battery_t bat;
1893 
1894 	if (stp == NULL) {
1895 		return (-1); /* errno is set for us */
1896 	}
1897 
1898 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_BATTERY) {
1899 		return (smb_set_errno(shp, ESMB_TYPE));
1900 	}
1901 
1902 	if (stp->smbst_hdr->smbh_len < sizeof (bat)) {
1903 		return (smb_set_errno(shp, ESMB_SHORT));
1904 	}
1905 
1906 	bzero(bp, sizeof (*bp));
1907 	smb_info_bcopy(stp->smbst_hdr, &bat, sizeof (bat));
1908 
1909 	/*
1910 	 * This may be superseded by the SBDS data.
1911 	 */
1912 	if (bat.smbbat_date != 0) {
1913 		bp->smbb_date = smb_strptr(stp, bat.smbbat_date);
1914 	} else {
1915 		bp->smbb_date = NULL;
1916 	}
1917 
1918 	/*
1919 	 * This may be superseded by the SBDS data.
1920 	 */
1921 	if (bat.smbbat_serial != 0) {
1922 		bp->smbb_serial = smb_strptr(stp, bat.smbbat_serial);
1923 	} else {
1924 		bp->smbb_serial = NULL;
1925 	}
1926 
1927 	bp->smbb_chem = bat.smbbat_chem;
1928 	bp->smbb_cap = bat.smbbat_cap;
1929 	if (bat.smbbat_mult > 0) {
1930 		bp->smbb_cap *= bat.smbbat_mult;
1931 	}
1932 	bp->smbb_volt = bat.smbbat_volt;
1933 	bp->smbb_version = smb_strptr(stp, bat.smbbat_version);
1934 	bp->smbb_err = bat.smbbat_err;
1935 	bp->smbb_ssn = bat.smbbat_ssn;
1936 	bp->smbb_syear = 1980 + (bat.smbbat_sdate >> 9);
1937 	bp->smbb_smonth = (bat.smbbat_sdate >> 5) & 0xf;
1938 	bp->smbb_sday = bat.smbbat_sdate & 0x1f;
1939 	bp->smbb_schem = smb_strptr(stp, bat.smbbat_schem);
1940 	bp->smbb_oemdata = bat.smbbat_oemdata;
1941 
1942 	return (0);
1943 }
1944 
1945 int
smbios_info_strprop(smbios_hdl_t * shp,id_t id,smbios_strprop_t * str)1946 smbios_info_strprop(smbios_hdl_t *shp, id_t id, smbios_strprop_t *str)
1947 {
1948 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1949 	smb_strprop_t prop;
1950 
1951 	if (stp == NULL) {
1952 		return (-1); /* errno is set for us */
1953 	}
1954 
1955 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_STRPROP) {
1956 		return (smb_set_errno(shp, ESMB_TYPE));
1957 	}
1958 
1959 	if (stp->smbst_hdr->smbh_len < sizeof (prop)) {
1960 		return (smb_set_errno(shp, ESMB_SHORT));
1961 	}
1962 
1963 	if (stp->smbst_hdr->smbh_len > sizeof (prop)) {
1964 		return (smb_set_errno(shp, ESMB_CORRUPT));
1965 	}
1966 
1967 	bzero(str, sizeof (*str));
1968 	smb_info_bcopy(stp->smbst_hdr, &prop, sizeof (prop));
1969 
1970 	str->smbsp_parent = prop.smbstrp_phdl;
1971 	str->smbsp_prop_id = prop.smbstrp_prop_id;
1972 	str->smbsp_prop_val = smb_strptr(stp, prop.smbstrp_prop_val);
1973 
1974 	return (0);
1975 }
1976 
1977 int
smbios_info_fwinfo(smbios_hdl_t * shp,id_t id,smbios_fwinfo_t * fwinfo)1978 smbios_info_fwinfo(smbios_hdl_t *shp, id_t id, smbios_fwinfo_t *fwinfo)
1979 {
1980 	const smb_struct_t *stp = smb_lookup_id(shp, id);
1981 	smb_fwinfo_t fw;
1982 
1983 	if (stp == NULL) {
1984 		return (-1); /* errno is set for us */
1985 	}
1986 
1987 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_FWINFO) {
1988 		return (smb_set_errno(shp, ESMB_TYPE));
1989 	}
1990 
1991 	if (stp->smbst_hdr->smbh_len < sizeof (fw)) {
1992 		return (smb_set_errno(shp, ESMB_SHORT));
1993 	}
1994 
1995 	/*
1996 	 * The verion and manufacturer are part of smbios_info_common().
1997 	 */
1998 	bzero(fwinfo, sizeof (*fwinfo));
1999 	smb_info_bcopy(stp->smbst_hdr, &fw, sizeof (fw));
2000 	fwinfo->smbfw_name = smb_strptr(stp, fw.smbfwii_name);
2001 	fwinfo->smbfw_id = smb_strptr(stp, fw.smbfwii_id);
2002 	fwinfo->smbfw_reldate = smb_strptr(stp, fw.smbfwii_reldate);
2003 	fwinfo->smbfw_lsv = smb_strptr(stp, fw.smbfwii_lsv);
2004 	fwinfo->smbfw_imgsz = fw.smbfwii_imgsz;
2005 	fwinfo->smbfw_chars = fw.smbfwii_chars;
2006 	fwinfo->smbfw_state = fw.smbfwii_state;
2007 	fwinfo->smbfw_ncomps = fw.smbfwii_ncomps;
2008 	fwinfo->smbfw_vers_fmt = fw.smbfwii_vers_fmt;
2009 	fwinfo->smbfw_id_fmt = fw.smbfwii_id_fmt;
2010 
2011 	return (0);
2012 }
2013 
2014 int
smbios_info_fwinfo_comps(smbios_hdl_t * shp,id_t id,uint_t * ncompsp,smbios_fwinfo_comp_t ** compsp)2015 smbios_info_fwinfo_comps(smbios_hdl_t *shp, id_t id, uint_t *ncompsp,
2016     smbios_fwinfo_comp_t **compsp)
2017 {
2018 	const smb_struct_t *stp = smb_lookup_id(shp, id);
2019 	smbios_fwinfo_comp_t *comps;
2020 	smb_fwinfo_t fw;
2021 	size_t need;
2022 	uint_t i;
2023 
2024 	if (stp == NULL) {
2025 		return (-1); /* errno is set for us */
2026 	}
2027 
2028 	if (stp->smbst_hdr->smbh_type != SMB_TYPE_FWINFO) {
2029 		return (smb_set_errno(shp, ESMB_TYPE));
2030 	}
2031 
2032 	if (stp->smbst_hdr->smbh_len < sizeof (fw)) {
2033 		return (smb_set_errno(shp, ESMB_SHORT));
2034 	}
2035 
2036 	smb_info_bcopy(stp->smbst_hdr, &fw, sizeof (fw));
2037 	if (fw.smbfwii_ncomps == 0) {
2038 		*ncompsp = 0;
2039 		*compsp = NULL;
2040 		return (0);
2041 	}
2042 
2043 	need = fw.smbfwii_ncomps * sizeof (uint16_t) + sizeof (smb_fwinfo_t);
2044 	if (stp->smbst_hdr->smbh_len < need) {
2045 		return (smb_set_errno(shp, ESMB_SHORT));
2046 	}
2047 
2048 	comps = smb_alloc(fw.smbfwii_ncomps * sizeof (smbios_fwinfo_comp_t));
2049 	if (comps == NULL) {
2050 		return (smb_set_errno(shp, ESMB_NOMEM));
2051 	}
2052 
2053 	for (i = 0; i < fw.smbfwii_ncomps; i++) {
2054 		uint16_t id;
2055 		size_t off = sizeof (smb_fwinfo_t) + sizeof (uint16_t) * i;
2056 		smb_info_bcopy_offset(stp->smbst_hdr, &id, sizeof (id), off);
2057 		comps[i].smbfwe_id = id;
2058 	}
2059 
2060 	*ncompsp = fw.smbfwii_ncomps;
2061 	*compsp = comps;
2062 
2063 	return (0);
2064 }
2065 
2066 void
smbios_info_fwinfo_comps_free(smbios_hdl_t * shp,uint_t ncomps,smbios_fwinfo_comp_t * comps)2067 smbios_info_fwinfo_comps_free(smbios_hdl_t *shp, uint_t ncomps,
2068     smbios_fwinfo_comp_t *comps)
2069 {
2070 	size_t sz = ncomps * sizeof (smbios_fwinfo_comp_t);
2071 
2072 	if (ncomps == 0) {
2073 		ASSERT3P(comps, ==, NULL);
2074 		return;
2075 	}
2076 
2077 	smb_free(comps, sz);
2078 }
2079