xref: /titanic_41/usr/src/cmd/smbios/smbios.c (revision 967d0e8a751eaccea6022668cd46d532ebea8f89)
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 2016 Joyent, Inc.
25  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
26  * Use is subject to license terms.
27  */
28 
29 #include <sys/sysmacros.h>
30 #include <sys/param.h>
31 
32 #include <smbios.h>
33 #include <alloca.h>
34 #include <limits.h>
35 #include <unistd.h>
36 #include <strings.h>
37 #include <stdlib.h>
38 #include <stdarg.h>
39 #include <stdio.h>
40 #include <fcntl.h>
41 #include <errno.h>
42 #include <ctype.h>
43 
44 #define	SMBIOS_SUCCESS	0
45 #define	SMBIOS_ERROR	1
46 #define	SMBIOS_USAGE	2
47 
48 static const char *g_pname;
49 static int g_hdr;
50 
51 static int opt_e;
52 static int opt_i = -1;
53 static int opt_O;
54 static int opt_s;
55 static int opt_t = -1;
56 static int opt_x;
57 
58 /*PRINTFLIKE2*/
59 static void
oprintf(FILE * fp,const char * format,...)60 oprintf(FILE *fp, const char *format, ...)
61 {
62 	va_list ap;
63 
64 	va_start(ap, format);
65 	(void) vfprintf(fp, format, ap);
66 	va_end(ap);
67 }
68 
69 /*PRINTFLIKE3*/
70 static void
desc_printf(const char * d,FILE * fp,const char * format,...)71 desc_printf(const char *d, FILE *fp, const char *format, ...)
72 {
73 	va_list ap;
74 
75 	va_start(ap, format);
76 	(void) vfprintf(fp, format, ap);
77 	va_end(ap);
78 
79 	if (d != NULL)
80 		(void) fprintf(fp, " (%s)\n", d);
81 	else
82 		(void) fprintf(fp, "\n");
83 }
84 
85 static void
flag_printf(FILE * fp,const char * s,uint_t flags,size_t bits,const char * (* flag_name)(uint_t),const char * (* flag_desc)(uint_t))86 flag_printf(FILE *fp, const char *s, uint_t flags, size_t bits,
87     const char *(*flag_name)(uint_t), const char *(*flag_desc)(uint_t))
88 {
89 	size_t i;
90 
91 	oprintf(fp, "  %s: 0x%x\n", s, flags);
92 
93 	for (i = 0; i < bits; i++) {
94 		uint_t f = 1 << i;
95 		const char *n;
96 
97 		if (!(flags & f))
98 			continue;
99 
100 		if ((n = flag_name(f)) != NULL)
101 			desc_printf(flag_desc(f), fp, "\t%s", n);
102 		else
103 			desc_printf(flag_desc(f), fp, "\t0x%x", f);
104 	}
105 }
106 
107 static void
flag64_printf(FILE * fp,const char * s,uint64_t flags,size_t bits,const char * (* flag_name)(uint64_t),const char * (* flag_desc)(uint64_t))108 flag64_printf(FILE *fp, const char *s, uint64_t flags, size_t bits,
109     const char *(*flag_name)(uint64_t), const char *(*flag_desc)(uint64_t))
110 {
111 	size_t i;
112 
113 	oprintf(fp, "  %s: 0x%llx\n", s, (u_longlong_t)flags);
114 
115 	for (i = 0; i < bits; i++) {
116 		u_longlong_t f = 1ULL << i;
117 		const char *n;
118 
119 		if (!(flags & f))
120 			continue;
121 
122 		if ((n = flag_name(f)) != NULL)
123 			desc_printf(flag_desc(f), fp, "\t%s", n);
124 		else
125 			desc_printf(flag_desc(f), fp, "\t0x%llx", f);
126 	}
127 }
128 
129 static void
id_printf(FILE * fp,const char * s,id_t id)130 id_printf(FILE *fp, const char *s, id_t id)
131 {
132 	switch (id) {
133 	case SMB_ID_NONE:
134 		oprintf(fp, "%sNone\n", s);
135 		break;
136 	case SMB_ID_NOTSUP:
137 		oprintf(fp, "%sNot Supported\n", s);
138 		break;
139 	default:
140 		oprintf(fp, "%s%u\n", s, (uint_t)id);
141 	}
142 }
143 
144 static int
check_oem(smbios_hdl_t * shp)145 check_oem(smbios_hdl_t *shp)
146 {
147 	int i;
148 	int cnt;
149 	int rv;
150 	id_t oem_id;
151 	smbios_struct_t s;
152 	const char **oem_str;
153 
154 	rv = smbios_lookup_type(shp, SMB_TYPE_OEMSTR, &s);
155 	if (rv != 0) {
156 		return (-1);
157 	}
158 
159 	oem_id = s.smbstr_id;
160 
161 	cnt = smbios_info_strtab(shp, oem_id, 0, NULL);
162 	if (cnt > 0) {
163 		oem_str =  alloca(sizeof (char *) * cnt);
164 		(void) smbios_info_strtab(shp, oem_id, cnt, oem_str);
165 
166 		for (i = 0; i < cnt; i++) {
167 			if (strncmp(oem_str[i], SMB_PRMS1,
168 			    strlen(SMB_PRMS1) + 1) == 0) {
169 				return (0);
170 			}
171 		}
172 	}
173 
174 	return (-1);
175 }
176 
177 static void
print_smbios_21(smbios_21_entry_t * ep,FILE * fp)178 print_smbios_21(smbios_21_entry_t *ep, FILE *fp)
179 {
180 	int i;
181 
182 	oprintf(fp, "Entry Point Anchor Tag: %*.*s\n",
183 	    (int)sizeof (ep->smbe_eanchor), (int)sizeof (ep->smbe_eanchor),
184 	    ep->smbe_eanchor);
185 
186 	oprintf(fp, "Entry Point Checksum: 0x%x\n", ep->smbe_ecksum);
187 	oprintf(fp, "Entry Point Length: %u\n", ep->smbe_elen);
188 	oprintf(fp, "Entry Point Version: %u.%u\n",
189 	    ep->smbe_major, ep->smbe_minor);
190 	oprintf(fp, "Max Structure Size: %u\n", ep->smbe_maxssize);
191 	oprintf(fp, "Entry Point Revision: 0x%x\n", ep->smbe_revision);
192 
193 	oprintf(fp, "Entry Point Revision Data:");
194 	for (i = 0; i < sizeof (ep->smbe_format); i++)
195 		oprintf(fp, " 0x%02x", ep->smbe_format[i]);
196 	oprintf(fp, "\n");
197 
198 	oprintf(fp, "Intermediate Anchor Tag: %*.*s\n",
199 	    (int)sizeof (ep->smbe_ianchor), (int)sizeof (ep->smbe_ianchor),
200 	    ep->smbe_ianchor);
201 
202 	oprintf(fp, "Intermediate Checksum: 0x%x\n", ep->smbe_icksum);
203 	oprintf(fp, "Structure Table Length: %u\n", ep->smbe_stlen);
204 	oprintf(fp, "Structure Table Address: 0x%x\n", ep->smbe_staddr);
205 	oprintf(fp, "Structure Table Entries: %u\n", ep->smbe_stnum);
206 	oprintf(fp, "DMI BCD Revision: 0x%x\n", ep->smbe_bcdrev);
207 }
208 
209 static void
print_smbios_30(smbios_30_entry_t * ep,FILE * fp)210 print_smbios_30(smbios_30_entry_t *ep, FILE *fp)
211 {
212 	oprintf(fp, "Entry Point Anchor Tag: %*.*s\n",
213 	    (int)sizeof (ep->smbe_eanchor), (int)sizeof (ep->smbe_eanchor),
214 	    ep->smbe_eanchor);
215 
216 	oprintf(fp, "Entry Point Checksum: 0x%x\n", ep->smbe_ecksum);
217 	oprintf(fp, "Entry Point Length: %u\n", ep->smbe_elen);
218 	oprintf(fp, "SMBIOS Version: %u.%u\n",
219 	    ep->smbe_major, ep->smbe_minor);
220 	oprintf(fp, "SMBIOS DocRev: 0x%x\n", ep->smbe_docrev);
221 	oprintf(fp, "Entry Point Revision: 0x%x\n", ep->smbe_revision);
222 
223 	oprintf(fp, "Structure Table Length: %u\n", ep->smbe_stlen);
224 	oprintf(fp, "Structure Table Address: 0x%" PRIx64 "\n",
225 	    ep->smbe_staddr);
226 }
227 
228 static void
print_smbios(smbios_hdl_t * shp,FILE * fp)229 print_smbios(smbios_hdl_t *shp, FILE *fp)
230 {
231 	smbios_entry_t ep;
232 
233 	switch (smbios_info_smbios(shp, &ep)) {
234 	case SMBIOS_ENTRY_POINT_21:
235 		print_smbios_21(&ep.ep21, fp);
236 		break;
237 	case SMBIOS_ENTRY_POINT_30:
238 		print_smbios_30(&ep.ep30, fp);
239 		break;
240 	}
241 }
242 
243 static void
print_common(const smbios_info_t * ip,FILE * fp)244 print_common(const smbios_info_t *ip, FILE *fp)
245 {
246 	if (ip->smbi_manufacturer[0] != '\0')
247 		oprintf(fp, "  Manufacturer: %s\n", ip->smbi_manufacturer);
248 	if (ip->smbi_product[0] != '\0')
249 		oprintf(fp, "  Product: %s\n", ip->smbi_product);
250 	if (ip->smbi_version[0] != '\0')
251 		oprintf(fp, "  Version: %s\n", ip->smbi_version);
252 	if (ip->smbi_serial[0] != '\0')
253 		oprintf(fp, "  Serial Number: %s\n", ip->smbi_serial);
254 	if (ip->smbi_asset[0] != '\0')
255 		oprintf(fp, "  Asset Tag: %s\n", ip->smbi_asset);
256 	if (ip->smbi_location[0] != '\0')
257 		oprintf(fp, "  Location Tag: %s\n", ip->smbi_location);
258 	if (ip->smbi_part[0] != '\0')
259 		oprintf(fp, "  Part Number: %s\n", ip->smbi_part);
260 }
261 
262 static void
print_bios(smbios_hdl_t * shp,FILE * fp)263 print_bios(smbios_hdl_t *shp, FILE *fp)
264 {
265 	smbios_bios_t b;
266 
267 	(void) smbios_info_bios(shp, &b);
268 
269 	oprintf(fp, "  Vendor: %s\n", b.smbb_vendor);
270 	oprintf(fp, "  Version String: %s\n", b.smbb_version);
271 	oprintf(fp, "  Release Date: %s\n", b.smbb_reldate);
272 	oprintf(fp, "  Address Segment: 0x%x\n", b.smbb_segment);
273 	oprintf(fp, "  ROM Size: %" PRIu64 " bytes\n", b.smbb_extromsize);
274 	oprintf(fp, "  Image Size: %u bytes\n", b.smbb_runsize);
275 
276 	flag64_printf(fp, "Characteristics",
277 	    b.smbb_cflags, sizeof (b.smbb_cflags) * NBBY,
278 	    smbios_bios_flag_name, smbios_bios_flag_desc);
279 
280 	if (b.smbb_nxcflags > SMB_BIOSXB_1) {
281 		flag_printf(fp, "Characteristics Extension Byte 1",
282 		    b.smbb_xcflags[SMB_BIOSXB_1],
283 		    sizeof (b.smbb_xcflags[SMB_BIOSXB_1]) * NBBY,
284 		    smbios_bios_xb1_name, smbios_bios_xb1_desc);
285 	}
286 
287 	if (b.smbb_nxcflags > SMB_BIOSXB_2) {
288 		flag_printf(fp, "Characteristics Extension Byte 2",
289 		    b.smbb_xcflags[SMB_BIOSXB_2],
290 		    sizeof (b.smbb_xcflags[SMB_BIOSXB_2]) * NBBY,
291 		    smbios_bios_xb2_name, smbios_bios_xb2_desc);
292 	}
293 
294 	if (b.smbb_nxcflags > SMB_BIOSXB_BIOS_MIN) {
295 		oprintf(fp, "  Version Number: %u.%u\n",
296 		    b.smbb_biosv.smbv_major, b.smbb_biosv.smbv_minor);
297 	}
298 
299 	if (b.smbb_nxcflags > SMB_BIOSXB_ECFW_MIN) {
300 		oprintf(fp, "  Embedded Ctlr Firmware Version Number: %u.%u\n",
301 		    b.smbb_ecfwv.smbv_major, b.smbb_ecfwv.smbv_minor);
302 	}
303 }
304 
305 static void
print_system(smbios_hdl_t * shp,FILE * fp)306 print_system(smbios_hdl_t *shp, FILE *fp)
307 {
308 	smbios_system_t s;
309 	uint_t i;
310 
311 	(void) smbios_info_system(shp, &s);
312 
313 	oprintf(fp, "  UUID: ");
314 	for (i = 0; i < s.smbs_uuidlen; i++) {
315 		oprintf(fp, "%02x", s.smbs_uuid[i]);
316 		if (i == 3 || i == 5 || i == 7 || i == 9)
317 			oprintf(fp, "-");
318 	}
319 	oprintf(fp, "\n");
320 
321 	desc_printf(smbios_system_wakeup_desc(s.smbs_wakeup),
322 	    fp, "  Wake-Up Event: 0x%x", s.smbs_wakeup);
323 
324 	oprintf(fp, "  SKU Number: %s\n", s.smbs_sku);
325 	oprintf(fp, "  Family: %s\n", s.smbs_family);
326 }
327 
328 static void
print_bboard(smbios_hdl_t * shp,id_t id,FILE * fp)329 print_bboard(smbios_hdl_t *shp, id_t id, FILE *fp)
330 {
331 	smbios_bboard_t b;
332 	int chdl_cnt;
333 
334 	(void) smbios_info_bboard(shp, id, &b);
335 
336 	oprintf(fp, "  Chassis: %u\n", (uint_t)b.smbb_chassis);
337 
338 	flag_printf(fp, "Flags", b.smbb_flags, sizeof (b.smbb_flags) * NBBY,
339 	    smbios_bboard_flag_name, smbios_bboard_flag_desc);
340 
341 	desc_printf(smbios_bboard_type_desc(b.smbb_type),
342 	    fp, "  Board Type: 0x%x", b.smbb_type);
343 
344 	chdl_cnt = b.smbb_contn;
345 	if (chdl_cnt != 0) {
346 		id_t *chdl;
347 		uint16_t hdl;
348 		int i, n, cnt;
349 
350 		chdl = alloca(chdl_cnt * sizeof (id_t));
351 		cnt = smbios_info_contains(shp, id, chdl_cnt, chdl);
352 		if (cnt > SMB_CONT_MAX)
353 			return;
354 		n = MIN(chdl_cnt, cnt);
355 
356 		oprintf(fp, "\n");
357 		for (i = 0; i < n; i++) {
358 			hdl = (uint16_t)chdl[i];
359 			oprintf(fp, "  Contained Handle: %u\n", hdl);
360 		}
361 	}
362 }
363 
364 static void
print_chassis(smbios_hdl_t * shp,id_t id,FILE * fp)365 print_chassis(smbios_hdl_t *shp, id_t id, FILE *fp)
366 {
367 	smbios_chassis_t c;
368 	int elem_cnt;
369 
370 	(void) smbios_info_chassis(shp, id, &c);
371 
372 	oprintf(fp, "  OEM Data: 0x%x\n", c.smbc_oemdata);
373 	oprintf(fp, "  SKU number: %s\n",
374 	    c.smbc_sku[0] == '\0' ? "<unknown>" : c.smbc_sku);
375 	oprintf(fp, "  Lock Present: %s\n", c.smbc_lock ? "Y" : "N");
376 
377 	desc_printf(smbios_chassis_type_desc(c.smbc_type),
378 	    fp, "  Chassis Type: 0x%x", c.smbc_type);
379 
380 	desc_printf(smbios_chassis_state_desc(c.smbc_bustate),
381 	    fp, "  Boot-Up State: 0x%x", c.smbc_bustate);
382 
383 	desc_printf(smbios_chassis_state_desc(c.smbc_psstate),
384 	    fp, "  Power Supply State: 0x%x", c.smbc_psstate);
385 
386 	desc_printf(smbios_chassis_state_desc(c.smbc_thstate),
387 	    fp, "  Thermal State: 0x%x", c.smbc_thstate);
388 
389 	oprintf(fp, "  Chassis Height: %uu\n", c.smbc_uheight);
390 	oprintf(fp, "  Power Cords: %u\n", c.smbc_cords);
391 
392 	elem_cnt = c.smbc_elems;
393 	oprintf(fp, "  Element Records: %u\n", elem_cnt);
394 
395 	if (elem_cnt > 0) {
396 		id_t *elems;
397 		uint8_t type;
398 		int i, n, cnt;
399 
400 		elems = alloca(c.smbc_elems * sizeof (id_t));
401 		cnt = smbios_info_contains(shp, id, elem_cnt, elems);
402 		if (cnt > SMB_CONT_MAX)
403 			return;
404 		n = MIN(elem_cnt, cnt);
405 
406 		oprintf(fp, "\n");
407 		for (i = 0; i < n; i++) {
408 			type = (uint8_t)elems[i];
409 			if (type & 0x80) {
410 				/* SMBIOS structrure Type */
411 				desc_printf(smbios_type_name(type & 0x7f), fp,
412 				    "  Contained SMBIOS structure Type: %u",
413 				    type & 0x80);
414 			} else {
415 				/* SMBIOS Base Board Type */
416 				desc_printf(smbios_bboard_type_desc(type), fp,
417 				    "  Contained SMBIOS Base Board Type: 0x%x",
418 				    type);
419 			}
420 		}
421 	}
422 }
423 
424 static void
print_processor(smbios_hdl_t * shp,id_t id,FILE * fp)425 print_processor(smbios_hdl_t *shp, id_t id, FILE *fp)
426 {
427 	smbios_processor_t p;
428 	uint_t status;
429 
430 	(void) smbios_info_processor(shp, id, &p);
431 	status = SMB_PRSTATUS_STATUS(p.smbp_status);
432 
433 	desc_printf(smbios_processor_family_desc(p.smbp_family),
434 	    fp, "  Family: %u", p.smbp_family);
435 
436 	if (p.smbp_family2 != 0)
437 		desc_printf(smbios_processor_family_desc(p.smbp_family2),
438 		    fp, "  Family Ext: %u", p.smbp_family2);
439 
440 	oprintf(fp, "  CPUID: 0x%llx\n", (u_longlong_t)p.smbp_cpuid);
441 
442 	desc_printf(smbios_processor_type_desc(p.smbp_type),
443 	    fp, "  Type: %u", p.smbp_type);
444 
445 	desc_printf(smbios_processor_upgrade_desc(p.smbp_upgrade),
446 	    fp, "  Socket Upgrade: %u", p.smbp_upgrade);
447 
448 	oprintf(fp, "  Socket Status: %s\n",
449 	    SMB_PRSTATUS_PRESENT(p.smbp_status) ?
450 	    "Populated" : "Not Populated");
451 
452 	desc_printf(smbios_processor_status_desc(status),
453 	    fp, "  Processor Status: %u", status);
454 
455 	if (SMB_PRV_LEGACY(p.smbp_voltage)) {
456 		oprintf(fp, "  Supported Voltages:");
457 		switch (p.smbp_voltage) {
458 		case SMB_PRV_5V:
459 			oprintf(fp, " 5.0V");
460 			break;
461 		case SMB_PRV_33V:
462 			oprintf(fp, " 3.3V");
463 			break;
464 		case SMB_PRV_29V:
465 			oprintf(fp, " 2.9V");
466 			break;
467 		}
468 		oprintf(fp, "\n");
469 	} else {
470 		oprintf(fp, "  Supported Voltages: %.1fV\n",
471 		    (float)SMB_PRV_VOLTAGE(p.smbp_voltage) / 10);
472 	}
473 
474 	if (p.smbp_corecount != 0) {
475 		if (p.smbp_corecount != 0xff || p.smbp_corecount2 == 0)
476 			oprintf(fp, "  Core Count: %u\n", p.smbp_corecount);
477 		else
478 			oprintf(fp, "  Core Count: %u\n", p.smbp_corecount2);
479 	} else {
480 		oprintf(fp, "  Core Count: Unknown\n");
481 	}
482 
483 	if (p.smbp_coresenabled != 0) {
484 		if (p.smbp_coresenabled != 0xff || p.smbp_coresenabled2 == 0) {
485 			oprintf(fp, "  Cores Enabled: %u\n",
486 			    p.smbp_coresenabled);
487 		} else {
488 			oprintf(fp, "  Cores Enabled: %u\n",
489 			    p.smbp_coresenabled2);
490 		}
491 	} else {
492 		oprintf(fp, "  Cores Enabled: Unknown\n");
493 	}
494 
495 	if (p.smbp_threadcount != 0) {
496 		if (p.smbp_threadcount != 0xff || p.smbp_threadcount2 == 0) {
497 			oprintf(fp, "  Thread Count: %u\n",
498 			    p.smbp_threadcount);
499 		} else {
500 			oprintf(fp, "  Thread Count: %u\n",
501 			    p.smbp_threadcount2);
502 		}
503 	} else {
504 		oprintf(fp, "  Thread Count: Unknown\n");
505 	}
506 
507 	if (p.smbp_cflags) {
508 		flag_printf(fp, "Processor Characteristics",
509 		    p.smbp_cflags, sizeof (p.smbp_cflags) * NBBY,
510 		    smbios_processor_core_flag_name,
511 		    smbios_processor_core_flag_desc);
512 	}
513 
514 	if (p.smbp_clkspeed != 0)
515 		oprintf(fp, "  External Clock Speed: %uMHz\n", p.smbp_clkspeed);
516 	else
517 		oprintf(fp, "  External Clock Speed: Unknown\n");
518 
519 	if (p.smbp_maxspeed != 0)
520 		oprintf(fp, "  Maximum Speed: %uMHz\n", p.smbp_maxspeed);
521 	else
522 		oprintf(fp, "  Maximum Speed: Unknown\n");
523 
524 	if (p.smbp_curspeed != 0)
525 		oprintf(fp, "  Current Speed: %uMHz\n", p.smbp_curspeed);
526 	else
527 		oprintf(fp, "  Current Speed: Unknown\n");
528 
529 	id_printf(fp, "	 L1 Cache: ", p.smbp_l1cache);
530 	id_printf(fp, "	 L2 Cache: ", p.smbp_l2cache);
531 	id_printf(fp, "	 L3 Cache: ", p.smbp_l3cache);
532 }
533 
534 static void
print_cache(smbios_hdl_t * shp,id_t id,FILE * fp)535 print_cache(smbios_hdl_t *shp, id_t id, FILE *fp)
536 {
537 	smbios_cache_t c;
538 
539 	(void) smbios_info_cache(shp, id, &c);
540 
541 	oprintf(fp, "  Level: %u\n", c.smba_level);
542 	oprintf(fp, "  Maximum Installed Size: %" PRIu64 " bytes\n",
543 	    c.smba_maxsize2);
544 
545 	if (c.smba_size2 != 0) {
546 		oprintf(fp, "  Installed Size: %" PRIu64 " bytes\n",
547 		    c.smba_size2);
548 	} else {
549 		oprintf(fp, "  Installed Size: Not Installed\n");
550 	}
551 
552 	if (c.smba_speed != 0)
553 		oprintf(fp, "  Speed: %uns\n", c.smba_speed);
554 	else
555 		oprintf(fp, "  Speed: Unknown\n");
556 
557 	flag_printf(fp, "Supported SRAM Types",
558 	    c.smba_stype, sizeof (c.smba_stype) * NBBY,
559 	    smbios_cache_ctype_name, smbios_cache_ctype_desc);
560 
561 	desc_printf(smbios_cache_ctype_desc(c.smba_ctype),
562 	    fp, "  Current SRAM Type: 0x%x", c.smba_ctype);
563 
564 	desc_printf(smbios_cache_ecc_desc(c.smba_etype),
565 	    fp, "  Error Correction Type: %u", c.smba_etype);
566 
567 	desc_printf(smbios_cache_logical_desc(c.smba_ltype),
568 	    fp, "  Logical Cache Type: %u", c.smba_ltype);
569 
570 	desc_printf(smbios_cache_assoc_desc(c.smba_assoc),
571 	    fp, "  Associativity: %u", c.smba_assoc);
572 
573 	desc_printf(smbios_cache_mode_desc(c.smba_mode),
574 	    fp, "  Mode: %u", c.smba_mode);
575 
576 	desc_printf(smbios_cache_loc_desc(c.smba_location),
577 	    fp, "  Location: %u", c.smba_location);
578 
579 	flag_printf(fp, "Flags", c.smba_flags, sizeof (c.smba_flags) * NBBY,
580 	    smbios_cache_flag_name, smbios_cache_flag_desc);
581 }
582 
583 static void
print_port(smbios_hdl_t * shp,id_t id,FILE * fp)584 print_port(smbios_hdl_t *shp, id_t id, FILE *fp)
585 {
586 	smbios_port_t p;
587 
588 	(void) smbios_info_port(shp, id, &p);
589 
590 	oprintf(fp, "  Internal Reference Designator: %s\n", p.smbo_iref);
591 	oprintf(fp, "  External Reference Designator: %s\n", p.smbo_eref);
592 
593 	desc_printf(smbios_port_conn_desc(p.smbo_itype),
594 	    fp, "  Internal Connector Type: %u", p.smbo_itype);
595 
596 	desc_printf(smbios_port_conn_desc(p.smbo_etype),
597 	    fp, "  External Connector Type: %u", p.smbo_etype);
598 
599 	desc_printf(smbios_port_type_desc(p.smbo_ptype),
600 	    fp, "  Port Type: %u", p.smbo_ptype);
601 }
602 
603 static void
print_slot(smbios_hdl_t * shp,id_t id,FILE * fp)604 print_slot(smbios_hdl_t *shp, id_t id, FILE *fp)
605 {
606 	smbios_slot_t s;
607 	smbios_version_t v;
608 
609 	(void) smbios_info_slot(shp, id, &s);
610 	smbios_info_smbios_version(shp, &v);
611 
612 	oprintf(fp, "  Reference Designator: %s\n", s.smbl_name);
613 	oprintf(fp, "  Slot ID: 0x%x\n", s.smbl_id);
614 
615 	desc_printf(smbios_slot_type_desc(s.smbl_type),
616 	    fp, "  Type: 0x%x", s.smbl_type);
617 
618 	desc_printf(smbios_slot_width_desc(s.smbl_width),
619 	    fp, "  Width: 0x%x", s.smbl_width);
620 
621 	desc_printf(smbios_slot_usage_desc(s.smbl_usage),
622 	    fp, "  Usage: 0x%x", s.smbl_usage);
623 
624 	desc_printf(smbios_slot_length_desc(s.smbl_length),
625 	    fp, "  Length: 0x%x", s.smbl_length);
626 
627 	flag_printf(fp, "Slot Characteristics 1",
628 	    s.smbl_ch1, sizeof (s.smbl_ch1) * NBBY,
629 	    smbios_slot_ch1_name, smbios_slot_ch1_desc);
630 
631 	flag_printf(fp, "Slot Characteristics 2",
632 	    s.smbl_ch2, sizeof (s.smbl_ch2) * NBBY,
633 	    smbios_slot_ch2_name, smbios_slot_ch2_desc);
634 
635 	if (check_oem(shp) != 0 && (v.smbv_major < 2 || v.smbv_minor < 6))
636 		return;
637 
638 	oprintf(fp, "  Segment Group: %u\n", s.smbl_sg);
639 	oprintf(fp, "  Bus Number: %u\n", s.smbl_bus);
640 	oprintf(fp, "  Device/Function Number: %u\n", s.smbl_df);
641 }
642 
643 static void
print_obdevs_ext(smbios_hdl_t * shp,id_t id,FILE * fp)644 print_obdevs_ext(smbios_hdl_t *shp, id_t id, FILE *fp)
645 {
646 	boolean_t enabled;
647 	smbios_obdev_ext_t oe;
648 	const char *type;
649 
650 	(void) smbios_info_obdevs_ext(shp, id, &oe);
651 
652 	/*
653 	 * Bit 7 is always whether or not the device is enabled while bits 0:6
654 	 * are the actual device type.
655 	 */
656 	enabled = oe.smboe_dtype >> 7;
657 	type = smbios_onboard_type_desc(oe.smboe_dtype & 0x7f);
658 
659 	oprintf(fp, "  Reference Designator: %s\n", oe.smboe_name);
660 	oprintf(fp, "  Device Enabled: %s\n", enabled == B_TRUE ? "true" :
661 	    "false");
662 	oprintf(fp, "  Device Type: %s\n", type);
663 	oprintf(fp, "  Device Type Instance: %u\n", oe.smboe_dti);
664 	oprintf(fp, "  Segment Group Number: %u\n", oe.smboe_sg);
665 	oprintf(fp, "  Bus Number: %u\n", oe.smboe_bus);
666 	oprintf(fp, "  Device/Function Number: %u\n", oe.smboe_df);
667 }
668 
669 static void
print_obdevs(smbios_hdl_t * shp,id_t id,FILE * fp)670 print_obdevs(smbios_hdl_t *shp, id_t id, FILE *fp)
671 {
672 	smbios_obdev_t *argv;
673 	int i, argc;
674 
675 	if ((argc = smbios_info_obdevs(shp, id, 0, NULL)) > 0) {
676 		argv = alloca(sizeof (smbios_obdev_t) * argc);
677 		(void) smbios_info_obdevs(shp, id, argc, argv);
678 		for (i = 0; i < argc; i++)
679 			oprintf(fp, "  %s\n", argv[i].smbd_name);
680 	}
681 }
682 
683 static void
print_strtab(smbios_hdl_t * shp,id_t id,FILE * fp)684 print_strtab(smbios_hdl_t *shp, id_t id, FILE *fp)
685 {
686 	const char **argv;
687 	int i, argc;
688 
689 	if ((argc = smbios_info_strtab(shp, id, 0, NULL)) > 0) {
690 		argv = alloca(sizeof (char *) * argc);
691 		(void) smbios_info_strtab(shp, id, argc, argv);
692 		for (i = 0; i < argc; i++)
693 			oprintf(fp, "  %s\n", argv[i]);
694 	}
695 }
696 
697 static void
print_lang(smbios_hdl_t * shp,id_t id,FILE * fp)698 print_lang(smbios_hdl_t *shp, id_t id, FILE *fp)
699 {
700 	smbios_lang_t l;
701 
702 	(void) smbios_info_lang(shp, &l);
703 
704 	oprintf(fp, "  Current Language: %s\n", l.smbla_cur);
705 	oprintf(fp, "  Language String Format: %u\n", l.smbla_fmt);
706 	oprintf(fp, "  Number of Installed Languages: %u\n", l.smbla_num);
707 	oprintf(fp, "  Installed Languages:\n");
708 
709 	print_strtab(shp, id, fp);
710 }
711 
712 /*ARGSUSED*/
713 static void
print_evlog(smbios_hdl_t * shp,id_t id,FILE * fp)714 print_evlog(smbios_hdl_t *shp, id_t id, FILE *fp)
715 {
716 	smbios_evlog_t ev;
717 	uint32_t i;
718 
719 	(void) smbios_info_eventlog(shp, &ev);
720 
721 	oprintf(fp, "  Log Area Size: %lu bytes\n", (ulong_t)ev.smbev_size);
722 	oprintf(fp, "  Header Offset: %lu\n", (ulong_t)ev.smbev_hdr);
723 	oprintf(fp, "  Data Offset: %lu\n", (ulong_t)ev.smbev_data);
724 
725 	desc_printf(smbios_evlog_method_desc(ev.smbev_method),
726 	    fp, "  Data Access Method: %u", ev.smbev_method);
727 
728 	flag_printf(fp, "Log Flags",
729 	    ev.smbev_flags, sizeof (ev.smbev_flags) * NBBY,
730 	    smbios_evlog_flag_name, smbios_evlog_flag_desc);
731 
732 	desc_printf(smbios_evlog_format_desc(ev.smbev_format),
733 	    fp, "  Log Header Format: %u", ev.smbev_format);
734 
735 	oprintf(fp, "  Update Token: 0x%x\n", ev.smbev_token);
736 	oprintf(fp, "  Data Access Address: ");
737 
738 	switch (ev.smbev_method) {
739 	case SMB_EVM_1x1i_1x1d:
740 	case SMB_EVM_2x1i_1x1d:
741 	case SMB_EVM_1x2i_1x1d:
742 		oprintf(fp, "Index Address 0x%x, Data Address 0x%x\n",
743 		    ev.smbev_addr.eva_io.evi_iaddr,
744 		    ev.smbev_addr.eva_io.evi_daddr);
745 		break;
746 	case SMB_EVM_GPNV:
747 		oprintf(fp, "0x%x\n", ev.smbev_addr.eva_gpnv);
748 		break;
749 	default:
750 		oprintf(fp, "0x%x\n", ev.smbev_addr.eva_addr);
751 	}
752 
753 	oprintf(fp, "  Type Descriptors:\n");
754 
755 	for (i = 0; i < ev.smbev_typec; i++) {
756 		oprintf(fp, "  %u: Log Type 0x%x, Data Type 0x%x\n", i,
757 		    ev.smbev_typev[i].smbevt_ltype,
758 		    ev.smbev_typev[i].smbevt_dtype);
759 	}
760 }
761 
762 static void
print_bytes(const uint8_t * data,size_t size,FILE * fp)763 print_bytes(const uint8_t *data, size_t size, FILE *fp)
764 {
765 	size_t row, rows = P2ROUNDUP(size, 16) / 16;
766 	size_t col, cols;
767 
768 	char buf[17];
769 	uint8_t x;
770 
771 	oprintf(fp, "\n	 offset:   0 1 2 3  4 5 6 7  8 9 a b  c d e f  "
772 	    "0123456789abcdef\n");
773 
774 	for (row = 0; row < rows; row++) {
775 		oprintf(fp, "	 %#4lx: ", (ulong_t)row * 16);
776 		cols = MIN(size - row * 16, 16);
777 
778 		for (col = 0; col < cols; col++) {
779 			if (col % 4 == 0)
780 				oprintf(fp, " ");
781 			x = *data++;
782 			oprintf(fp, "%02x", x);
783 			buf[col] = x <= ' ' || x > '~' ? '.' : x;
784 		}
785 
786 		for (; col < 16; col++) {
787 			if (col % 4 == 0)
788 				oprintf(fp, " ");
789 			oprintf(fp, "  ");
790 			buf[col] = ' ';
791 		}
792 
793 		buf[col] = '\0';
794 		oprintf(fp, "  %s\n", buf);
795 	}
796 
797 	oprintf(fp, "\n");
798 }
799 
800 static void
print_memarray(smbios_hdl_t * shp,id_t id,FILE * fp)801 print_memarray(smbios_hdl_t *shp, id_t id, FILE *fp)
802 {
803 	smbios_memarray_t ma;
804 
805 	(void) smbios_info_memarray(shp, id, &ma);
806 
807 	desc_printf(smbios_memarray_loc_desc(ma.smbma_location),
808 	    fp, "  Location: %u", ma.smbma_location);
809 
810 	desc_printf(smbios_memarray_use_desc(ma.smbma_use),
811 	    fp, "  Use: %u", ma.smbma_use);
812 
813 	desc_printf(smbios_memarray_ecc_desc(ma.smbma_ecc),
814 	    fp, "  ECC: %u", ma.smbma_ecc);
815 
816 	oprintf(fp, "  Number of Slots/Sockets: %u\n", ma.smbma_ndevs);
817 	id_printf(fp, "	 Memory Error Data: ", ma.smbma_err);
818 	oprintf(fp, "  Max Capacity: %llu bytes\n",
819 	    (u_longlong_t)ma.smbma_size);
820 }
821 
822 static void
print_memdevice(smbios_hdl_t * shp,id_t id,FILE * fp)823 print_memdevice(smbios_hdl_t *shp, id_t id, FILE *fp)
824 {
825 	smbios_memdevice_t md;
826 
827 	(void) smbios_info_memdevice(shp, id, &md);
828 
829 	id_printf(fp, "	 Physical Memory Array: ", md.smbmd_array);
830 	id_printf(fp, "	 Memory Error Data: ", md.smbmd_error);
831 
832 	if (md.smbmd_twidth != -1u)
833 		oprintf(fp, "  Total Width: %u bits\n", md.smbmd_twidth);
834 	else
835 		oprintf(fp, "  Total Width: Unknown\n");
836 
837 	if (md.smbmd_dwidth != -1u)
838 		oprintf(fp, "  Data Width: %u bits\n", md.smbmd_dwidth);
839 	else
840 		oprintf(fp, "  Data Width: Unknown\n");
841 
842 	switch (md.smbmd_size) {
843 	case -1ull:
844 		oprintf(fp, "  Size: Unknown\n");
845 		break;
846 	case 0:
847 		oprintf(fp, "  Size: Not Populated\n");
848 		break;
849 	default:
850 		oprintf(fp, "  Size: %llu bytes\n",
851 		    (u_longlong_t)md.smbmd_size);
852 	}
853 
854 	desc_printf(smbios_memdevice_form_desc(md.smbmd_form),
855 	    fp, "  Form Factor: %u", md.smbmd_form);
856 
857 	if (md.smbmd_set == 0)
858 		oprintf(fp, "  Set: None\n");
859 	else if (md.smbmd_set == (uint8_t)-1u)
860 		oprintf(fp, "  Set: Unknown\n");
861 	else
862 		oprintf(fp, "  Set: %u\n", md.smbmd_set);
863 
864 	if (md.smbmd_rank != 0) {
865 		desc_printf(smbios_memdevice_rank_desc(md.smbmd_rank),
866 		    fp, "  Rank: %u", md.smbmd_rank);
867 	} else {
868 		oprintf(fp, "  Rank: Unknown\n");
869 	}
870 
871 	desc_printf(smbios_memdevice_type_desc(md.smbmd_type),
872 	    fp, "  Memory Type: %u", md.smbmd_type);
873 
874 	flag_printf(fp, "Flags", md.smbmd_flags, sizeof (md.smbmd_flags) * NBBY,
875 	    smbios_memdevice_flag_name, smbios_memdevice_flag_desc);
876 
877 	if (md.smbmd_speed != 0)
878 		oprintf(fp, "  Speed: %u MT/s\n", md.smbmd_speed);
879 	else
880 		oprintf(fp, "  Speed: Unknown\n");
881 
882 	if (md.smbmd_clkspeed != 0)
883 		oprintf(fp, "  Configured Speed: %u MT/s\n", md.smbmd_clkspeed);
884 	else
885 		oprintf(fp, "  Configured Speed: Unknown\n");
886 
887 	oprintf(fp, "  Device Locator: %s\n", md.smbmd_dloc);
888 	oprintf(fp, "  Bank Locator: %s\n", md.smbmd_bloc);
889 
890 	if (md.smbmd_minvolt != 0) {
891 		oprintf(fp, "  Minimum Voltage: %.2fV\n",
892 		    md.smbmd_minvolt / 1000.0);
893 	} else {
894 		oprintf(fp, "  Minimum Voltage: Unknown\n");
895 	}
896 
897 	if (md.smbmd_maxvolt != 0) {
898 		oprintf(fp, "  Maximum Voltage: %.2fV\n",
899 		    md.smbmd_maxvolt / 1000.0);
900 	} else {
901 		oprintf(fp, "  Maximum Voltage: Unknown\n");
902 	}
903 
904 	if (md.smbmd_confvolt != 0) {
905 		oprintf(fp, "  Configured Voltage: %.2fV\n",
906 		    md.smbmd_confvolt / 1000.0);
907 	} else {
908 		oprintf(fp, "  Configured Voltage: Unknown\n");
909 	}
910 }
911 
912 static void
print_memarrmap(smbios_hdl_t * shp,id_t id,FILE * fp)913 print_memarrmap(smbios_hdl_t *shp, id_t id, FILE *fp)
914 {
915 	smbios_memarrmap_t ma;
916 
917 	(void) smbios_info_memarrmap(shp, id, &ma);
918 
919 	id_printf(fp, "	 Physical Memory Array: ", ma.smbmam_array);
920 	oprintf(fp, "  Devices per Row: %u\n", ma.smbmam_width);
921 
922 	oprintf(fp, "  Physical Address: 0x%llx\n  Size: %llu bytes\n",
923 	    (u_longlong_t)ma.smbmam_addr, (u_longlong_t)ma.smbmam_size);
924 }
925 
926 static void
print_memdevmap(smbios_hdl_t * shp,id_t id,FILE * fp)927 print_memdevmap(smbios_hdl_t *shp, id_t id, FILE *fp)
928 {
929 	smbios_memdevmap_t md;
930 
931 	(void) smbios_info_memdevmap(shp, id, &md);
932 
933 	id_printf(fp, "	 Memory Device: ", md.smbmdm_device);
934 	id_printf(fp, "	 Memory Array Mapped Address: ", md.smbmdm_arrmap);
935 
936 	oprintf(fp, "  Physical Address: 0x%llx\n  Size: %llu bytes\n",
937 	    (u_longlong_t)md.smbmdm_addr, (u_longlong_t)md.smbmdm_size);
938 
939 	oprintf(fp, "  Partition Row Position: %u\n", md.smbmdm_rpos);
940 	oprintf(fp, "  Interleave Position: %u\n", md.smbmdm_ipos);
941 	oprintf(fp, "  Interleave Data Depth: %u\n", md.smbmdm_idepth);
942 }
943 
944 static void
print_hwsec(smbios_hdl_t * shp,FILE * fp)945 print_hwsec(smbios_hdl_t *shp, FILE *fp)
946 {
947 	smbios_hwsec_t h;
948 
949 	(void) smbios_info_hwsec(shp, &h);
950 
951 	desc_printf(smbios_hwsec_desc(h.smbh_pwr_ps),
952 	    fp, "  Power-On Password Status: %u", h.smbh_pwr_ps);
953 	desc_printf(smbios_hwsec_desc(h.smbh_kbd_ps),
954 	    fp, "  Keyboard Password Status: %u", h.smbh_kbd_ps);
955 	desc_printf(smbios_hwsec_desc(h.smbh_adm_ps),
956 	    fp, "  Administrator Password Status: %u", h.smbh_adm_ps);
957 	desc_printf(smbios_hwsec_desc(h.smbh_pan_ps),
958 	    fp, "  Front Panel Reset Status: %u", h.smbh_pan_ps);
959 }
960 
961 static void
print_boot(smbios_hdl_t * shp,FILE * fp)962 print_boot(smbios_hdl_t *shp, FILE *fp)
963 {
964 	smbios_boot_t b;
965 
966 	(void) smbios_info_boot(shp, &b);
967 
968 	desc_printf(smbios_boot_desc(b.smbt_status),
969 	    fp, "  Boot Status Code: 0x%x", b.smbt_status);
970 
971 	if (b.smbt_size != 0) {
972 		oprintf(fp, "  Boot Data (%lu bytes):\n", (ulong_t)b.smbt_size);
973 		print_bytes(b.smbt_data, b.smbt_size, fp);
974 	}
975 }
976 
977 static void
print_ipmi(smbios_hdl_t * shp,FILE * fp)978 print_ipmi(smbios_hdl_t *shp, FILE *fp)
979 {
980 	smbios_ipmi_t i;
981 
982 	(void) smbios_info_ipmi(shp, &i);
983 
984 	desc_printf(smbios_ipmi_type_desc(i.smbip_type),
985 	    fp, "  Type: %u", i.smbip_type);
986 
987 	oprintf(fp, "  BMC IPMI Version: %u.%u\n",
988 	    i.smbip_vers.smbv_major, i.smbip_vers.smbv_minor);
989 
990 	oprintf(fp, "  i2c Bus Slave Address: 0x%x\n", i.smbip_i2c);
991 	oprintf(fp, "  NV Storage Device Bus ID: 0x%x\n", i.smbip_bus);
992 	oprintf(fp, "  BMC Base Address: 0x%llx\n", (u_longlong_t)i.smbip_addr);
993 	oprintf(fp, "  Interrupt Number: %u\n", i.smbip_intr);
994 	oprintf(fp, "  Register Spacing: %u\n", i.smbip_regspacing);
995 
996 	flag_printf(fp, "Flags", i.smbip_flags, sizeof (i.smbip_flags) * NBBY,
997 	    smbios_ipmi_flag_name, smbios_ipmi_flag_desc);
998 }
999 
1000 static void
print_extprocessor(smbios_hdl_t * shp,id_t id,FILE * fp)1001 print_extprocessor(smbios_hdl_t *shp, id_t id, FILE *fp)
1002 {
1003 	int i;
1004 	smbios_processor_ext_t ep;
1005 
1006 	if (check_oem(shp) != 0)
1007 		return;
1008 
1009 	(void) smbios_info_extprocessor(shp, id, &ep);
1010 
1011 	oprintf(fp, "  Processor: %u\n", ep.smbpe_processor);
1012 	oprintf(fp, "  FRU: %u\n", ep.smbpe_fru);
1013 	oprintf(fp, "  Initial APIC ID count: %u\n\n", ep.smbpe_n);
1014 
1015 	for (i = 0; i < ep.smbpe_n; i++) {
1016 		oprintf(fp, "  Logical Strand %u: Initial APIC ID: %u\n", i,
1017 		    ep.smbpe_apicid[i]);
1018 	}
1019 }
1020 
1021 static void
print_extport(smbios_hdl_t * shp,id_t id,FILE * fp)1022 print_extport(smbios_hdl_t *shp, id_t id, FILE *fp)
1023 {
1024 	smbios_port_ext_t epo;
1025 
1026 	if (check_oem(shp) != 0)
1027 		return;
1028 
1029 	(void) smbios_info_extport(shp, id, &epo);
1030 
1031 	oprintf(fp, "  Chassis Handle: %u\n", epo.smbporte_chassis);
1032 	oprintf(fp, "  Port Connector Handle: %u\n", epo.smbporte_port);
1033 	oprintf(fp, "  Device Type: %u\n", epo.smbporte_dtype);
1034 	oprintf(fp, "  Device Handle: %u\n", epo.smbporte_devhdl);
1035 	oprintf(fp, "  PHY: %u\n", epo.smbporte_phy);
1036 }
1037 
1038 static void
print_pciexrc(smbios_hdl_t * shp,id_t id,FILE * fp)1039 print_pciexrc(smbios_hdl_t *shp, id_t id, FILE *fp)
1040 {
1041 	smbios_pciexrc_t pcie;
1042 
1043 	if (check_oem(shp) != 0)
1044 		return;
1045 
1046 	(void) smbios_info_pciexrc(shp, id, &pcie);
1047 
1048 	oprintf(fp, "  Component ID: %u\n", pcie.smbpcie_bb);
1049 	oprintf(fp, "  BDF: 0x%x\n", pcie.smbpcie_bdf);
1050 }
1051 
1052 static void
print_extmemarray(smbios_hdl_t * shp,id_t id,FILE * fp)1053 print_extmemarray(smbios_hdl_t *shp, id_t id, FILE *fp)
1054 {
1055 	smbios_memarray_ext_t em;
1056 
1057 	if (check_oem(shp) != 0)
1058 		return;
1059 
1060 	(void) smbios_info_extmemarray(shp, id, &em);
1061 
1062 	oprintf(fp, "  Physical Memory Array Handle: %u\n", em.smbmae_ma);
1063 	oprintf(fp, "  Component Parent Handle: %u\n", em.smbmae_comp);
1064 	oprintf(fp, "  BDF: 0x%x\n", em.smbmae_bdf);
1065 }
1066 
1067 static void
print_extmemdevice(smbios_hdl_t * shp,id_t id,FILE * fp)1068 print_extmemdevice(smbios_hdl_t *shp, id_t id, FILE *fp)
1069 {
1070 	int i;
1071 	smbios_memdevice_ext_t emd;
1072 
1073 	if (check_oem(shp) != 0)
1074 		return;
1075 
1076 	(void) smbios_info_extmemdevice(shp, id, &emd);
1077 
1078 	oprintf(fp, "  Memory Device Handle: %u\n", emd.smbmdeve_md);
1079 	oprintf(fp, "  DRAM Channel: %u\n", emd.smbmdeve_drch);
1080 	oprintf(fp, "  Number of Chip Selects: %u\n", emd.smbmdeve_ncs);
1081 
1082 	for (i = 0; i < emd.smbmdeve_ncs; i++) {
1083 		oprintf(fp, "  Chip Select: %u\n", emd.smbmdeve_cs[i]);
1084 	}
1085 }
1086 
1087 static int
print_struct(smbios_hdl_t * shp,const smbios_struct_t * sp,void * fp)1088 print_struct(smbios_hdl_t *shp, const smbios_struct_t *sp, void *fp)
1089 {
1090 	smbios_info_t info;
1091 	int hex = opt_x;
1092 	const char *s;
1093 
1094 	if (opt_t != -1 && opt_t != sp->smbstr_type)
1095 		return (0); /* skip struct if type doesn't match -t */
1096 
1097 	if (!opt_O && (sp->smbstr_type == SMB_TYPE_MEMCTL ||
1098 	    sp->smbstr_type == SMB_TYPE_MEMMOD))
1099 		return (0); /* skip struct if type is obsolete */
1100 
1101 	if (g_hdr++ == 0 || !opt_s)
1102 		oprintf(fp, "%-5s %-4s %s\n", "ID", "SIZE", "TYPE");
1103 
1104 	oprintf(fp, "%-5u %-4lu",
1105 	    (uint_t)sp->smbstr_id, (ulong_t)sp->smbstr_size);
1106 
1107 	if ((s = smbios_type_name(sp->smbstr_type)) != NULL)
1108 		oprintf(fp, " %s (type %u)", s, sp->smbstr_type);
1109 	else if (sp->smbstr_type > SMB_TYPE_OEM_LO &&
1110 	    sp->smbstr_type < SMB_TYPE_OEM_HI)
1111 		oprintf(fp, " %s+%u (type %u)", "SMB_TYPE_OEM_LO",
1112 		    sp->smbstr_type - SMB_TYPE_OEM_LO, sp->smbstr_type);
1113 	else
1114 		oprintf(fp, " %u", sp->smbstr_type);
1115 
1116 	if ((s = smbios_type_desc(sp->smbstr_type)) != NULL)
1117 		oprintf(fp, " (%s)\n", s);
1118 	else
1119 		oprintf(fp, "\n");
1120 
1121 	if (opt_s)
1122 		return (0); /* only print header line if -s specified */
1123 
1124 	if (smbios_info_common(shp, sp->smbstr_id, &info) == 0) {
1125 		oprintf(fp, "\n");
1126 		print_common(&info, fp);
1127 	}
1128 
1129 	switch (sp->smbstr_type) {
1130 	case SMB_TYPE_BIOS:
1131 		oprintf(fp, "\n");
1132 		print_bios(shp, fp);
1133 		break;
1134 	case SMB_TYPE_SYSTEM:
1135 		oprintf(fp, "\n");
1136 		print_system(shp, fp);
1137 		break;
1138 	case SMB_TYPE_BASEBOARD:
1139 		oprintf(fp, "\n");
1140 		print_bboard(shp, sp->smbstr_id, fp);
1141 		break;
1142 	case SMB_TYPE_CHASSIS:
1143 		oprintf(fp, "\n");
1144 		print_chassis(shp, sp->smbstr_id, fp);
1145 		break;
1146 	case SMB_TYPE_PROCESSOR:
1147 		oprintf(fp, "\n");
1148 		print_processor(shp, sp->smbstr_id, fp);
1149 		break;
1150 	case SMB_TYPE_CACHE:
1151 		oprintf(fp, "\n");
1152 		print_cache(shp, sp->smbstr_id, fp);
1153 		break;
1154 	case SMB_TYPE_PORT:
1155 		oprintf(fp, "\n");
1156 		print_port(shp, sp->smbstr_id, fp);
1157 		break;
1158 	case SMB_TYPE_SLOT:
1159 		oprintf(fp, "\n");
1160 		print_slot(shp, sp->smbstr_id, fp);
1161 		break;
1162 	case SMB_TYPE_OBDEVS:
1163 		oprintf(fp, "\n");
1164 		print_obdevs(shp, sp->smbstr_id, fp);
1165 		break;
1166 	case SMB_TYPE_OEMSTR:
1167 	case SMB_TYPE_SYSCONFSTR:
1168 		oprintf(fp, "\n");
1169 		print_strtab(shp, sp->smbstr_id, fp);
1170 		break;
1171 	case SMB_TYPE_LANG:
1172 		oprintf(fp, "\n");
1173 		print_lang(shp, sp->smbstr_id, fp);
1174 		break;
1175 	case SMB_TYPE_EVENTLOG:
1176 		oprintf(fp, "\n");
1177 		print_evlog(shp, sp->smbstr_id, fp);
1178 		break;
1179 	case SMB_TYPE_MEMARRAY:
1180 		oprintf(fp, "\n");
1181 		print_memarray(shp, sp->smbstr_id, fp);
1182 		break;
1183 	case SMB_TYPE_MEMDEVICE:
1184 		oprintf(fp, "\n");
1185 		print_memdevice(shp, sp->smbstr_id, fp);
1186 		break;
1187 	case SMB_TYPE_MEMARRAYMAP:
1188 		oprintf(fp, "\n");
1189 		print_memarrmap(shp, sp->smbstr_id, fp);
1190 		break;
1191 	case SMB_TYPE_MEMDEVICEMAP:
1192 		oprintf(fp, "\n");
1193 		print_memdevmap(shp, sp->smbstr_id, fp);
1194 		break;
1195 	case SMB_TYPE_SECURITY:
1196 		oprintf(fp, "\n");
1197 		print_hwsec(shp, fp);
1198 		break;
1199 	case SMB_TYPE_BOOT:
1200 		oprintf(fp, "\n");
1201 		print_boot(shp, fp);
1202 		break;
1203 	case SMB_TYPE_IPMIDEV:
1204 		oprintf(fp, "\n");
1205 		print_ipmi(shp, fp);
1206 		break;
1207 	case SMB_TYPE_OBDEVEXT:
1208 		oprintf(fp, "\n");
1209 		print_obdevs_ext(shp, sp->smbstr_id, fp);
1210 		break;
1211 	case SUN_OEM_EXT_PROCESSOR:
1212 		oprintf(fp, "\n");
1213 		print_extprocessor(shp, sp->smbstr_id, fp);
1214 		break;
1215 	case SUN_OEM_EXT_PORT:
1216 		oprintf(fp, "\n");
1217 		print_extport(shp, sp->smbstr_id, fp);
1218 		break;
1219 	case SUN_OEM_PCIEXRC:
1220 		oprintf(fp, "\n");
1221 		print_pciexrc(shp, sp->smbstr_id, fp);
1222 		break;
1223 	case SUN_OEM_EXT_MEMARRAY:
1224 		oprintf(fp, "\n");
1225 		print_extmemarray(shp, sp->smbstr_id, fp);
1226 		break;
1227 	case SUN_OEM_EXT_MEMDEVICE:
1228 		oprintf(fp, "\n");
1229 		print_extmemdevice(shp, sp->smbstr_id, fp);
1230 		break;
1231 	default:
1232 		hex++;
1233 	}
1234 
1235 	if (hex)
1236 		print_bytes(sp->smbstr_data, sp->smbstr_size, fp);
1237 	else
1238 		oprintf(fp, "\n");
1239 
1240 	return (0);
1241 }
1242 
1243 static uint16_t
getu16(const char * name,const char * s)1244 getu16(const char *name, const char *s)
1245 {
1246 	u_longlong_t val;
1247 	char *p;
1248 
1249 	errno = 0;
1250 	val = strtoull(s, &p, 0);
1251 
1252 	if (errno != 0 || p == s || *p != '\0' || val > UINT16_MAX) {
1253 		(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
1254 		    g_pname, name, s);
1255 		exit(SMBIOS_USAGE);
1256 	}
1257 
1258 	return ((uint16_t)val);
1259 }
1260 
1261 static uint16_t
getstype(const char * name,const char * s)1262 getstype(const char *name, const char *s)
1263 {
1264 	const char *ts;
1265 	uint16_t t;
1266 
1267 	for (t = 0; t < SMB_TYPE_OEM_LO; t++) {
1268 		if ((ts = smbios_type_name(t)) != NULL && strcmp(s, ts) == 0)
1269 			return (t);
1270 	}
1271 
1272 	(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
1273 	    g_pname, name, s);
1274 
1275 	exit(SMBIOS_USAGE);
1276 	/*NOTREACHED*/
1277 }
1278 
1279 static int
usage(FILE * fp)1280 usage(FILE *fp)
1281 {
1282 	(void) fprintf(fp, "Usage: %s "
1283 	    "[-BeOsx] [-i id] [-t type] [-w file] [file]\n\n", g_pname);
1284 
1285 	(void) fprintf(fp,
1286 	    "\t-B disable header validation for broken BIOSes\n"
1287 	    "\t-e display SMBIOS entry point information\n"
1288 	    "\t-i display only the specified structure\n"
1289 	    "\t-O display obsolete structure types\n"
1290 	    "\t-s display only a summary of structure identifiers and types\n"
1291 	    "\t-t display only the specified structure type\n"
1292 	    "\t-w write the raw data to the specified file\n"
1293 	    "\t-x display raw data for structures\n");
1294 
1295 	return (SMBIOS_USAGE);
1296 }
1297 
1298 int
main(int argc,char * argv[])1299 main(int argc, char *argv[])
1300 {
1301 	const char *ifile = NULL;
1302 	const char *ofile = NULL;
1303 	int oflags = 0;
1304 
1305 	smbios_hdl_t *shp;
1306 	smbios_struct_t s;
1307 	int err, fd, c;
1308 	char *p;
1309 
1310 	if ((p = strrchr(argv[0], '/')) == NULL)
1311 		g_pname = argv[0];
1312 	else
1313 		g_pname = p + 1;
1314 
1315 	while (optind < argc) {
1316 		while ((c = getopt(argc, argv, "Bei:Ost:w:xZ")) != EOF) {
1317 			switch (c) {
1318 			case 'B':
1319 				oflags |= SMB_O_NOCKSUM | SMB_O_NOVERS;
1320 				break;
1321 			case 'e':
1322 				opt_e++;
1323 				break;
1324 			case 'i':
1325 				opt_i = getu16("struct ID", optarg);
1326 				break;
1327 			case 'O':
1328 				opt_O++;
1329 				break;
1330 			case 's':
1331 				opt_s++;
1332 				break;
1333 			case 't':
1334 				if (isdigit(optarg[0]))
1335 					opt_t = getu16("struct type", optarg);
1336 				else
1337 					opt_t = getstype("struct type", optarg);
1338 				break;
1339 			case 'w':
1340 				ofile = optarg;
1341 				break;
1342 			case 'x':
1343 				opt_x++;
1344 				break;
1345 			case 'Z':
1346 				oflags |= SMB_O_ZIDS; /* undocumented */
1347 				break;
1348 			default:
1349 				return (usage(stderr));
1350 			}
1351 		}
1352 
1353 		if (optind < argc) {
1354 			if (ifile != NULL) {
1355 				(void) fprintf(stderr, "%s: illegal "
1356 				    "argument -- %s\n", g_pname, argv[optind]);
1357 				return (SMBIOS_USAGE);
1358 			}
1359 			ifile = argv[optind++];
1360 		}
1361 	}
1362 
1363 	if ((shp = smbios_open(ifile, SMB_VERSION, oflags, &err)) == NULL) {
1364 		(void) fprintf(stderr, "%s: failed to load SMBIOS: %s\n",
1365 		    g_pname, smbios_errmsg(err));
1366 		return (SMBIOS_ERROR);
1367 	}
1368 
1369 	if (opt_i == -1 && opt_t == -1 && opt_e == 0 &&
1370 	    smbios_truncated(shp))
1371 		(void) fprintf(stderr, "%s: SMBIOS table is truncated\n",
1372 		    g_pname);
1373 
1374 	if (ofile != NULL) {
1375 		if ((fd = open(ofile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1) {
1376 			(void) fprintf(stderr, "%s: failed to open %s: %s\n",
1377 			    g_pname, ofile, strerror(errno));
1378 			err = SMBIOS_ERROR;
1379 		} else if (smbios_write(shp, fd) != 0) {
1380 			(void) fprintf(stderr, "%s: failed to write %s: %s\n",
1381 			    g_pname, ofile, smbios_errmsg(smbios_errno(shp)));
1382 			err = SMBIOS_ERROR;
1383 		}
1384 		smbios_close(shp);
1385 		return (err);
1386 	}
1387 
1388 	if (opt_e) {
1389 		print_smbios(shp, stdout);
1390 		smbios_close(shp);
1391 		return (SMBIOS_SUCCESS);
1392 	}
1393 
1394 	if (opt_O && (opt_i != -1 || opt_t != -1))
1395 		opt_O++; /* -i or -t imply displaying obsolete records */
1396 
1397 	if (opt_i != -1)
1398 		err = smbios_lookup_id(shp, opt_i, &s);
1399 	else
1400 		err = smbios_iter(shp, print_struct, stdout);
1401 
1402 	if (err != 0) {
1403 		(void) fprintf(stderr, "%s: failed to access SMBIOS: %s\n",
1404 		    g_pname, smbios_errmsg(smbios_errno(shp)));
1405 		smbios_close(shp);
1406 		return (SMBIOS_ERROR);
1407 	}
1408 
1409 	if (opt_i != -1)
1410 		(void) print_struct(shp, &s, stdout);
1411 
1412 	smbios_close(shp);
1413 	return (SMBIOS_SUCCESS);
1414 }
1415