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