xref: /illumos-gate/usr/src/cmd/smbios/smbios.c (revision b4fb003914e70b41d96dec8011864f6af1faf3ef)
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 (c) 2017, Joyent, Inc.
25  * Copyright 2022 Oxide Computer Company
26  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 #include <sys/sysmacros.h>
31 #include <sys/param.h>
32 
33 #include <smbios.h>
34 #include <alloca.h>
35 #include <limits.h>
36 #include <unistd.h>
37 #include <strings.h>
38 #include <stdlib.h>
39 #include <stdarg.h>
40 #include <stdio.h>
41 #include <fcntl.h>
42 #include <errno.h>
43 #include <ctype.h>
44 #include <libjedec.h>
45 
46 #define	SMBIOS_SUCCESS	0
47 #define	SMBIOS_ERROR	1
48 #define	SMBIOS_USAGE	2
49 
50 static const char *g_pname;
51 static int g_hdr;
52 
53 static int opt_e;
54 static int opt_i = -1;
55 static int opt_O;
56 static int opt_s;
57 static int opt_t = -1;
58 static int opt_x;
59 
60 static boolean_t
61 smbios_vergteq(smbios_version_t *v, uint_t major, uint_t minor)
62 {
63 	if (v->smbv_major > major)
64 		return (B_TRUE);
65 	if (v->smbv_major == major &&
66 	    v->smbv_minor >= minor)
67 		return (B_TRUE);
68 	return (B_FALSE);
69 }
70 
71 /*PRINTFLIKE2*/
72 static void
73 smbios_warn(smbios_hdl_t *shp, const char *format, ...)
74 {
75 	va_list ap;
76 
77 	va_start(ap, format);
78 	(void) vfprintf(stderr, format, ap);
79 	va_end(ap);
80 
81 	if (shp != NULL) {
82 		(void) fprintf(stderr, ": %s",
83 		    smbios_errmsg(smbios_errno(shp)));
84 	}
85 
86 	(void) fprintf(stderr, "\n");
87 }
88 
89 /*PRINTFLIKE2*/
90 static void
91 oprintf(FILE *fp, const char *format, ...)
92 {
93 	va_list ap;
94 
95 	va_start(ap, format);
96 	(void) vfprintf(fp, format, ap);
97 	va_end(ap);
98 }
99 
100 /*PRINTFLIKE3*/
101 static void
102 desc_printf(const char *d, FILE *fp, const char *format, ...)
103 {
104 	va_list ap;
105 
106 	va_start(ap, format);
107 	(void) vfprintf(fp, format, ap);
108 	va_end(ap);
109 
110 	if (d != NULL)
111 		(void) fprintf(fp, " (%s)\n", d);
112 	else
113 		(void) fprintf(fp, "\n");
114 }
115 
116 static void
117 flag_printf(FILE *fp, const char *s, uint_t flags, size_t bits,
118     const char *(*flag_name)(uint_t), const char *(*flag_desc)(uint_t))
119 {
120 	size_t i;
121 
122 	oprintf(fp, "  %s: 0x%x\n", s, flags);
123 
124 	for (i = 0; i < bits; i++) {
125 		uint_t f = 1 << i;
126 		const char *n;
127 
128 		if (!(flags & f))
129 			continue;
130 
131 		if ((n = flag_name(f)) != NULL)
132 			desc_printf(flag_desc(f), fp, "\t%s", n);
133 		else
134 			desc_printf(flag_desc(f), fp, "\t0x%x", f);
135 	}
136 }
137 
138 static void
139 flag64_printf(FILE *fp, const char *s, uint64_t flags, size_t bits,
140     const char *(*flag_name)(uint64_t), const char *(*flag_desc)(uint64_t))
141 {
142 	size_t i;
143 
144 	oprintf(fp, "  %s: 0x%llx\n", s, (u_longlong_t)flags);
145 
146 	for (i = 0; i < bits; i++) {
147 		u_longlong_t f = 1ULL << i;
148 		const char *n;
149 
150 		if (!(flags & f))
151 			continue;
152 
153 		if ((n = flag_name(f)) != NULL)
154 			desc_printf(flag_desc(f), fp, "\t%s", n);
155 		else
156 			desc_printf(flag_desc(f), fp, "\t0x%llx", f);
157 	}
158 }
159 
160 static void
161 id_printf(FILE *fp, const char *s, id_t id)
162 {
163 	switch (id) {
164 	case SMB_ID_NONE:
165 		oprintf(fp, "%sNone\n", s);
166 		break;
167 	case SMB_ID_NOTSUP:
168 		oprintf(fp, "%sNot Supported\n", s);
169 		break;
170 	default:
171 		oprintf(fp, "%s%u\n", s, (uint_t)id);
172 	}
173 }
174 
175 static void
176 jedec_print(FILE *fp, const char *desc, uint_t id)
177 {
178 	const char *name;
179 	uint_t cont, vendor;
180 
181 	/*
182 	 * SMBIOS encodes data in the way that the underlying memory standard
183 	 * does. In this case, the upper byte indicates the vendor that we care
184 	 * about while the lower byte indicates the number of continuations that
185 	 * are needed. libjedec indexes this based on zero (e.g. table 1 is zero
186 	 * continuations), which is how the spec encodes it. We add one so that
187 	 * we can match how the spec describes it.
188 	 */
189 	vendor = id >> 8;
190 	cont = id & 0x7f;
191 	name = libjedec_vendor_string(cont, vendor);
192 	if (name == NULL) {
193 		oprintf(fp, "  %s: Bank: 0x%x Vendor: 0x%x\n", desc, cont + 1,
194 		    vendor);
195 	} else {
196 		oprintf(fp, "  %s: Bank: 0x%x Vendor: 0x%x (%s)\n", desc,
197 		    cont + 1, vendor, name);
198 	}
199 }
200 
201 /*
202  * Print a 128-bit data as a series of 16 hex digits.
203  */
204 static void
205 u128_print(FILE *fp, const char *desc, const uint8_t *data)
206 {
207 	uint_t i;
208 
209 	oprintf(fp, "%s: ", desc);
210 	for (i = 0; i < 16; i++) {
211 		oprintf(fp, " %02x", data[i]);
212 	}
213 	oprintf(fp, "\n");
214 }
215 
216 /*
217  * Print a string that came from an SMBIOS table. We do this character by
218  * character so we can potentially escape strings.
219  */
220 static void
221 str_print_label(FILE *fp, const char *header, const char *str, boolean_t label)
222 {
223 	const char *c;
224 
225 	oprintf(fp, header);
226 	if (label) {
227 		oprintf(fp, ": ");
228 	}
229 
230 	for (c = str; *c != '\0'; c++) {
231 		if (isprint(*c)) {
232 			oprintf(fp, "%c", *c);
233 		} else {
234 			oprintf(fp, "\\x%02x", *c);
235 		}
236 	}
237 
238 	oprintf(fp, "\n");
239 }
240 
241 static void
242 str_print_nolabel(FILE *fp, const char *ws, const char *str)
243 {
244 	return (str_print_label(fp, ws, str, B_FALSE));
245 }
246 
247 static void
248 str_print(FILE *fp, const char *header, const char *str)
249 {
250 	return (str_print_label(fp, header, str, B_TRUE));
251 }
252 
253 static int
254 check_oem(smbios_hdl_t *shp)
255 {
256 	int i;
257 	int cnt;
258 	int rv;
259 	id_t oem_id;
260 	smbios_struct_t s;
261 	const char **oem_str;
262 
263 	rv = smbios_lookup_type(shp, SMB_TYPE_OEMSTR, &s);
264 	if (rv != 0) {
265 		return (-1);
266 	}
267 
268 	oem_id = s.smbstr_id;
269 
270 	cnt = smbios_info_strtab(shp, oem_id, 0, NULL);
271 	if (cnt > 0) {
272 		oem_str =  alloca(sizeof (char *) * cnt);
273 		(void) smbios_info_strtab(shp, oem_id, cnt, oem_str);
274 
275 		for (i = 0; i < cnt; i++) {
276 			if (strncmp(oem_str[i], SMB_PRMS1,
277 			    strlen(SMB_PRMS1) + 1) == 0) {
278 				return (0);
279 			}
280 		}
281 	}
282 
283 	return (-1);
284 }
285 
286 static void
287 print_smbios_21(smbios_21_entry_t *ep, FILE *fp)
288 {
289 	int i;
290 
291 	oprintf(fp, "Entry Point Anchor Tag: %*.*s\n",
292 	    (int)sizeof (ep->smbe_eanchor), (int)sizeof (ep->smbe_eanchor),
293 	    ep->smbe_eanchor);
294 
295 	oprintf(fp, "Entry Point Checksum: 0x%x\n", ep->smbe_ecksum);
296 	oprintf(fp, "Entry Point Length: %u\n", ep->smbe_elen);
297 	oprintf(fp, "Entry Point Version: %u.%u\n",
298 	    ep->smbe_major, ep->smbe_minor);
299 	oprintf(fp, "Max Structure Size: %u\n", ep->smbe_maxssize);
300 	oprintf(fp, "Entry Point Revision: 0x%x\n", ep->smbe_revision);
301 
302 	oprintf(fp, "Entry Point Revision Data:");
303 	for (i = 0; i < sizeof (ep->smbe_format); i++)
304 		oprintf(fp, " 0x%02x", ep->smbe_format[i]);
305 	oprintf(fp, "\n");
306 
307 	oprintf(fp, "Intermediate Anchor Tag: %*.*s\n",
308 	    (int)sizeof (ep->smbe_ianchor), (int)sizeof (ep->smbe_ianchor),
309 	    ep->smbe_ianchor);
310 
311 	oprintf(fp, "Intermediate Checksum: 0x%x\n", ep->smbe_icksum);
312 	oprintf(fp, "Structure Table Length: %u\n", ep->smbe_stlen);
313 	oprintf(fp, "Structure Table Address: 0x%x\n", ep->smbe_staddr);
314 	oprintf(fp, "Structure Table Entries: %u\n", ep->smbe_stnum);
315 	oprintf(fp, "DMI BCD Revision: 0x%x\n", ep->smbe_bcdrev);
316 }
317 
318 static void
319 print_smbios_30(smbios_30_entry_t *ep, FILE *fp)
320 {
321 	oprintf(fp, "Entry Point Anchor Tag: %*.*s\n",
322 	    (int)sizeof (ep->smbe_eanchor), (int)sizeof (ep->smbe_eanchor),
323 	    ep->smbe_eanchor);
324 
325 	oprintf(fp, "Entry Point Checksum: 0x%x\n", ep->smbe_ecksum);
326 	oprintf(fp, "Entry Point Length: %u\n", ep->smbe_elen);
327 	oprintf(fp, "SMBIOS Version: %u.%u\n",
328 	    ep->smbe_major, ep->smbe_minor);
329 	oprintf(fp, "SMBIOS DocRev: 0x%x\n", ep->smbe_docrev);
330 	oprintf(fp, "Entry Point Revision: 0x%x\n", ep->smbe_revision);
331 
332 	oprintf(fp, "Structure Table Length: %u\n", ep->smbe_stlen);
333 	oprintf(fp, "Structure Table Address: 0x%" PRIx64 "\n",
334 	    ep->smbe_staddr);
335 }
336 
337 static void
338 print_smbios(smbios_hdl_t *shp, FILE *fp)
339 {
340 	smbios_entry_t ep;
341 
342 	switch (smbios_info_smbios(shp, &ep)) {
343 	case SMBIOS_ENTRY_POINT_21:
344 		print_smbios_21(&ep.ep21, fp);
345 		break;
346 	case SMBIOS_ENTRY_POINT_30:
347 		print_smbios_30(&ep.ep30, fp);
348 		break;
349 	}
350 }
351 
352 static void
353 print_common(const smbios_info_t *ip, FILE *fp)
354 {
355 	if (ip->smbi_manufacturer[0] != '\0')
356 		str_print(fp, "  Manufacturer", ip->smbi_manufacturer);
357 	if (ip->smbi_product[0] != '\0')
358 		str_print(fp, "  Product", ip->smbi_product);
359 	if (ip->smbi_version[0] != '\0')
360 		str_print(fp, "  Version", ip->smbi_version);
361 	if (ip->smbi_serial[0] != '\0')
362 		str_print(fp, "  Serial Number", ip->smbi_serial);
363 	if (ip->smbi_asset[0] != '\0')
364 		str_print(fp, "  Asset Tag", ip->smbi_asset);
365 	if (ip->smbi_location[0] != '\0')
366 		str_print(fp, "  Location Tag", ip->smbi_location);
367 	if (ip->smbi_part[0] != '\0')
368 		str_print(fp, "  Part Number", ip->smbi_part);
369 }
370 
371 static void
372 print_bios(smbios_hdl_t *shp, FILE *fp)
373 {
374 	smbios_bios_t b;
375 
376 	if (smbios_info_bios(shp, &b) == -1) {
377 		smbios_warn(shp, "failed to read BIOS information");
378 		return;
379 	}
380 
381 	str_print(fp, "  Vendor", b.smbb_vendor);
382 	str_print(fp, "  Version String", b.smbb_version);
383 	str_print(fp, "  Release Date", b.smbb_reldate);
384 	oprintf(fp, "  Address Segment: 0x%x\n", b.smbb_segment);
385 	oprintf(fp, "  ROM Size: %" PRIu64 " bytes\n", b.smbb_extromsize);
386 	oprintf(fp, "  Image Size: %u bytes\n", b.smbb_runsize);
387 
388 	flag64_printf(fp, "Characteristics",
389 	    b.smbb_cflags, sizeof (b.smbb_cflags) * NBBY,
390 	    smbios_bios_flag_name, smbios_bios_flag_desc);
391 
392 	if (b.smbb_nxcflags > SMB_BIOSXB_1) {
393 		flag_printf(fp, "Characteristics Extension Byte 1",
394 		    b.smbb_xcflags[SMB_BIOSXB_1],
395 		    sizeof (b.smbb_xcflags[SMB_BIOSXB_1]) * NBBY,
396 		    smbios_bios_xb1_name, smbios_bios_xb1_desc);
397 	}
398 
399 	if (b.smbb_nxcflags > SMB_BIOSXB_2) {
400 		flag_printf(fp, "Characteristics Extension Byte 2",
401 		    b.smbb_xcflags[SMB_BIOSXB_2],
402 		    sizeof (b.smbb_xcflags[SMB_BIOSXB_2]) * NBBY,
403 		    smbios_bios_xb2_name, smbios_bios_xb2_desc);
404 	}
405 
406 	if (b.smbb_nxcflags > SMB_BIOSXB_BIOS_MIN) {
407 		oprintf(fp, "  Version Number: %u.%u\n",
408 		    b.smbb_biosv.smbv_major, b.smbb_biosv.smbv_minor);
409 	}
410 
411 	/*
412 	 * If the major and minor versions are 0xff then that indicates that the
413 	 * embedded controller does not exist.
414 	 */
415 	if (b.smbb_nxcflags > SMB_BIOSXB_ECFW_MIN &&
416 	    b.smbb_ecfwv.smbv_major != 0xff &&
417 	    b.smbb_ecfwv.smbv_minor != 0xff) {
418 		oprintf(fp, "  Embedded Ctlr Firmware Version Number: %u.%u\n",
419 		    b.smbb_ecfwv.smbv_major, b.smbb_ecfwv.smbv_minor);
420 	}
421 }
422 
423 static void
424 print_system(smbios_hdl_t *shp, FILE *fp)
425 {
426 	smbios_system_t s;
427 	uint_t i;
428 
429 	if (smbios_info_system(shp, &s) == -1) {
430 		smbios_warn(shp, "failed to read system information");
431 		return;
432 	}
433 
434 	oprintf(fp, "  UUID: ");
435 	for (i = 0; i < s.smbs_uuidlen; i++) {
436 		oprintf(fp, "%02x", s.smbs_uuid[i]);
437 		if (i == 3 || i == 5 || i == 7 || i == 9)
438 			oprintf(fp, "-");
439 	}
440 	oprintf(fp, "\n");
441 
442 	desc_printf(smbios_system_wakeup_desc(s.smbs_wakeup),
443 	    fp, "  Wake-Up Event: 0x%x", s.smbs_wakeup);
444 
445 	str_print(fp, "  SKU Number", s.smbs_sku);
446 	str_print(fp, "  Family", s.smbs_family);
447 }
448 
449 static void
450 print_bboard(smbios_hdl_t *shp, id_t id, FILE *fp)
451 {
452 	smbios_bboard_t b;
453 	int chdl_cnt;
454 
455 	if (smbios_info_bboard(shp, id, &b) != 0) {
456 		smbios_warn(shp, "failed to read baseboard information");
457 		return;
458 	}
459 
460 	oprintf(fp, "  Chassis: %u\n", (uint_t)b.smbb_chassis);
461 
462 	flag_printf(fp, "Flags", b.smbb_flags, sizeof (b.smbb_flags) * NBBY,
463 	    smbios_bboard_flag_name, smbios_bboard_flag_desc);
464 
465 	desc_printf(smbios_bboard_type_desc(b.smbb_type),
466 	    fp, "  Board Type: 0x%x", b.smbb_type);
467 
468 	chdl_cnt = b.smbb_contn;
469 	if (chdl_cnt != 0) {
470 		id_t *chdl;
471 		uint16_t hdl;
472 		int i, n, cnt;
473 
474 		chdl = alloca(chdl_cnt * sizeof (id_t));
475 		cnt = smbios_info_contains(shp, id, chdl_cnt, chdl);
476 		if (cnt > SMB_CONT_MAX)
477 			return;
478 		n = MIN(chdl_cnt, cnt);
479 
480 		oprintf(fp, "\n");
481 		for (i = 0; i < n; i++) {
482 			hdl = (uint16_t)chdl[i];
483 			oprintf(fp, "  Contained Handle: %u\n", hdl);
484 		}
485 	}
486 }
487 
488 static void
489 print_chassis(smbios_hdl_t *shp, id_t id, FILE *fp)
490 {
491 	smbios_chassis_t c;
492 	smbios_chassis_entry_t *elts;
493 	uint_t nelts, i;
494 
495 	if (smbios_info_chassis(shp, id, &c) != 0) {
496 		smbios_warn(shp, "failed to read chassis information");
497 		return;
498 	}
499 
500 	oprintf(fp, "  OEM Data: 0x%x\n", c.smbc_oemdata);
501 	str_print(fp, "  SKU Number",
502 	    c.smbc_sku[0] == '\0' ? "<unknown>" : c.smbc_sku);
503 	oprintf(fp, "  Lock Present: %s\n", c.smbc_lock ? "Y" : "N");
504 
505 	desc_printf(smbios_chassis_type_desc(c.smbc_type),
506 	    fp, "  Chassis Type: 0x%x", c.smbc_type);
507 
508 	desc_printf(smbios_chassis_state_desc(c.smbc_bustate),
509 	    fp, "  Boot-Up State: 0x%x", c.smbc_bustate);
510 
511 	desc_printf(smbios_chassis_state_desc(c.smbc_psstate),
512 	    fp, "  Power Supply State: 0x%x", c.smbc_psstate);
513 
514 	desc_printf(smbios_chassis_state_desc(c.smbc_thstate),
515 	    fp, "  Thermal State: 0x%x", c.smbc_thstate);
516 
517 	oprintf(fp, "  Chassis Height: %uu\n", c.smbc_uheight);
518 	oprintf(fp, "  Power Cords: %u\n", c.smbc_cords);
519 
520 	oprintf(fp, "  Element Records: %u\n", c.smbc_elems);
521 
522 	if (c.smbc_elems == 0) {
523 		return;
524 	}
525 
526 	if (smbios_info_chassis_elts(shp, id, &nelts, &elts) != 0) {
527 		smbios_warn(shp, "failed to read chassis elements");
528 		return;
529 	}
530 
531 	oprintf(fp, "\n");
532 
533 	for (i = 0; i < nelts; i++) {
534 		switch (elts[i].smbce_type) {
535 		case SMB_CELT_BBOARD:
536 			desc_printf(smbios_bboard_type_desc(elts[i].smbce_elt),
537 			    fp, "  Contained SMBIOS Base Board Type: 0x%x",
538 			    elts[i].smbce_elt);
539 			break;
540 		case SMB_CELT_SMBIOS:
541 			desc_printf(smbios_type_name(elts[i].smbce_elt), fp,
542 			    "  Contained SMBIOS structure Type: %u",
543 			    elts[i].smbce_elt);
544 			break;
545 		default:
546 			oprintf(fp, "  Unknown contained Type: %u/%u\n",
547 			    elts[i].smbce_type, elts[i].smbce_elt);
548 			break;
549 		}
550 		oprintf(fp, "    Minimum number: %u\n", elts[i].smbce_min);
551 		oprintf(fp, "    Maximum number: %u\n", elts[i].smbce_max);
552 	}
553 }
554 
555 static void
556 print_processor(smbios_hdl_t *shp, id_t id, FILE *fp)
557 {
558 	smbios_processor_t p;
559 	uint_t status;
560 
561 	if (smbios_info_processor(shp, id, &p) != 0) {
562 		smbios_warn(shp, "failed to read processor information");
563 		return;
564 	}
565 	status = SMB_PRSTATUS_STATUS(p.smbp_status);
566 
567 	desc_printf(smbios_processor_family_desc(p.smbp_family),
568 	    fp, "  Family: %u", p.smbp_family);
569 
570 	oprintf(fp, "  CPUID: 0x%llx\n", (u_longlong_t)p.smbp_cpuid);
571 
572 	desc_printf(smbios_processor_type_desc(p.smbp_type),
573 	    fp, "  Type: %u", p.smbp_type);
574 
575 	desc_printf(smbios_processor_upgrade_desc(p.smbp_upgrade),
576 	    fp, "  Socket Upgrade: %u", p.smbp_upgrade);
577 
578 	oprintf(fp, "  Socket Status: %s\n",
579 	    SMB_PRSTATUS_PRESENT(p.smbp_status) ?
580 	    "Populated" : "Not Populated");
581 
582 	desc_printf(smbios_processor_status_desc(status),
583 	    fp, "  Processor Status: %u", status);
584 
585 	if (SMB_PRV_LEGACY(p.smbp_voltage)) {
586 		oprintf(fp, "  Supported Voltages:");
587 		switch (p.smbp_voltage) {
588 		case SMB_PRV_5V:
589 			oprintf(fp, " 5.0V");
590 			break;
591 		case SMB_PRV_33V:
592 			oprintf(fp, " 3.3V");
593 			break;
594 		case SMB_PRV_29V:
595 			oprintf(fp, " 2.9V");
596 			break;
597 		}
598 		oprintf(fp, "\n");
599 	} else {
600 		oprintf(fp, "  Supported Voltages: %.1fV\n",
601 		    (float)SMB_PRV_VOLTAGE(p.smbp_voltage) / 10);
602 	}
603 
604 	if (p.smbp_corecount != 0) {
605 		oprintf(fp, "  Core Count: %u\n", p.smbp_corecount);
606 	} else {
607 		oprintf(fp, "  Core Count: Unknown\n");
608 	}
609 
610 	if (p.smbp_coresenabled != 0) {
611 		oprintf(fp, "  Cores Enabled: %u\n", p.smbp_coresenabled);
612 	} else {
613 		oprintf(fp, "  Cores Enabled: Unknown\n");
614 	}
615 
616 	if (p.smbp_threadcount != 0) {
617 		oprintf(fp, "  Thread Count: %u\n", p.smbp_threadcount);
618 	} else {
619 		oprintf(fp, "  Thread Count: Unknown\n");
620 	}
621 
622 	if (p.smbp_cflags) {
623 		flag_printf(fp, "Processor Characteristics",
624 		    p.smbp_cflags, sizeof (p.smbp_cflags) * NBBY,
625 		    smbios_processor_core_flag_name,
626 		    smbios_processor_core_flag_desc);
627 	}
628 
629 	if (p.smbp_clkspeed != 0)
630 		oprintf(fp, "  External Clock Speed: %uMHz\n", p.smbp_clkspeed);
631 	else
632 		oprintf(fp, "  External Clock Speed: Unknown\n");
633 
634 	if (p.smbp_maxspeed != 0)
635 		oprintf(fp, "  Maximum Speed: %uMHz\n", p.smbp_maxspeed);
636 	else
637 		oprintf(fp, "  Maximum Speed: Unknown\n");
638 
639 	if (p.smbp_curspeed != 0)
640 		oprintf(fp, "  Current Speed: %uMHz\n", p.smbp_curspeed);
641 	else
642 		oprintf(fp, "  Current Speed: Unknown\n");
643 
644 	id_printf(fp, "  L1 Cache Handle: ", p.smbp_l1cache);
645 	id_printf(fp, "  L2 Cache Handle: ", p.smbp_l2cache);
646 	id_printf(fp, "  L3 Cache Handle: ", p.smbp_l3cache);
647 
648 	if (p.smbp_threadsenabled != 0) {
649 		oprintf(fp, "  Threads Enabled: %u\n", p.smbp_threadsenabled);
650 	} else {
651 		oprintf(fp, "  Threads Enabled: Unknown\n");
652 	}
653 }
654 
655 static void
656 print_cache(smbios_hdl_t *shp, id_t id, FILE *fp)
657 {
658 	smbios_cache_t c;
659 
660 	if (smbios_info_cache(shp, id, &c) != 0) {
661 		smbios_warn(shp, "failed to read cache information");
662 		return;
663 	}
664 
665 	oprintf(fp, "  Level: %u\n", c.smba_level);
666 	oprintf(fp, "  Maximum Installed Size: %" PRIu64 " bytes\n",
667 	    c.smba_maxsize2);
668 
669 	if (c.smba_size2 != 0) {
670 		oprintf(fp, "  Installed Size: %" PRIu64 " bytes\n",
671 		    c.smba_size2);
672 	} else {
673 		oprintf(fp, "  Installed Size: Not Installed\n");
674 	}
675 
676 	if (c.smba_speed != 0)
677 		oprintf(fp, "  Speed: %uns\n", c.smba_speed);
678 	else
679 		oprintf(fp, "  Speed: Unknown\n");
680 
681 	flag_printf(fp, "Supported SRAM Types",
682 	    c.smba_stype, sizeof (c.smba_stype) * NBBY,
683 	    smbios_cache_ctype_name, smbios_cache_ctype_desc);
684 
685 	desc_printf(smbios_cache_ctype_desc(c.smba_ctype),
686 	    fp, "  Current SRAM Type: 0x%x", c.smba_ctype);
687 
688 	desc_printf(smbios_cache_ecc_desc(c.smba_etype),
689 	    fp, "  Error Correction Type: %u", c.smba_etype);
690 
691 	desc_printf(smbios_cache_logical_desc(c.smba_ltype),
692 	    fp, "  Logical Cache Type: %u", c.smba_ltype);
693 
694 	desc_printf(smbios_cache_assoc_desc(c.smba_assoc),
695 	    fp, "  Associativity: %u", c.smba_assoc);
696 
697 	desc_printf(smbios_cache_mode_desc(c.smba_mode),
698 	    fp, "  Mode: %u", c.smba_mode);
699 
700 	desc_printf(smbios_cache_loc_desc(c.smba_location),
701 	    fp, "  Location: %u", c.smba_location);
702 
703 	flag_printf(fp, "Flags", c.smba_flags, sizeof (c.smba_flags) * NBBY,
704 	    smbios_cache_flag_name, smbios_cache_flag_desc);
705 }
706 
707 static void
708 print_port(smbios_hdl_t *shp, id_t id, FILE *fp)
709 {
710 	smbios_port_t p;
711 
712 	if (smbios_info_port(shp, id, &p) != 0) {
713 		smbios_warn(shp, "failed to read port information");
714 		return;
715 	}
716 
717 	str_print(fp, "  Internal Reference Designator", p.smbo_iref);
718 	str_print(fp, "  External Reference Designator", p.smbo_eref);
719 
720 	desc_printf(smbios_port_conn_desc(p.smbo_itype),
721 	    fp, "  Internal Connector Type: %u", p.smbo_itype);
722 
723 	desc_printf(smbios_port_conn_desc(p.smbo_etype),
724 	    fp, "  External Connector Type: %u", p.smbo_etype);
725 
726 	desc_printf(smbios_port_type_desc(p.smbo_ptype),
727 	    fp, "  Port Type: %u", p.smbo_ptype);
728 }
729 
730 static void
731 print_slot(smbios_hdl_t *shp, id_t id, FILE *fp)
732 {
733 	smbios_slot_t s;
734 	smbios_version_t v;
735 
736 	if (smbios_info_slot(shp, id, &s) != 0) {
737 		smbios_warn(shp, "failed to read slot information");
738 		return;
739 	}
740 	smbios_info_smbios_version(shp, &v);
741 
742 	str_print(fp, "  Reference Designator", s.smbl_name);
743 	oprintf(fp, "  Slot ID: 0x%x\n", s.smbl_id);
744 
745 	desc_printf(smbios_slot_type_desc(s.smbl_type),
746 	    fp, "  Type: 0x%x", s.smbl_type);
747 
748 	desc_printf(smbios_slot_width_desc(s.smbl_width),
749 	    fp, "  Width: 0x%x", s.smbl_width);
750 
751 	desc_printf(smbios_slot_usage_desc(s.smbl_usage),
752 	    fp, "  Usage: 0x%x", s.smbl_usage);
753 
754 	desc_printf(smbios_slot_length_desc(s.smbl_length),
755 	    fp, "  Length: 0x%x", s.smbl_length);
756 
757 	flag_printf(fp, "Slot Characteristics 1",
758 	    s.smbl_ch1, sizeof (s.smbl_ch1) * NBBY,
759 	    smbios_slot_ch1_name, smbios_slot_ch1_desc);
760 
761 	flag_printf(fp, "Slot Characteristics 2",
762 	    s.smbl_ch2, sizeof (s.smbl_ch2) * NBBY,
763 	    smbios_slot_ch2_name, smbios_slot_ch2_desc);
764 
765 	if (check_oem(shp) != 0 && !smbios_vergteq(&v, 2, 6))
766 		return;
767 
768 	oprintf(fp, "  Segment Group: %u\n", s.smbl_sg);
769 	oprintf(fp, "  Bus Number: %u\n", s.smbl_bus);
770 	oprintf(fp, "  Device/Function Number: %u/%u\n", s.smbl_df >> 3,
771 	    s.smbl_df & 0x7);
772 
773 	if (s.smbl_dbw != 0) {
774 		oprintf(fp, "  Data Bus Width: %d\n", s.smbl_dbw);
775 	}
776 
777 	if (s.smbl_npeers > 0) {
778 		smbios_slot_peer_t *peer;
779 		uint_t i, npeers;
780 
781 		if (smbios_info_slot_peers(shp, id, &npeers, &peer) != 0) {
782 			smbios_warn(shp, "failed to read slot peer "
783 			    "information");
784 			return;
785 		}
786 
787 		for (i = 0; i < npeers; i++) {
788 			oprintf(fp, "  Slot Peer %u:\n", i);
789 			oprintf(fp, "    Segment group: %u\n",
790 			    peer[i].smblp_group);
791 			oprintf(fp, "    Bus/Device/Function: %u/%u/%u\n",
792 			    peer[i].smblp_bus, peer[i].smblp_device,
793 			    peer[i].smblp_function);
794 			oprintf(fp, "    Electrical width: %u\n",
795 			    peer[i].smblp_data_width);
796 		}
797 
798 		smbios_info_slot_peers_free(shp, npeers, peer);
799 	}
800 
801 	if (s.smbl_info != 0) {
802 		if (s.smbl_type >= SMB_SLT_PCIE &&
803 		    s.smbl_type <= SMB_SLT_PCIEG6P) {
804 			oprintf(fp, "  PCIe Generation: %d\n", s.smbl_info);
805 		} else {
806 			oprintf(fp, "  Slot Type: 0x%x\n", s.smbl_info);
807 		}
808 	}
809 
810 	if (s.smbl_pwidth != 0) {
811 		desc_printf(smbios_slot_width_desc(s.smbl_pwidth),
812 		    fp, "  Physical Width: 0x%x", s.smbl_pwidth);
813 	}
814 
815 	if (s.smbl_pitch != 0) {
816 		oprintf(fp, "  Slot Pitch: %u.%u mm\n", s.smbl_pitch / 100,
817 		    s.smbl_pitch % 100);
818 	}
819 
820 	/*
821 	 * The slot height was introduced in SMBIOS 3.5. However, a value of
822 	 * zero here does not mean that it is unknown, but rather that the
823 	 * concept is not applicable. Therefore we cannot use a standard check
824 	 * against zero for this and instead use the version.
825 	 */
826 	if (smbios_vergteq(&v, 3, 5)) {
827 		desc_printf(smbios_slot_height_desc(s.smbl_height), fp,
828 		    "  Height: 0x%x", s.smbl_height);
829 	} else {
830 		oprintf(fp, "  Height:  unknown\n");
831 	}
832 }
833 
834 static void
835 print_obdevs_ext(smbios_hdl_t *shp, id_t id, FILE *fp)
836 {
837 	boolean_t enabled;
838 	smbios_obdev_ext_t oe;
839 	const char *type;
840 
841 	if (smbios_info_obdevs_ext(shp, id, &oe) != 0) {
842 		smbios_warn(shp, "failed to read extended on-board devices "
843 		    "information");
844 		return;
845 	}
846 
847 	/*
848 	 * Bit 7 is always whether or not the device is enabled while bits 0:6
849 	 * are the actual device type.
850 	 */
851 	enabled = oe.smboe_dtype >> 7;
852 	type = smbios_onboard_ext_type_desc(oe.smboe_dtype & 0x7f);
853 
854 	str_print(fp, "  Reference Designator", oe.smboe_name);
855 	oprintf(fp, "  Device Enabled: %s\n", enabled == B_TRUE ? "true" :
856 	    "false");
857 	oprintf(fp, "  Device Type: %s\n", type);
858 	oprintf(fp, "  Device Type Instance: %u\n", oe.smboe_dti);
859 	oprintf(fp, "  Segment Group Number: %u\n", oe.smboe_sg);
860 	oprintf(fp, "  Bus Number: %u\n", oe.smboe_bus);
861 	oprintf(fp, "  Device/Function Number: %u\n", oe.smboe_df);
862 }
863 
864 static void
865 print_obdevs(smbios_hdl_t *shp, id_t id, FILE *fp)
866 {
867 	smbios_obdev_t *argv;
868 	int i, argc;
869 
870 	if ((argc = smbios_info_obdevs(shp, id, 0, NULL)) > 0) {
871 		argv = alloca(sizeof (smbios_obdev_t) * argc);
872 		if (smbios_info_obdevs(shp, id, argc, argv) == -1) {
873 			smbios_warn(shp, "failed to read on-board device "
874 			    "information");
875 			return;
876 		}
877 		for (i = 0; i < argc; i++)
878 			str_print_nolabel(fp, "  ", argv[i].smbd_name);
879 	}
880 }
881 
882 static void
883 print_strtab(smbios_hdl_t *shp, id_t id, FILE *fp)
884 {
885 	const char **argv;
886 	int i, argc;
887 
888 	if ((argc = smbios_info_strtab(shp, id, 0, NULL)) > 0) {
889 		argv = alloca(sizeof (char *) * argc);
890 		if (smbios_info_strtab(shp, id, argc, argv) == -1) {
891 			smbios_warn(shp, "failed to read string table "
892 			    "information");
893 			return;
894 		}
895 		for (i = 0; i < argc; i++)
896 			str_print_nolabel(fp, "  ", argv[i]);
897 	}
898 }
899 
900 static void
901 print_lang(smbios_hdl_t *shp, id_t id, FILE *fp)
902 {
903 	smbios_lang_t l;
904 
905 	if (smbios_info_lang(shp, &l) == -1) {
906 		smbios_warn(shp, "failed to read language information");
907 		return;
908 	}
909 
910 	str_print(fp, "  Current Language", l.smbla_cur);
911 	oprintf(fp, "  Language String Format: %u\n", l.smbla_fmt);
912 	oprintf(fp, "  Number of Installed Languages: %u\n", l.smbla_num);
913 	oprintf(fp, "  Installed Languages:\n");
914 
915 	print_strtab(shp, id, fp);
916 }
917 
918 /*ARGSUSED*/
919 static void
920 print_evlog(smbios_hdl_t *shp, id_t id, FILE *fp)
921 {
922 	smbios_evlog_t ev;
923 	uint32_t i;
924 
925 	if (smbios_info_eventlog(shp, &ev) == -1) {
926 		smbios_warn(shp, "failed to read event log information");
927 		return;
928 	}
929 
930 	oprintf(fp, "  Log Area Size: %lu bytes\n", (ulong_t)ev.smbev_size);
931 	oprintf(fp, "  Header Offset: %lu\n", (ulong_t)ev.smbev_hdr);
932 	oprintf(fp, "  Data Offset: %lu\n", (ulong_t)ev.smbev_data);
933 
934 	desc_printf(smbios_evlog_method_desc(ev.smbev_method),
935 	    fp, "  Data Access Method: %u", ev.smbev_method);
936 
937 	flag_printf(fp, "Log Flags",
938 	    ev.smbev_flags, sizeof (ev.smbev_flags) * NBBY,
939 	    smbios_evlog_flag_name, smbios_evlog_flag_desc);
940 
941 	desc_printf(smbios_evlog_format_desc(ev.smbev_format),
942 	    fp, "  Log Header Format: %u", ev.smbev_format);
943 
944 	oprintf(fp, "  Update Token: 0x%x\n", ev.smbev_token);
945 	oprintf(fp, "  Data Access Address: ");
946 
947 	switch (ev.smbev_method) {
948 	case SMB_EVM_1x1i_1x1d:
949 	case SMB_EVM_2x1i_1x1d:
950 	case SMB_EVM_1x2i_1x1d:
951 		oprintf(fp, "Index Address 0x%x, Data Address 0x%x\n",
952 		    ev.smbev_addr.eva_io.evi_iaddr,
953 		    ev.smbev_addr.eva_io.evi_daddr);
954 		break;
955 	case SMB_EVM_GPNV:
956 		oprintf(fp, "0x%x\n", ev.smbev_addr.eva_gpnv);
957 		break;
958 	default:
959 		oprintf(fp, "0x%x\n", ev.smbev_addr.eva_addr);
960 	}
961 
962 	oprintf(fp, "  Type Descriptors:\n");
963 
964 	for (i = 0; i < ev.smbev_typec; i++) {
965 		oprintf(fp, "  %u: Log Type 0x%x, Data Type 0x%x\n", i,
966 		    ev.smbev_typev[i].smbevt_ltype,
967 		    ev.smbev_typev[i].smbevt_dtype);
968 	}
969 }
970 
971 static void
972 print_bytes(const uint8_t *data, size_t size, FILE *fp)
973 {
974 	size_t row, rows = P2ROUNDUP(size, 16) / 16;
975 	size_t col, cols;
976 
977 	char buf[17];
978 	uint8_t x;
979 
980 	oprintf(fp, "\n  offset:   0 1 2 3  4 5 6 7  8 9 a b  c d e f  "
981 	    "0123456789abcdef\n");
982 
983 	for (row = 0; row < rows; row++) {
984 		oprintf(fp, "  %#6lx: ", (ulong_t)row * 16);
985 		cols = MIN(size - row * 16, 16);
986 
987 		for (col = 0; col < cols; col++) {
988 			if (col % 4 == 0)
989 				oprintf(fp, " ");
990 			x = *data++;
991 			oprintf(fp, "%02x", x);
992 			buf[col] = x <= ' ' || x > '~' ? '.' : x;
993 		}
994 
995 		for (; col < 16; col++) {
996 			if (col % 4 == 0)
997 				oprintf(fp, " ");
998 			oprintf(fp, "  ");
999 			buf[col] = ' ';
1000 		}
1001 
1002 		buf[col] = '\0';
1003 		oprintf(fp, "  %s\n", buf);
1004 	}
1005 
1006 	oprintf(fp, "\n");
1007 }
1008 
1009 static void
1010 print_memarray(smbios_hdl_t *shp, id_t id, FILE *fp)
1011 {
1012 	smbios_memarray_t ma;
1013 
1014 	if (smbios_info_memarray(shp, id, &ma) != 0) {
1015 		smbios_warn(shp, "failed to read memarray information");
1016 		return;
1017 	}
1018 
1019 	desc_printf(smbios_memarray_loc_desc(ma.smbma_location),
1020 	    fp, "  Location: %u", ma.smbma_location);
1021 
1022 	desc_printf(smbios_memarray_use_desc(ma.smbma_use),
1023 	    fp, "  Use: %u", ma.smbma_use);
1024 
1025 	desc_printf(smbios_memarray_ecc_desc(ma.smbma_ecc),
1026 	    fp, "  ECC: %u", ma.smbma_ecc);
1027 
1028 	oprintf(fp, "  Number of Slots/Sockets: %u\n", ma.smbma_ndevs);
1029 	id_printf(fp, "  Memory Error Data: ", ma.smbma_err);
1030 	oprintf(fp, "  Max Capacity: %llu bytes\n",
1031 	    (u_longlong_t)ma.smbma_size);
1032 }
1033 
1034 static void
1035 print_memdevice(smbios_hdl_t *shp, id_t id, FILE *fp)
1036 {
1037 	smbios_memdevice_t md;
1038 
1039 	if (smbios_info_memdevice(shp, id, &md) != 0) {
1040 		smbios_warn(shp, "failed to read memory device information");
1041 		return;
1042 	}
1043 
1044 	id_printf(fp, "  Physical Memory Array: ", md.smbmd_array);
1045 	id_printf(fp, "  Memory Error Data: ", md.smbmd_error);
1046 
1047 	if (md.smbmd_twidth != -1u)
1048 		oprintf(fp, "  Total Width: %u bits\n", md.smbmd_twidth);
1049 	else
1050 		oprintf(fp, "  Total Width: Unknown\n");
1051 
1052 	if (md.smbmd_dwidth != -1u)
1053 		oprintf(fp, "  Data Width: %u bits\n", md.smbmd_dwidth);
1054 	else
1055 		oprintf(fp, "  Data Width: Unknown\n");
1056 
1057 	switch (md.smbmd_size) {
1058 	case -1ull:
1059 		oprintf(fp, "  Size: Unknown\n");
1060 		break;
1061 	case 0:
1062 		oprintf(fp, "  Size: Not Populated\n");
1063 		break;
1064 	default:
1065 		oprintf(fp, "  Size: %llu bytes\n",
1066 		    (u_longlong_t)md.smbmd_size);
1067 	}
1068 
1069 	desc_printf(smbios_memdevice_form_desc(md.smbmd_form),
1070 	    fp, "  Form Factor: %u", md.smbmd_form);
1071 
1072 	if (md.smbmd_set == 0)
1073 		oprintf(fp, "  Set: None\n");
1074 	else if (md.smbmd_set == (uint8_t)-1u)
1075 		oprintf(fp, "  Set: Unknown\n");
1076 	else
1077 		oprintf(fp, "  Set: %u\n", md.smbmd_set);
1078 
1079 	if (md.smbmd_rank != 0) {
1080 		desc_printf(smbios_memdevice_rank_desc(md.smbmd_rank),
1081 		    fp, "  Rank: %u", md.smbmd_rank);
1082 	} else {
1083 		oprintf(fp, "  Rank: Unknown\n");
1084 	}
1085 
1086 	desc_printf(smbios_memdevice_type_desc(md.smbmd_type),
1087 	    fp, "  Memory Type: %u", md.smbmd_type);
1088 
1089 	flag_printf(fp, "Flags", md.smbmd_flags, sizeof (md.smbmd_flags) * NBBY,
1090 	    smbios_memdevice_flag_name, smbios_memdevice_flag_desc);
1091 
1092 	if (md.smbmd_extspeed != 0) {
1093 		oprintf(fp, "  Speed: %" PRIu64 " MT/s\n", md.smbmd_extspeed);
1094 	} else {
1095 		oprintf(fp, "  Speed: Unknown\n");
1096 	}
1097 
1098 	if (md.smbmd_extclkspeed != 0) {
1099 		oprintf(fp, "  Configured Speed: %" PRIu64 " MT/s\n",
1100 		    md.smbmd_extclkspeed);
1101 	} else {
1102 		oprintf(fp, "  Configured Speed: Unknown\n");
1103 	}
1104 
1105 	str_print(fp, "  Device Locator", md.smbmd_dloc);
1106 	str_print(fp, "  Bank Locator", md.smbmd_bloc);
1107 
1108 	if (md.smbmd_minvolt != 0) {
1109 		oprintf(fp, "  Minimum Voltage: %.2fV\n",
1110 		    md.smbmd_minvolt / 1000.0);
1111 	} else {
1112 		oprintf(fp, "  Minimum Voltage: Unknown\n");
1113 	}
1114 
1115 	if (md.smbmd_maxvolt != 0) {
1116 		oprintf(fp, "  Maximum Voltage: %.2fV\n",
1117 		    md.smbmd_maxvolt / 1000.0);
1118 	} else {
1119 		oprintf(fp, "  Maximum Voltage: Unknown\n");
1120 	}
1121 
1122 	if (md.smbmd_confvolt != 0) {
1123 		oprintf(fp, "  Configured Voltage: %.2fV\n",
1124 		    md.smbmd_confvolt / 1000.0);
1125 	} else {
1126 		oprintf(fp, "  Configured Voltage: Unknown\n");
1127 	}
1128 
1129 	if (md.smbmd_memtech != 0) {
1130 		desc_printf(smbios_memdevice_memtech_desc(md.smbmd_memtech),
1131 		    fp, "  Memory Technology: %u", md.smbmd_memtech);
1132 	}
1133 
1134 	if (md.smbmd_opcap_flags != 0) {
1135 		flag_printf(fp, "Operating Mode Capabilities",
1136 		    md.smbmd_opcap_flags, sizeof (md.smbmd_opcap_flags) * NBBY,
1137 		    smbios_memdevice_op_capab_name,
1138 		    smbios_memdevice_op_capab_desc);
1139 	}
1140 
1141 	if (md.smbmd_firmware_rev[0] != '\0') {
1142 		str_print(fp, "  Firmware Revision", md.smbmd_firmware_rev);
1143 	}
1144 
1145 	if (md.smbmd_modmfg_id != 0) {
1146 		jedec_print(fp, "Module Manufacturer ID", md.smbmd_modmfg_id);
1147 	}
1148 
1149 	if (md.smbmd_modprod_id  != 0) {
1150 		jedec_print(fp, "Module Product ID", md.smbmd_modprod_id);
1151 	}
1152 
1153 	if (md.smbmd_cntrlmfg_id != 0) {
1154 		jedec_print(fp, "Memory Subsystem Controller Manufacturer ID",
1155 		    md.smbmd_cntrlmfg_id);
1156 	}
1157 
1158 	if (md.smbmd_cntrlprod_id != 0) {
1159 		jedec_print(fp, "Memory Subsystem Controller Product ID",
1160 		    md.smbmd_cntrlprod_id);
1161 	}
1162 
1163 	if (md.smbmd_nvsize == UINT64_MAX) {
1164 		oprintf(fp, "  Non-volatile Size: Unknown\n");
1165 	} else if (md.smbmd_nvsize != 0) {
1166 		oprintf(fp, "  Non-volatile Size: %llu bytes\n",
1167 		    (u_longlong_t)md.smbmd_nvsize);
1168 	}
1169 
1170 	if (md.smbmd_volatile_size == UINT64_MAX) {
1171 		oprintf(fp, "  Volatile Size: Unknown\n");
1172 	} else if (md.smbmd_volatile_size != 0) {
1173 		oprintf(fp, "  Volatile Size: %llu bytes\n",
1174 		    (u_longlong_t)md.smbmd_volatile_size);
1175 	}
1176 
1177 	if (md.smbmd_cache_size == UINT64_MAX) {
1178 		oprintf(fp, "  Cache Size: Unknown\n");
1179 	} else if (md.smbmd_cache_size != 0) {
1180 		oprintf(fp, "  Cache Size: %llu bytes\n",
1181 		    (u_longlong_t)md.smbmd_cache_size);
1182 	}
1183 
1184 	if (md.smbmd_logical_size == UINT64_MAX) {
1185 		oprintf(fp, "  Logical Size: Unknown\n");
1186 	} else if (md.smbmd_logical_size != 0) {
1187 		oprintf(fp, "  Logical Size: %llu bytes\n",
1188 		    (u_longlong_t)md.smbmd_logical_size);
1189 	}
1190 }
1191 
1192 static void
1193 print_memarrmap(smbios_hdl_t *shp, id_t id, FILE *fp)
1194 {
1195 	smbios_memarrmap_t ma;
1196 
1197 	if (smbios_info_memarrmap(shp, id, &ma) != 0) {
1198 		smbios_warn(shp, "failed to read memory array map information");
1199 		return;
1200 	}
1201 
1202 	id_printf(fp, "  Physical Memory Array: ", ma.smbmam_array);
1203 	oprintf(fp, "  Devices per Row: %u\n", ma.smbmam_width);
1204 
1205 	oprintf(fp, "  Physical Address: 0x%llx\n  Size: %llu bytes\n",
1206 	    (u_longlong_t)ma.smbmam_addr, (u_longlong_t)ma.smbmam_size);
1207 }
1208 
1209 static void
1210 print_memdevmap(smbios_hdl_t *shp, id_t id, FILE *fp)
1211 {
1212 	smbios_memdevmap_t md;
1213 
1214 	if (smbios_info_memdevmap(shp, id, &md) != 0) {
1215 		smbios_warn(shp, "failed to read memory device map "
1216 		    "information");
1217 		return;
1218 	}
1219 
1220 	id_printf(fp, "  Memory Device: ", md.smbmdm_device);
1221 	id_printf(fp, "  Memory Array Mapped Address: ", md.smbmdm_arrmap);
1222 
1223 	oprintf(fp, "  Physical Address: 0x%llx\n  Size: %llu bytes\n",
1224 	    (u_longlong_t)md.smbmdm_addr, (u_longlong_t)md.smbmdm_size);
1225 
1226 	oprintf(fp, "  Partition Row Position: %u\n", md.smbmdm_rpos);
1227 	oprintf(fp, "  Interleave Position: %u\n", md.smbmdm_ipos);
1228 	oprintf(fp, "  Interleave Data Depth: %u\n", md.smbmdm_idepth);
1229 }
1230 
1231 static void
1232 print_hwsec(smbios_hdl_t *shp, FILE *fp)
1233 {
1234 	smbios_hwsec_t h;
1235 
1236 	if (smbios_info_hwsec(shp, &h) == -1) {
1237 		smbios_warn(shp, "failed to read hwsec information");
1238 		return;
1239 	}
1240 
1241 	desc_printf(smbios_hwsec_desc(h.smbh_pwr_ps),
1242 	    fp, "  Power-On Password Status: %u", h.smbh_pwr_ps);
1243 	desc_printf(smbios_hwsec_desc(h.smbh_kbd_ps),
1244 	    fp, "  Keyboard Password Status: %u", h.smbh_kbd_ps);
1245 	desc_printf(smbios_hwsec_desc(h.smbh_adm_ps),
1246 	    fp, "  Administrator Password Status: %u", h.smbh_adm_ps);
1247 	desc_printf(smbios_hwsec_desc(h.smbh_pan_ps),
1248 	    fp, "  Front Panel Reset Status: %u", h.smbh_pan_ps);
1249 }
1250 
1251 static void
1252 print_vprobe(smbios_hdl_t *shp, id_t id, FILE *fp)
1253 {
1254 	smbios_vprobe_t vp;
1255 
1256 	if (smbios_info_vprobe(shp, id, &vp) != 0) {
1257 		smbios_warn(shp, "failed to read voltage probe information");
1258 		return;
1259 	}
1260 
1261 	str_print(fp, "  Description", vp.smbvp_description != NULL ?
1262 	    vp.smbvp_description : "unknown");
1263 	desc_printf(smbios_vprobe_loc_desc(vp.smbvp_location),
1264 	    fp, "  Location: %u", vp.smbvp_location);
1265 	desc_printf(smbios_vprobe_status_desc(vp.smbvp_status),
1266 	    fp, "  Status: %u", vp.smbvp_status);
1267 
1268 	if (vp.smbvp_maxval != SMB_PROBE_UNKNOWN_VALUE) {
1269 		oprintf(fp, "  Maximum Possible Voltage: %u mV\n",
1270 		    vp.smbvp_maxval);
1271 	} else {
1272 		oprintf(fp, "  Maximum Possible Voltage: unknown\n");
1273 	}
1274 
1275 	if (vp.smbvp_minval != SMB_PROBE_UNKNOWN_VALUE) {
1276 		oprintf(fp, "  Minimum Possible Voltage: %u mV\n",
1277 		    vp.smbvp_minval);
1278 	} else {
1279 		oprintf(fp, "  Minimum Possible Voltage: unknown\n");
1280 	}
1281 
1282 	if (vp.smbvp_resolution != SMB_PROBE_UNKNOWN_VALUE) {
1283 		oprintf(fp, "  Probe Resolution: %u.%u mV\n",
1284 		    vp.smbvp_resolution / 10,
1285 		    vp.smbvp_resolution % 10);
1286 	} else {
1287 		oprintf(fp, "  Probe Resolution: unknown\n");
1288 	}
1289 
1290 	if (vp.smbvp_tolerance != SMB_PROBE_UNKNOWN_VALUE) {
1291 		oprintf(fp, "  Probe Tolerance: +/-%u mV\n",
1292 		    vp.smbvp_tolerance);
1293 	} else {
1294 		oprintf(fp, "  Probe Tolerance: unknown\n");
1295 	}
1296 
1297 	if (vp.smbvp_accuracy != SMB_PROBE_UNKNOWN_VALUE) {
1298 		oprintf(fp, "  Probe Accuracy: +/-%u.%02u%%\n",
1299 		    vp.smbvp_accuracy / 100,
1300 		    vp.smbvp_accuracy % 100);
1301 	} else {
1302 		oprintf(fp, "  Probe Accuracy: unknown\n");
1303 	}
1304 
1305 	oprintf(fp, "  OEM- or BIOS- defined value: 0x%x\n", vp.smbvp_oem);
1306 
1307 	if (vp.smbvp_nominal != SMB_PROBE_UNKNOWN_VALUE) {
1308 		oprintf(fp, "  Probe Nominal Value: %u mV\n", vp.smbvp_nominal);
1309 	} else {
1310 		oprintf(fp, "  Probe Nominal Value: unknown\n");
1311 	}
1312 }
1313 
1314 static void
1315 print_cooldev(smbios_hdl_t *shp, id_t id, FILE *fp)
1316 {
1317 	smbios_cooldev_t cd;
1318 
1319 	if (smbios_info_cooldev(shp, id, &cd) != 0) {
1320 		smbios_warn(shp, "failed to read cooling device "
1321 		    "information");
1322 		return;
1323 	}
1324 
1325 	id_printf(fp, "  Temperature Probe Handle: ", cd.smbcd_tprobe);
1326 	desc_printf(smbios_cooldev_type_desc(cd.smbcd_type),
1327 	    fp, "  Device Type: %u", cd.smbcd_type);
1328 	desc_printf(smbios_cooldev_status_desc(cd.smbcd_status),
1329 	    fp, "  Status: %u", cd.smbcd_status);
1330 	oprintf(fp, "  Cooling Unit Group: %u\n", cd.smbcd_group);
1331 	oprintf(fp, "  OEM- or BIOS- defined data: 0x%x\n", cd.smbcd_oem);
1332 	if (cd.smbcd_nominal != SMB_PROBE_UNKNOWN_VALUE) {
1333 		oprintf(fp, "  Nominal Speed: %u RPM\n", cd.smbcd_nominal);
1334 	} else {
1335 		oprintf(fp, "  Nominal Speed: unknown\n");
1336 	}
1337 
1338 	if (cd.smbcd_descr != NULL && cd.smbcd_descr[0] != '\0') {
1339 		str_print(fp, "  Description", cd.smbcd_descr);
1340 	}
1341 }
1342 
1343 static void
1344 print_tprobe(smbios_hdl_t *shp, id_t id, FILE *fp)
1345 {
1346 	smbios_tprobe_t tp;
1347 
1348 	if (smbios_info_tprobe(shp, id, &tp) != 0) {
1349 		smbios_warn(shp, "failed to read temperature probe "
1350 		    "information");
1351 		return;
1352 	}
1353 
1354 	str_print(fp, "  Description", tp.smbtp_description != NULL ?
1355 	    tp.smbtp_description : "unknown");
1356 	desc_printf(smbios_tprobe_loc_desc(tp.smbtp_location),
1357 	    fp, "  Location: %u", tp.smbtp_location);
1358 	desc_printf(smbios_tprobe_status_desc(tp.smbtp_status),
1359 	    fp, "  Status: %u", tp.smbtp_status);
1360 
1361 	if (tp.smbtp_maxval != SMB_PROBE_UNKNOWN_VALUE) {
1362 		oprintf(fp, "  Maximum Possible Temperature: %u.%u C\n",
1363 		    tp.smbtp_maxval / 10, tp.smbtp_maxval % 10);
1364 	} else {
1365 		oprintf(fp, "  Maximum Possible Temperature: unknown\n");
1366 	}
1367 
1368 	if (tp.smbtp_minval != SMB_PROBE_UNKNOWN_VALUE) {
1369 		oprintf(fp, "  Minimum Possible Temperature: %u.%u C\n",
1370 		    tp.smbtp_minval / 10, tp.smbtp_minval % 10);
1371 	} else {
1372 		oprintf(fp, "  Minimum Possible Temperature: unknown\n");
1373 	}
1374 
1375 	if (tp.smbtp_resolution != SMB_PROBE_UNKNOWN_VALUE) {
1376 		oprintf(fp, "  Probe Resolution: %u.%03u C\n",
1377 		    tp.smbtp_resolution / 1000,
1378 		    tp.smbtp_resolution % 1000);
1379 	} else {
1380 		oprintf(fp, "  Probe Resolution: unknown\n");
1381 	}
1382 
1383 	if (tp.smbtp_tolerance != SMB_PROBE_UNKNOWN_VALUE) {
1384 		oprintf(fp, "  Probe Tolerance: +/-%u.%u C\n",
1385 		    tp.smbtp_tolerance / 10, tp.smbtp_tolerance % 10);
1386 	} else {
1387 		oprintf(fp, "  Probe Tolerance: unknown\n");
1388 	}
1389 
1390 	if (tp.smbtp_accuracy != SMB_PROBE_UNKNOWN_VALUE) {
1391 		oprintf(fp, "  Probe Accuracy: +/-%u.%02u%%\n",
1392 		    tp.smbtp_accuracy / 100,
1393 		    tp.smbtp_accuracy % 100);
1394 	} else {
1395 		oprintf(fp, "  Probe Accuracy: unknown\n");
1396 	}
1397 
1398 	oprintf(fp, "  OEM- or BIOS- defined value: 0x%x\n", tp.smbtp_oem);
1399 
1400 	if (tp.smbtp_nominal != SMB_PROBE_UNKNOWN_VALUE) {
1401 		oprintf(fp, "  Probe Nominal Value: %u.%u C\n",
1402 		    tp.smbtp_nominal / 10, tp.smbtp_nominal % 10);
1403 	} else {
1404 		oprintf(fp, "  Probe Nominal Value: unknown\n");
1405 	}
1406 }
1407 
1408 static void
1409 print_iprobe(smbios_hdl_t *shp, id_t id, FILE *fp)
1410 {
1411 	smbios_iprobe_t ip;
1412 
1413 	if (smbios_info_iprobe(shp, id, &ip) != 0) {
1414 		smbios_warn(shp, "failed to read current probe information");
1415 		return;
1416 	}
1417 
1418 	str_print(fp, "  Description", ip.smbip_description != NULL ?
1419 	    ip.smbip_description : "unknown");
1420 	desc_printf(smbios_iprobe_loc_desc(ip.smbip_location),
1421 	    fp, "  Location: %u", ip.smbip_location);
1422 	desc_printf(smbios_iprobe_status_desc(ip.smbip_status),
1423 	    fp, "  Status: %u", ip.smbip_status);
1424 
1425 	if (ip.smbip_maxval != SMB_PROBE_UNKNOWN_VALUE) {
1426 		oprintf(fp, "  Maximum Possible Current: %u mA\n",
1427 		    ip.smbip_maxval);
1428 	} else {
1429 		oprintf(fp, "  Maximum Possible Current: unknown\n");
1430 	}
1431 
1432 	if (ip.smbip_minval != SMB_PROBE_UNKNOWN_VALUE) {
1433 		oprintf(fp, "  Minimum Possible Current: %u mA\n",
1434 		    ip.smbip_minval);
1435 	} else {
1436 		oprintf(fp, "  Minimum Possible Current: unknown\n");
1437 	}
1438 
1439 	if (ip.smbip_resolution != SMB_PROBE_UNKNOWN_VALUE) {
1440 		oprintf(fp, "  Probe Resolution: %u.%u mA\n",
1441 		    ip.smbip_resolution / 10,
1442 		    ip.smbip_resolution % 10);
1443 	} else {
1444 		oprintf(fp, "  Probe Resolution: unknown\n");
1445 	}
1446 
1447 	if (ip.smbip_tolerance != SMB_PROBE_UNKNOWN_VALUE) {
1448 		oprintf(fp, "  Probe Tolerance: +/-%u mA\n",
1449 		    ip.smbip_tolerance);
1450 	} else {
1451 		oprintf(fp, "  Probe Tolerance: unknown\n");
1452 	}
1453 
1454 	if (ip.smbip_accuracy != SMB_PROBE_UNKNOWN_VALUE) {
1455 		oprintf(fp, "  Probe Accuracy: +/-%u.%02u%%\n",
1456 		    ip.smbip_accuracy / 100,
1457 		    ip.smbip_accuracy % 100);
1458 	} else {
1459 		oprintf(fp, "  Probe Accuracy: unknown\n");
1460 	}
1461 
1462 	oprintf(fp, "  OEM- or BIOS- defined value: 0x%x\n", ip.smbip_oem);
1463 
1464 	if (ip.smbip_nominal != SMB_PROBE_UNKNOWN_VALUE) {
1465 		oprintf(fp, "  Probe Nominal Value: %u mA\n", ip.smbip_nominal);
1466 	} else {
1467 		oprintf(fp, "  Probe Nominal Value: unknown\n");
1468 	}
1469 }
1470 
1471 
1472 static void
1473 print_boot(smbios_hdl_t *shp, FILE *fp)
1474 {
1475 	smbios_boot_t b;
1476 
1477 	if (smbios_info_boot(shp, &b) == -1) {
1478 		smbios_warn(shp, "failed to read boot information");
1479 		return;
1480 	}
1481 
1482 	desc_printf(smbios_boot_desc(b.smbt_status),
1483 	    fp, "  Boot Status Code: 0x%x", b.smbt_status);
1484 
1485 	if (b.smbt_size != 0) {
1486 		oprintf(fp, "  Boot Data (%lu bytes):\n", (ulong_t)b.smbt_size);
1487 		print_bytes(b.smbt_data, b.smbt_size, fp);
1488 	}
1489 }
1490 
1491 static void
1492 print_ipmi(smbios_hdl_t *shp, FILE *fp)
1493 {
1494 	smbios_ipmi_t i;
1495 
1496 	if (smbios_info_ipmi(shp, &i) == -1) {
1497 		smbios_warn(shp, "failed to read ipmi information");
1498 		return;
1499 	}
1500 
1501 	desc_printf(smbios_ipmi_type_desc(i.smbip_type),
1502 	    fp, "  Type: %u", i.smbip_type);
1503 
1504 	oprintf(fp, "  BMC IPMI Version: %u.%u\n",
1505 	    i.smbip_vers.smbv_major, i.smbip_vers.smbv_minor);
1506 
1507 	oprintf(fp, "  i2c Bus Slave Address: 0x%x\n", i.smbip_i2c);
1508 	oprintf(fp, "  NV Storage Device Bus ID: 0x%x\n", i.smbip_bus);
1509 	oprintf(fp, "  BMC Base Address: 0x%llx\n", (u_longlong_t)i.smbip_addr);
1510 	oprintf(fp, "  Interrupt Number: %u\n", i.smbip_intr);
1511 	oprintf(fp, "  Register Spacing: %u\n", i.smbip_regspacing);
1512 
1513 	flag_printf(fp, "Flags", i.smbip_flags, sizeof (i.smbip_flags) * NBBY,
1514 	    smbios_ipmi_flag_name, smbios_ipmi_flag_desc);
1515 }
1516 
1517 static void
1518 print_powersup(smbios_hdl_t *shp, id_t id, FILE *fp)
1519 {
1520 	smbios_powersup_t p;
1521 
1522 	if (smbios_info_powersup(shp, id, &p) != 0) {
1523 		smbios_warn(shp, "failed to read power supply information");
1524 		return;
1525 	}
1526 
1527 	oprintf(fp, "  Power Supply Group: %u\n", p.smbps_group);
1528 	if (p.smbps_maxout != 0x8000) {
1529 		oprintf(fp, "  Maximum Output: %llu mW\n", p.smbps_maxout);
1530 	} else {
1531 		oprintf(fp, "  Maximum Output: unknown\n");
1532 	}
1533 
1534 	flag_printf(fp, "Characteristics", p.smbps_flags,
1535 	    sizeof (p.smbps_flags) * NBBY, smbios_powersup_flag_name,
1536 	    smbios_powersup_flag_desc);
1537 
1538 	desc_printf(smbios_powersup_input_desc(p.smbps_ivrs),
1539 	    fp, "  Input Voltage Range Switching: %u", p.smbps_ivrs);
1540 	desc_printf(smbios_powersup_status_desc(p.smbps_status),
1541 	    fp, "  Status: %u", p.smbps_status);
1542 	desc_printf(smbios_powersup_type_desc(p.smbps_pstype),
1543 	    fp, "  Type: %u", p.smbps_pstype);
1544 
1545 	if (p.smbps_vprobe != 0xffff) {
1546 		oprintf(fp, "  Voltage Probe Handle: %lu\n", p.smbps_vprobe);
1547 	}
1548 
1549 	if (p.smbps_cooldev != 0xffff) {
1550 		oprintf(fp, "  Cooling Device Handle: %lu\n", p.smbps_cooldev);
1551 	}
1552 
1553 	if (p.smbps_iprobe != 0xffff) {
1554 		oprintf(fp, "  Current Probe Handle: %lu\n", p.smbps_iprobe);
1555 	}
1556 }
1557 
1558 static void
1559 print_processor_info_riscv(smbios_hdl_t *shp, id_t id, FILE *fp)
1560 {
1561 	smbios_processor_info_riscv_t rv;
1562 
1563 	if (smbios_info_processor_riscv(shp, id, &rv) != 0) {
1564 		smbios_warn(shp, "failed to read RISC-V specific processor "
1565 		    "information");
1566 		return;
1567 	}
1568 
1569 	if (rv.smbpirv_boothart != 0) {
1570 		oprintf(fp, "    Boot Hart\n");
1571 	}
1572 	u128_print(fp, "    Hart ID", rv.smbpirv_hartid);
1573 	u128_print(fp, "    Vendor ID", rv.smbpirv_vendid);
1574 	u128_print(fp, "    Architecture ID", rv.smbpirv_archid);
1575 	u128_print(fp, "    Implementation ID", rv.smbpirv_machid);
1576 	flag64_printf(fp, "  ISA", rv.smbpirv_isa,
1577 	    sizeof (rv.smbpirv_isa) * NBBY, smbios_riscv_isa_name,
1578 	    smbios_riscv_isa_desc);
1579 	flag_printf(fp, "  Privilege Levels", rv.smbpirv_privlvl,
1580 	    sizeof (rv.smbpirv_privlvl) * NBBY, smbios_riscv_priv_name,
1581 	    smbios_riscv_priv_desc);
1582 	u128_print(fp, "    Machine Exception Trap Delegation",
1583 	    rv.smbpirv_metdi);
1584 	u128_print(fp, "    Machine Interrupt Trap Delegation",
1585 	    rv.smbpirv_mitdi);
1586 	desc_printf(smbios_riscv_width_desc(rv.smbpirv_xlen),
1587 	    fp, "    Register Width: 0x%x", rv.smbpirv_xlen);
1588 	desc_printf(smbios_riscv_width_desc(rv.smbpirv_mxlen),
1589 	    fp, "    M-Mode Register Width: 0x%x", rv.smbpirv_mxlen);
1590 	desc_printf(smbios_riscv_width_desc(rv.smbpirv_sxlen),
1591 	    fp, "    S-Mode Register Width: 0x%x", rv.smbpirv_sxlen);
1592 	desc_printf(smbios_riscv_width_desc(rv.smbpirv_uxlen),
1593 	    fp, "    U-Mode Register Width: 0x%x", rv.smbpirv_uxlen);
1594 }
1595 
1596 static void
1597 print_processor_info(smbios_hdl_t *shp, id_t id, FILE *fp)
1598 {
1599 	smbios_processor_info_t p;
1600 
1601 	if (smbios_info_processor_info(shp, id, &p) != 0) {
1602 		smbios_warn(shp, "failed to read processor additional "
1603 		    "information");
1604 		return;
1605 	}
1606 
1607 	id_printf(fp, "  Processor Handle: ", p.smbpi_processor);
1608 	desc_printf(smbios_processor_info_type_desc(p.smbpi_ptype),
1609 	    fp, "  Processor Type: %u", p.smbpi_ptype);
1610 
1611 	switch (p.smbpi_ptype) {
1612 	case SMB_PROCINFO_T_RV32:
1613 	case SMB_PROCINFO_T_RV64:
1614 	case SMB_PROCINFO_T_RV128:
1615 		oprintf(fp, "  RISC-V Additional Processor Information:\n");
1616 		print_processor_info_riscv(shp, id, fp);
1617 		break;
1618 	default:
1619 		break;
1620 	}
1621 }
1622 
1623 static void
1624 print_battery(smbios_hdl_t *shp, id_t id, FILE *fp)
1625 {
1626 	smbios_battery_t bat;
1627 
1628 	if (smbios_info_battery(shp, id, &bat) != 0) {
1629 		smbios_warn(shp, "failed to read battery information");
1630 		return;
1631 	}
1632 
1633 	if (bat.smbb_date != NULL) {
1634 		str_print(fp, "  Manufacture Date", bat.smbb_date);
1635 	}
1636 
1637 	if (bat.smbb_serial != NULL) {
1638 		str_print(fp, "  Serial Number", bat.smbb_serial);
1639 	}
1640 
1641 	if (bat.smbb_chem != SMB_BDC_UNKNOWN) {
1642 		desc_printf(smbios_battery_chem_desc(bat.smbb_chem),
1643 		    fp, "  Battery Chemistry: 0x%x", bat.smbb_chem);
1644 	}
1645 
1646 	if (bat.smbb_cap != 0) {
1647 		oprintf(fp, "  Design Capacity: %u mWh\n", bat.smbb_cap);
1648 	} else {
1649 		oprintf(fp, "  Design Capacity: unknown\n");
1650 	}
1651 
1652 	if (bat.smbb_volt != 0) {
1653 		oprintf(fp, "  Design Voltage: %u mV\n", bat.smbb_volt);
1654 	} else {
1655 		oprintf(fp, "  Design Voltage: unknown\n");
1656 	}
1657 
1658 	str_print(fp, "  SBDS Version Number", bat.smbb_version);
1659 	if (bat.smbb_err != UINT8_MAX) {
1660 		oprintf(fp, "  Maximum Error: %u\n", bat.smbb_err);
1661 	} else {
1662 		oprintf(fp, "  Maximum Error: unknown\n", bat.smbb_err);
1663 	}
1664 	oprintf(fp, "  SBDS Serial Number: %04x\n", bat.smbb_ssn);
1665 	oprintf(fp, "  SBDS Manufacture Date: %u-%02u-%02u\n", bat.smbb_syear,
1666 	    bat.smbb_smonth, bat.smbb_sday);
1667 	str_print(fp, "  SBDS Device Chemistry", bat.smbb_schem);
1668 	oprintf(fp, "  OEM-specific Information: 0x%08x\n", bat.smbb_oemdata);
1669 }
1670 
1671 static void
1672 print_pointdev(smbios_hdl_t *shp, id_t id, FILE *fp)
1673 {
1674 	smbios_pointdev_t pd;
1675 
1676 	if (smbios_info_pointdev(shp, id, &pd) != 0) {
1677 		smbios_warn(shp, "failed to read pointer device information");
1678 		return;
1679 	}
1680 
1681 	desc_printf(smbios_pointdev_type_desc(pd.smbpd_type),
1682 	    fp, "  Type: %u", pd.smbpd_type);
1683 	desc_printf(smbios_pointdev_iface_desc(pd.smbpd_iface),
1684 	    fp, "  Interface: %u", pd.smbpd_iface);
1685 	oprintf(fp, "  Buttons: %u\n", pd.smbpd_nbuttons);
1686 }
1687 
1688 static void
1689 print_extprocessor(smbios_hdl_t *shp, id_t id, FILE *fp)
1690 {
1691 	int i;
1692 	smbios_processor_ext_t ep;
1693 
1694 	if (check_oem(shp) != 0)
1695 		return;
1696 
1697 	if (smbios_info_extprocessor(shp, id, &ep) != 0) {
1698 		smbios_warn(shp, "failed to read extended processor "
1699 		    "information");
1700 		return;
1701 	}
1702 
1703 	oprintf(fp, "  Processor: %u\n", ep.smbpe_processor);
1704 	oprintf(fp, "  FRU: %u\n", ep.smbpe_fru);
1705 	oprintf(fp, "  Initial APIC ID count: %u\n\n", ep.smbpe_n);
1706 
1707 	for (i = 0; i < ep.smbpe_n; i++) {
1708 		oprintf(fp, "  Logical Strand %u: Initial APIC ID: %u\n", i,
1709 		    ep.smbpe_apicid[i]);
1710 	}
1711 }
1712 
1713 static void
1714 print_extport(smbios_hdl_t *shp, id_t id, FILE *fp)
1715 {
1716 	smbios_port_ext_t epo;
1717 
1718 	if (check_oem(shp) != 0)
1719 		return;
1720 
1721 	if (smbios_info_extport(shp, id, &epo) != 0) {
1722 		smbios_warn(shp, "failed to read extended port information");
1723 		return;
1724 	}
1725 
1726 	oprintf(fp, "  Chassis Handle: %u\n", epo.smbporte_chassis);
1727 	oprintf(fp, "  Port Connector Handle: %u\n", epo.smbporte_port);
1728 	oprintf(fp, "  Device Type: %u\n", epo.smbporte_dtype);
1729 	oprintf(fp, "  Device Handle: %u\n", epo.smbporte_devhdl);
1730 	oprintf(fp, "  PHY: %u\n", epo.smbporte_phy);
1731 }
1732 
1733 static void
1734 print_pciexrc(smbios_hdl_t *shp, id_t id, FILE *fp)
1735 {
1736 	smbios_pciexrc_t pcie;
1737 
1738 	if (check_oem(shp) != 0)
1739 		return;
1740 
1741 	if (smbios_info_pciexrc(shp, id, &pcie) != 0) {
1742 		smbios_warn(shp, "failed to read pciexrc information");
1743 		return;
1744 	}
1745 
1746 	oprintf(fp, "  Component ID: %u\n", pcie.smbpcie_bb);
1747 	oprintf(fp, "  BDF: 0x%x\n", pcie.smbpcie_bdf);
1748 }
1749 
1750 static void
1751 print_extmemarray(smbios_hdl_t *shp, id_t id, FILE *fp)
1752 {
1753 	smbios_memarray_ext_t em;
1754 
1755 	if (check_oem(shp) != 0)
1756 		return;
1757 
1758 	if (smbios_info_extmemarray(shp, id, &em) != 0) {
1759 		smbios_warn(shp, "failed to read extmemarray information");
1760 		return;
1761 	}
1762 
1763 	oprintf(fp, "  Physical Memory Array Handle: %u\n", em.smbmae_ma);
1764 	oprintf(fp, "  Component Parent Handle: %u\n", em.smbmae_comp);
1765 	oprintf(fp, "  BDF: 0x%x\n", em.smbmae_bdf);
1766 }
1767 
1768 static void
1769 print_extmemdevice(smbios_hdl_t *shp, id_t id, FILE *fp)
1770 {
1771 	int i;
1772 	smbios_memdevice_ext_t emd;
1773 
1774 	if (check_oem(shp) != 0)
1775 		return;
1776 
1777 	if (smbios_info_extmemdevice(shp, id, &emd) != 0) {
1778 		smbios_warn(shp, "failed to read extmemdevice information");
1779 		return;
1780 	}
1781 
1782 	oprintf(fp, "  Memory Device Handle: %u\n", emd.smbmdeve_md);
1783 	oprintf(fp, "  DRAM Channel: %u\n", emd.smbmdeve_drch);
1784 	oprintf(fp, "  Number of Chip Selects: %u\n", emd.smbmdeve_ncs);
1785 
1786 	for (i = 0; i < emd.smbmdeve_ncs; i++) {
1787 		oprintf(fp, "  Chip Select: %u\n", emd.smbmdeve_cs[i]);
1788 	}
1789 }
1790 
1791 static void
1792 print_strprop_info(smbios_hdl_t *shp, id_t id, FILE *fp)
1793 {
1794 	smbios_strprop_t prop;
1795 
1796 	if (smbios_info_strprop(shp, id, &prop) != 0) {
1797 		smbios_warn(shp, "failed to read string property information");
1798 		return;
1799 	}
1800 
1801 	desc_printf(smbios_strprop_id_desc(prop.smbsp_prop_id), fp,
1802 	    "  Property ID: %u", prop.smbsp_prop_id);
1803 	if (prop.smbsp_prop_val != NULL) {
1804 		str_print(fp, "  Property Value", prop.smbsp_prop_val);
1805 	}
1806 	id_printf(fp, "  Parent Handle: ", prop.smbsp_parent);
1807 }
1808 
1809 static void
1810 print_fwinfo(smbios_hdl_t *shp, id_t id, FILE *fp)
1811 {
1812 	smbios_fwinfo_t fw;
1813 	smbios_fwinfo_comp_t *comps;
1814 	uint_t ncomps, i;
1815 
1816 	if (smbios_info_fwinfo(shp, id, &fw) != 0) {
1817 		smbios_warn(shp, "failed to read firmware inventory");
1818 		return;
1819 	}
1820 
1821 	str_print(fp, "  Component Name", fw.smbfw_name);
1822 	str_print(fp, "  ID", fw.smbfw_id);
1823 	str_print(fp, "  Release Date", fw.smbfw_reldate);
1824 	str_print(fp, "  Lowest Supported Version", fw.smbfw_lsv);
1825 	desc_printf(smbios_fwinfo_vers_desc(fw.smbfw_vers_fmt), fp,
1826 	    "  Version Format: %u", fw.smbfw_vers_fmt);
1827 	desc_printf(smbios_fwinfo_id_desc(fw.smbfw_id_fmt), fp,
1828 	    "  ID Format: %u", fw.smbfw_id_fmt);
1829 	if (fw.smbfw_imgsz != UINT64_MAX) {
1830 		oprintf(fp, "  Image Size: %" PRIu64 "\n", fw.smbfw_imgsz);
1831 	} else {
1832 		oprintf(fp, "  Image Size: unknown\n");
1833 	}
1834 
1835 	flag_printf(fp, "Characteristics", fw.smbfw_chars,
1836 	    sizeof (fw.smbfw_chars) * NBBY, smbios_fwinfo_ch_name,
1837 	    smbios_fwinfo_ch_desc);
1838 
1839 	desc_printf(smbios_fwinfo_state_desc(fw.smbfw_state), fp, "  State: %u",
1840 	    fw.smbfw_state);
1841 	oprintf(fp, "  Number of Associated Components: %u\n",
1842 	    fw.smbfw_ncomps);
1843 
1844 	if (fw.smbfw_ncomps == 0)
1845 		return;
1846 
1847 	if (smbios_info_fwinfo_comps(shp, id, &ncomps, &comps) == -1) {
1848 		smbios_warn(shp, "failed to read firmware inventory "
1849 		    "components");
1850 		return;
1851 	}
1852 
1853 	oprintf(fp, "\n  Component Handles:\n");
1854 	for (i = 0; i < ncomps; i++) {
1855 		oprintf(fp, "    %ld\n", comps[i]);
1856 	}
1857 }
1858 
1859 static int
1860 print_struct(smbios_hdl_t *shp, const smbios_struct_t *sp, void *fp)
1861 {
1862 	smbios_info_t info;
1863 	int hex = opt_x;
1864 	const char *s;
1865 
1866 	if (opt_t != -1 && opt_t != sp->smbstr_type)
1867 		return (0); /* skip struct if type doesn't match -t */
1868 
1869 	if (!opt_O && (sp->smbstr_type == SMB_TYPE_MEMCTL ||
1870 	    sp->smbstr_type == SMB_TYPE_MEMMOD))
1871 		return (0); /* skip struct if type is obsolete */
1872 
1873 	if (g_hdr++ == 0 || !opt_s)
1874 		oprintf(fp, "%-5s %-4s %s\n", "ID", "SIZE", "TYPE");
1875 
1876 	oprintf(fp, "%-5u %-4lu",
1877 	    (uint_t)sp->smbstr_id, (ulong_t)sp->smbstr_size);
1878 
1879 	if ((s = smbios_type_name(sp->smbstr_type)) != NULL)
1880 		oprintf(fp, " %s (type %u)", s, sp->smbstr_type);
1881 	else if (sp->smbstr_type > SMB_TYPE_OEM_LO &&
1882 	    sp->smbstr_type < SMB_TYPE_OEM_HI)
1883 		oprintf(fp, " %s+%u (type %u)", "SMB_TYPE_OEM_LO",
1884 		    sp->smbstr_type - SMB_TYPE_OEM_LO, sp->smbstr_type);
1885 	else
1886 		oprintf(fp, " %u", sp->smbstr_type);
1887 
1888 	if ((s = smbios_type_desc(sp->smbstr_type)) != NULL)
1889 		oprintf(fp, " (%s)\n", s);
1890 	else
1891 		oprintf(fp, "\n");
1892 
1893 	if (opt_s)
1894 		return (0); /* only print header line if -s specified */
1895 
1896 	if (smbios_info_common(shp, sp->smbstr_id, &info) == 0) {
1897 		oprintf(fp, "\n");
1898 		print_common(&info, fp);
1899 	}
1900 
1901 	switch (sp->smbstr_type) {
1902 	case SMB_TYPE_BIOS:
1903 		oprintf(fp, "\n");
1904 		print_bios(shp, fp);
1905 		break;
1906 	case SMB_TYPE_SYSTEM:
1907 		oprintf(fp, "\n");
1908 		print_system(shp, fp);
1909 		break;
1910 	case SMB_TYPE_BASEBOARD:
1911 		oprintf(fp, "\n");
1912 		print_bboard(shp, sp->smbstr_id, fp);
1913 		break;
1914 	case SMB_TYPE_CHASSIS:
1915 		oprintf(fp, "\n");
1916 		print_chassis(shp, sp->smbstr_id, fp);
1917 		break;
1918 	case SMB_TYPE_PROCESSOR:
1919 		oprintf(fp, "\n");
1920 		print_processor(shp, sp->smbstr_id, fp);
1921 		break;
1922 	case SMB_TYPE_CACHE:
1923 		oprintf(fp, "\n");
1924 		print_cache(shp, sp->smbstr_id, fp);
1925 		break;
1926 	case SMB_TYPE_PORT:
1927 		oprintf(fp, "\n");
1928 		print_port(shp, sp->smbstr_id, fp);
1929 		break;
1930 	case SMB_TYPE_SLOT:
1931 		oprintf(fp, "\n");
1932 		print_slot(shp, sp->smbstr_id, fp);
1933 		break;
1934 	case SMB_TYPE_OBDEVS:
1935 		oprintf(fp, "\n");
1936 		print_obdevs(shp, sp->smbstr_id, fp);
1937 		break;
1938 	case SMB_TYPE_OEMSTR:
1939 	case SMB_TYPE_SYSCONFSTR:
1940 		oprintf(fp, "\n");
1941 		print_strtab(shp, sp->smbstr_id, fp);
1942 		break;
1943 	case SMB_TYPE_LANG:
1944 		oprintf(fp, "\n");
1945 		print_lang(shp, sp->smbstr_id, fp);
1946 		break;
1947 	case SMB_TYPE_EVENTLOG:
1948 		oprintf(fp, "\n");
1949 		print_evlog(shp, sp->smbstr_id, fp);
1950 		break;
1951 	case SMB_TYPE_MEMARRAY:
1952 		oprintf(fp, "\n");
1953 		print_memarray(shp, sp->smbstr_id, fp);
1954 		break;
1955 	case SMB_TYPE_MEMDEVICE:
1956 		oprintf(fp, "\n");
1957 		print_memdevice(shp, sp->smbstr_id, fp);
1958 		break;
1959 	case SMB_TYPE_MEMARRAYMAP:
1960 		oprintf(fp, "\n");
1961 		print_memarrmap(shp, sp->smbstr_id, fp);
1962 		break;
1963 	case SMB_TYPE_MEMDEVICEMAP:
1964 		oprintf(fp, "\n");
1965 		print_memdevmap(shp, sp->smbstr_id, fp);
1966 		break;
1967 	case SMB_TYPE_BATTERY:
1968 		oprintf(fp, "\n");
1969 		print_battery(shp, sp->smbstr_id, fp);
1970 		break;
1971 	case SMB_TYPE_POINTDEV:
1972 		oprintf(fp, "\n");
1973 		print_pointdev(shp, sp->smbstr_id, fp);
1974 		break;
1975 	case SMB_TYPE_SECURITY:
1976 		oprintf(fp, "\n");
1977 		print_hwsec(shp, fp);
1978 		break;
1979 	case SMB_TYPE_VPROBE:
1980 		oprintf(fp, "\n");
1981 		print_vprobe(shp, sp->smbstr_id, fp);
1982 		break;
1983 	case SMB_TYPE_COOLDEV:
1984 		oprintf(fp, "\n");
1985 		print_cooldev(shp, sp->smbstr_id, fp);
1986 		break;
1987 	case SMB_TYPE_TPROBE:
1988 		oprintf(fp, "\n");
1989 		print_tprobe(shp, sp->smbstr_id, fp);
1990 		break;
1991 	case SMB_TYPE_IPROBE:
1992 		oprintf(fp, "\n");
1993 		print_iprobe(shp, sp->smbstr_id, fp);
1994 		break;
1995 	case SMB_TYPE_BOOT:
1996 		oprintf(fp, "\n");
1997 		print_boot(shp, fp);
1998 		break;
1999 	case SMB_TYPE_IPMIDEV:
2000 		oprintf(fp, "\n");
2001 		print_ipmi(shp, fp);
2002 		break;
2003 	case SMB_TYPE_POWERSUP:
2004 		oprintf(fp, "\n");
2005 		print_powersup(shp, sp->smbstr_id, fp);
2006 		break;
2007 	case SMB_TYPE_OBDEVEXT:
2008 		oprintf(fp, "\n");
2009 		print_obdevs_ext(shp, sp->smbstr_id, fp);
2010 		break;
2011 	case SMB_TYPE_PROCESSOR_INFO:
2012 		oprintf(fp, "\n");
2013 		print_processor_info(shp, sp->smbstr_id, fp);
2014 		break;
2015 	case SMB_TYPE_STRPROP:
2016 		oprintf(fp, "\n");
2017 		print_strprop_info(shp, sp->smbstr_id, fp);
2018 		break;
2019 	case SMB_TYPE_FWINFO:
2020 		oprintf(fp, "\n");
2021 		print_fwinfo(shp, sp->smbstr_id, fp);
2022 		break;
2023 	case SUN_OEM_EXT_PROCESSOR:
2024 		oprintf(fp, "\n");
2025 		print_extprocessor(shp, sp->smbstr_id, fp);
2026 		break;
2027 	case SUN_OEM_EXT_PORT:
2028 		oprintf(fp, "\n");
2029 		print_extport(shp, sp->smbstr_id, fp);
2030 		break;
2031 	case SUN_OEM_PCIEXRC:
2032 		oprintf(fp, "\n");
2033 		print_pciexrc(shp, sp->smbstr_id, fp);
2034 		break;
2035 	case SUN_OEM_EXT_MEMARRAY:
2036 		oprintf(fp, "\n");
2037 		print_extmemarray(shp, sp->smbstr_id, fp);
2038 		break;
2039 	case SUN_OEM_EXT_MEMDEVICE:
2040 		oprintf(fp, "\n");
2041 		print_extmemdevice(shp, sp->smbstr_id, fp);
2042 		break;
2043 	default:
2044 		hex++;
2045 	}
2046 
2047 	if (hex)
2048 		print_bytes(sp->smbstr_data, sp->smbstr_size, fp);
2049 	else
2050 		oprintf(fp, "\n");
2051 
2052 	return (0);
2053 }
2054 
2055 static uint16_t
2056 getu16(const char *name, const char *s)
2057 {
2058 	u_longlong_t val;
2059 	char *p;
2060 
2061 	errno = 0;
2062 	val = strtoull(s, &p, 0);
2063 
2064 	if (errno != 0 || p == s || *p != '\0' || val > UINT16_MAX) {
2065 		(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
2066 		    g_pname, name, s);
2067 		exit(SMBIOS_USAGE);
2068 	}
2069 
2070 	return ((uint16_t)val);
2071 }
2072 
2073 static uint16_t
2074 getstype(const char *name, const char *s)
2075 {
2076 	const char *ts;
2077 	uint16_t t;
2078 
2079 	for (t = 0; t < SMB_TYPE_OEM_LO; t++) {
2080 		if ((ts = smbios_type_name(t)) != NULL && strcmp(s, ts) == 0)
2081 			return (t);
2082 	}
2083 
2084 	(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
2085 	    g_pname, name, s);
2086 
2087 	exit(SMBIOS_USAGE);
2088 	/*NOTREACHED*/
2089 }
2090 
2091 static int
2092 usage(FILE *fp)
2093 {
2094 	(void) fprintf(fp, "Usage: %s "
2095 	    "[-BeOsx] [-i id] [-t type] [-w file] [file]\n\n", g_pname);
2096 
2097 	(void) fprintf(fp,
2098 	    "\t-B disable header validation for broken BIOSes\n"
2099 	    "\t-e display SMBIOS entry point information\n"
2100 	    "\t-i display only the specified structure\n"
2101 	    "\t-O display obsolete structure types\n"
2102 	    "\t-s display only a summary of structure identifiers and types\n"
2103 	    "\t-t display only the specified structure type\n"
2104 	    "\t-w write the raw data to the specified file\n"
2105 	    "\t-x display raw data for structures\n");
2106 
2107 	return (SMBIOS_USAGE);
2108 }
2109 
2110 int
2111 main(int argc, char *argv[])
2112 {
2113 	const char *ifile = NULL;
2114 	const char *ofile = NULL;
2115 	int oflags = 0;
2116 
2117 	smbios_hdl_t *shp;
2118 	smbios_struct_t s;
2119 	int err, fd, c;
2120 	char *p;
2121 
2122 	if ((p = strrchr(argv[0], '/')) == NULL)
2123 		g_pname = argv[0];
2124 	else
2125 		g_pname = p + 1;
2126 
2127 	while (optind < argc) {
2128 		while ((c = getopt(argc, argv, "Bei:Ost:w:xZ")) != EOF) {
2129 			switch (c) {
2130 			case 'B':
2131 				oflags |= SMB_O_NOCKSUM | SMB_O_NOVERS;
2132 				break;
2133 			case 'e':
2134 				opt_e++;
2135 				break;
2136 			case 'i':
2137 				opt_i = getu16("struct ID", optarg);
2138 				break;
2139 			case 'O':
2140 				opt_O++;
2141 				break;
2142 			case 's':
2143 				opt_s++;
2144 				break;
2145 			case 't':
2146 				if (isdigit(optarg[0]))
2147 					opt_t = getu16("struct type", optarg);
2148 				else
2149 					opt_t = getstype("struct type", optarg);
2150 				break;
2151 			case 'w':
2152 				ofile = optarg;
2153 				break;
2154 			case 'x':
2155 				opt_x++;
2156 				break;
2157 			case 'Z':
2158 				oflags |= SMB_O_ZIDS; /* undocumented */
2159 				break;
2160 			default:
2161 				return (usage(stderr));
2162 			}
2163 		}
2164 
2165 		if (optind < argc) {
2166 			if (ifile != NULL) {
2167 				(void) fprintf(stderr, "%s: illegal "
2168 				    "argument -- %s\n", g_pname, argv[optind]);
2169 				return (SMBIOS_USAGE);
2170 			}
2171 			ifile = argv[optind++];
2172 		}
2173 	}
2174 
2175 	if ((shp = smbios_open(ifile, SMB_VERSION, oflags, &err)) == NULL) {
2176 		(void) fprintf(stderr, "%s: failed to load SMBIOS: %s\n",
2177 		    g_pname, smbios_errmsg(err));
2178 		return (SMBIOS_ERROR);
2179 	}
2180 
2181 	if (opt_i == -1 && opt_t == -1 && opt_e == 0 &&
2182 	    smbios_truncated(shp))
2183 		(void) fprintf(stderr, "%s: SMBIOS table is truncated\n",
2184 		    g_pname);
2185 
2186 	if (ofile != NULL) {
2187 		if ((fd = open(ofile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1) {
2188 			(void) fprintf(stderr, "%s: failed to open %s: %s\n",
2189 			    g_pname, ofile, strerror(errno));
2190 			err = SMBIOS_ERROR;
2191 		} else if (smbios_write(shp, fd) != 0) {
2192 			(void) fprintf(stderr, "%s: failed to write %s: %s\n",
2193 			    g_pname, ofile, smbios_errmsg(smbios_errno(shp)));
2194 			err = SMBIOS_ERROR;
2195 		}
2196 		smbios_close(shp);
2197 		return (err);
2198 	}
2199 
2200 	if (opt_e) {
2201 		print_smbios(shp, stdout);
2202 		smbios_close(shp);
2203 		return (SMBIOS_SUCCESS);
2204 	}
2205 
2206 	if (opt_O && (opt_i != -1 || opt_t != -1))
2207 		opt_O++; /* -i or -t imply displaying obsolete records */
2208 
2209 	if (opt_i != -1)
2210 		err = smbios_lookup_id(shp, opt_i, &s);
2211 	else
2212 		err = smbios_iter(shp, print_struct, stdout);
2213 
2214 	if (err != 0) {
2215 		(void) fprintf(stderr, "%s: failed to access SMBIOS: %s\n",
2216 		    g_pname, smbios_errmsg(smbios_errno(shp)));
2217 		smbios_close(shp);
2218 		return (SMBIOS_ERROR);
2219 	}
2220 
2221 	if (opt_i != -1)
2222 		(void) print_struct(shp, &s, stdout);
2223 
2224 	smbios_close(shp);
2225 	return (SMBIOS_SUCCESS);
2226 }
2227