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