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