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 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * SMBIOS Information Routines 29 * 30 * The routines in this file are used to convert from the SMBIOS data format to 31 * a more reasonable and stable set of structures offered as part of our ABI. 32 * These functions take the general form: 33 * 34 * stp = smb_lookup_type(shp, foo); 35 * smb_foo_t foo; 36 * 37 * smb_info_bcopy(stp->smbst_hdr, &foo, sizeof (foo)); 38 * bzero(caller's struct); 39 * 40 * copy/convert foo members into caller's struct 41 * 42 * We copy the internal structure on to an automatic variable so as to avoid 43 * checks everywhere for structures that the BIOS has improperly truncated, and 44 * also to automatically handle the case of a structure that has been extended. 45 * When necessary, this code can use smb_gteq() to determine whether the SMBIOS 46 * data is of a particular revision that is supposed to contain a new field. 47 */ 48 49 #include <sys/smbios_impl.h> 50 51 #ifdef _KERNEL 52 #include <sys/sunddi.h> 53 #else 54 #include <fcntl.h> 55 #include <unistd.h> 56 #include <string.h> 57 #endif 58 59 /* 60 * A large number of SMBIOS structures contain a set of common strings used to 61 * describe a h/w component's serial number, manufacturer, etc. These fields 62 * helpfully have different names and offsets and sometimes aren't consistent. 63 * To simplify life for our clients, we factor these common things out into 64 * smbios_info_t, which can be retrieved for any structure. The following 65 * table describes the mapping from a given structure to the smbios_info_t. 66 * Multiple SMBIOS stuctures' contained objects are also handled here. 67 */ 68 static const struct smb_infospec { 69 uint8_t is_type; /* structure type */ 70 uint8_t is_manu; /* manufacturer offset */ 71 uint8_t is_product; /* product name offset */ 72 uint8_t is_version; /* version offset */ 73 uint8_t is_serial; /* serial number offset */ 74 uint8_t is_asset; /* asset tag offset */ 75 uint8_t is_location; /* location string offset */ 76 uint8_t is_part; /* part number offset */ 77 uint8_t is_contc; /* contained count */ 78 uint8_t is_contsz; /* contained size */ 79 uint8_t is_contv; /* contained objects */ 80 } _smb_infospecs[] = { 81 { SMB_TYPE_SYSTEM, 82 offsetof(smb_system_t, smbsi_manufacturer), 83 offsetof(smb_system_t, smbsi_product), 84 offsetof(smb_system_t, smbsi_version), 85 offsetof(smb_system_t, smbsi_serial), 86 0, 87 0, 88 0, 89 0, 90 0, 91 0 }, 92 { SMB_TYPE_BASEBOARD, 93 offsetof(smb_bboard_t, smbbb_manufacturer), 94 offsetof(smb_bboard_t, smbbb_product), 95 offsetof(smb_bboard_t, smbbb_version), 96 offsetof(smb_bboard_t, smbbb_serial), 97 offsetof(smb_bboard_t, smbbb_asset), 98 offsetof(smb_bboard_t, smbbb_location), 99 0, 100 offsetof(smb_bboard_t, smbbb_cn), 101 SMB_CONT_WORD, 102 offsetof(smb_bboard_t, smbbb_cv) }, 103 { SMB_TYPE_CHASSIS, 104 offsetof(smb_chassis_t, smbch_manufacturer), 105 0, 106 offsetof(smb_chassis_t, smbch_version), 107 offsetof(smb_chassis_t, smbch_serial), 108 offsetof(smb_chassis_t, smbch_asset), 109 0, 110 0, 111 offsetof(smb_chassis_t, smbch_cn), 112 SMB_CONT_BYTE, 113 offsetof(smb_chassis_t, smbch_cv) }, 114 { SMB_TYPE_PROCESSOR, 115 offsetof(smb_processor_t, smbpr_manufacturer), 116 0, 117 offsetof(smb_processor_t, smbpr_version), 118 offsetof(smb_processor_t, smbpr_serial), 119 offsetof(smb_processor_t, smbpr_asset), 120 offsetof(smb_processor_t, smbpr_socket), 121 offsetof(smb_processor_t, smbpr_part), 122 0, 123 0, 124 0 }, 125 { SMB_TYPE_CACHE, 126 0, 127 0, 128 0, 129 0, 130 0, 131 offsetof(smb_cache_t, smbca_socket), 132 0, 133 0, 134 0, 135 0 }, 136 { SMB_TYPE_PORT, 137 0, 138 0, 139 0, 140 0, 141 0, 142 offsetof(smb_port_t, smbpo_iref), 143 0, 144 0, 145 0, 146 0 }, 147 { SMB_TYPE_SLOT, 148 0, 149 0, 150 0, 151 0, 152 0, 153 offsetof(smb_slot_t, smbsl_name), 154 0, 155 0, 156 0, 157 0 }, 158 { SMB_TYPE_MEMDEVICE, 159 offsetof(smb_memdevice_t, smbmdev_manufacturer), 160 0, 161 0, 162 offsetof(smb_memdevice_t, smbmdev_serial), 163 offsetof(smb_memdevice_t, smbmdev_asset), 164 offsetof(smb_memdevice_t, smbmdev_dloc), 165 offsetof(smb_memdevice_t, smbmdev_part), 166 0, 167 0, 168 0 }, 169 { SMB_TYPE_POWERSUP, 170 offsetof(smb_powersup_t, smbpsup_manufacturer), 171 offsetof(smb_powersup_t, smbpsup_devname), 172 offsetof(smb_powersup_t, smbpsup_rev), 173 offsetof(smb_powersup_t, smbpsup_serial), 174 offsetof(smb_powersup_t, smbpsup_asset), 175 offsetof(smb_powersup_t, smbpsup_loc), 176 offsetof(smb_powersup_t, smbpsup_part), 177 0, 178 0, 179 0 }, 180 { SMB_TYPE_EOT } 181 }; 182 183 static const char * 184 smb_info_strptr(const smb_struct_t *stp, uint8_t off, int *n) 185 { 186 const uint8_t *sp = (const uint8_t *)(uintptr_t)stp->smbst_hdr; 187 188 if (off != 0 && sp + off < stp->smbst_end) { 189 (*n)++; /* indicate success for caller */ 190 return (smb_strptr(stp, sp[off])); 191 } 192 193 return (smb_strptr(stp, 0)); 194 } 195 196 static void 197 smb_info_bcopy(const smb_header_t *hp, void *dst, size_t dstlen) 198 { 199 if (dstlen > hp->smbh_len) { 200 bcopy(hp, dst, hp->smbh_len); 201 bzero((char *)dst + hp->smbh_len, dstlen - hp->smbh_len); 202 } else 203 bcopy(hp, dst, dstlen); 204 } 205 206 void 207 smbios_info_smbios(smbios_hdl_t *shp, smbios_entry_t *ep) 208 { 209 bcopy(&shp->sh_ent, ep, sizeof (smbios_entry_t)); 210 } 211 212 #ifndef _KERNEL 213 static char smbios_product_override[256]; 214 static boolean_t smbios_product_checked; 215 #endif 216 217 int 218 smbios_info_common(smbios_hdl_t *shp, id_t id, smbios_info_t *ip) 219 { 220 const smb_struct_t *stp = smb_lookup_id(shp, id); 221 const struct smb_infospec *isp; 222 int n = 0; 223 224 if (stp == NULL) 225 return (-1); /* errno is set for us */ 226 227 for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) { 228 if (isp->is_type == stp->smbst_hdr->smbh_type) 229 break; 230 } 231 232 ip->smbi_manufacturer = smb_info_strptr(stp, isp->is_manu, &n); 233 ip->smbi_product = smb_info_strptr(stp, isp->is_product, &n); 234 ip->smbi_version = smb_info_strptr(stp, isp->is_version, &n); 235 ip->smbi_serial = smb_info_strptr(stp, isp->is_serial, &n); 236 ip->smbi_asset = smb_info_strptr(stp, isp->is_asset, &n); 237 ip->smbi_location = smb_info_strptr(stp, isp->is_location, &n); 238 ip->smbi_part = smb_info_strptr(stp, isp->is_part, &n); 239 240 /* 241 * This private file allows developers to experiment with reporting 242 * different platform strings from SMBIOS. It is not a supported 243 * mechanism in the long term, and does not work in the kernel. 244 */ 245 #ifndef _KERNEL 246 if (isp->is_type == SMB_TYPE_SYSTEM) { 247 if (!smbios_product_checked) { 248 int fd = open("/etc/smbios_product", O_RDONLY); 249 if (fd >= 0) { 250 (void) read(fd, smbios_product_override, 251 sizeof (smbios_product_override) - 1); 252 (void) close(fd); 253 } 254 smbios_product_checked = B_TRUE; 255 } 256 257 if (smbios_product_override[0] != '\0') 258 ip->smbi_product = smbios_product_override; 259 } 260 #endif 261 262 /* 263 * If we have a port with an empty internal reference designator string 264 * try using the external reference designator string instead. 265 */ 266 if (isp->is_type == SMB_TYPE_PORT && ip->smbi_location[0] == '\0') { 267 ip->smbi_location = smb_info_strptr(stp, 268 offsetof(smb_port_t, smbpo_eref), &n); 269 } 270 271 return (n ? 0 : smb_set_errno(shp, ESMB_NOINFO)); 272 } 273 274 /* 275 * Returns the actual number of contained objects. 276 * 277 * idc - number of contained objects 278 * idv - returned array of contained objects 279 */ 280 int 281 smbios_info_contains(smbios_hdl_t *shp, id_t id, uint_t idc, id_t *idv) 282 { 283 const smb_struct_t *stp = smb_lookup_id(shp, id); 284 const struct smb_infospec *isp; 285 id_t *cp; 286 uint_t size; 287 uint8_t cnt; 288 int i, n; 289 290 if (stp == NULL) { 291 return (-1); /* errno is set for us */ 292 } 293 294 for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) { 295 if (isp->is_type == stp->smbst_hdr->smbh_type) 296 break; 297 } 298 if (isp->is_type == SMB_TYPE_EOT) 299 return (smb_set_errno(shp, ESMB_TYPE)); 300 301 size = isp->is_contsz; 302 cnt = *((uint8_t *)(uintptr_t)stp->smbst_hdr + isp->is_contc); 303 cp = (id_t *)((uintptr_t)stp->smbst_hdr + isp->is_contv); 304 305 n = MIN(cnt, idc); 306 for (i = 0; i < n; i++) { 307 if (size == SMB_CONT_WORD) 308 idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 2)); 309 else if (size == SMB_CONT_BYTE) 310 idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 3)); 311 else 312 return (smb_set_errno(shp, ESMB_INVAL)); 313 } 314 315 return (cnt); 316 } 317 318 id_t 319 smbios_info_bios(smbios_hdl_t *shp, smbios_bios_t *bp) 320 { 321 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BIOS); 322 const smb_bios_t *bip; 323 324 if (stp == NULL) 325 return (-1); /* errno is set for us */ 326 327 if (stp->smbst_hdr->smbh_len < sizeof (smb_bios_t) - sizeof (uint8_t)) 328 return (smb_set_errno(shp, ESMB_CORRUPT)); 329 330 bip = (smb_bios_t *)(uintptr_t)stp->smbst_hdr; 331 bzero(bp, sizeof (smbios_bios_t)); 332 333 bp->smbb_vendor = smb_strptr(stp, bip->smbbi_vendor); 334 bp->smbb_version = smb_strptr(stp, bip->smbbi_version); 335 bp->smbb_segment = bip->smbbi_segment; 336 bp->smbb_reldate = smb_strptr(stp, bip->smbbi_reldate); 337 bp->smbb_romsize = 64 * 1024 * ((uint32_t)bip->smbbi_romsize + 1); 338 bp->smbb_runsize = 16 * (0x10000 - (uint32_t)bip->smbbi_segment); 339 bp->smbb_cflags = bip->smbbi_cflags; 340 341 /* 342 * If one or more extension bytes are present, reset smbb_xcflags to 343 * point to them. Otherwise leave this member set to NULL. 344 */ 345 if (stp->smbst_hdr->smbh_len >= sizeof (smb_bios_t)) { 346 bp->smbb_xcflags = bip->smbbi_xcflags; 347 bp->smbb_nxcflags = stp->smbst_hdr->smbh_len - 348 sizeof (smb_bios_t) + 1; 349 350 if (bp->smbb_nxcflags > SMB_BIOSXB_ECFW_MIN && 351 smb_gteq(shp, SMB_VERSION_24)) { 352 bp->smbb_biosv.smbv_major = 353 bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MAJ]; 354 bp->smbb_biosv.smbv_minor = 355 bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MIN]; 356 bp->smbb_ecfwv.smbv_major = 357 bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MAJ]; 358 bp->smbb_ecfwv.smbv_minor = 359 bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MIN]; 360 } 361 } 362 363 return (stp->smbst_hdr->smbh_hdl); 364 } 365 366 id_t 367 smbios_info_system(smbios_hdl_t *shp, smbios_system_t *sip) 368 { 369 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM); 370 smb_system_t si; 371 372 if (stp == NULL) 373 return (-1); /* errno is set for us */ 374 375 smb_info_bcopy(stp->smbst_hdr, &si, sizeof (si)); 376 bzero(sip, sizeof (smbios_system_t)); 377 378 sip->smbs_uuid = ((smb_system_t *)stp->smbst_hdr)->smbsi_uuid; 379 sip->smbs_uuidlen = sizeof (si.smbsi_uuid); 380 sip->smbs_wakeup = si.smbsi_wakeup; 381 sip->smbs_sku = smb_strptr(stp, si.smbsi_sku); 382 sip->smbs_family = smb_strptr(stp, si.smbsi_family); 383 384 return (stp->smbst_hdr->smbh_hdl); 385 } 386 387 int 388 smbios_info_bboard(smbios_hdl_t *shp, id_t id, smbios_bboard_t *bbp) 389 { 390 const smb_struct_t *stp = smb_lookup_id(shp, id); 391 smb_bboard_t bb; 392 393 if (stp == NULL) 394 return (-1); /* errno is set for us */ 395 396 if (stp->smbst_hdr->smbh_type != SMB_TYPE_BASEBOARD) 397 return (smb_set_errno(shp, ESMB_TYPE)); 398 399 smb_info_bcopy(stp->smbst_hdr, &bb, sizeof (bb)); 400 bzero(bbp, sizeof (smbios_bboard_t)); 401 402 bbp->smbb_chassis = bb.smbbb_chassis; 403 bbp->smbb_flags = bb.smbbb_flags; 404 bbp->smbb_type = bb.smbbb_type; 405 bbp->smbb_contn = bb.smbbb_cn; 406 407 return (0); 408 } 409 410 int 411 smbios_info_chassis(smbios_hdl_t *shp, id_t id, smbios_chassis_t *chp) 412 { 413 const smb_struct_t *stp = smb_lookup_id(shp, id); 414 smb_chassis_t ch; 415 416 if (stp == NULL) 417 return (-1); /* errno is set for us */ 418 419 if (stp->smbst_hdr->smbh_type != SMB_TYPE_CHASSIS) 420 return (smb_set_errno(shp, ESMB_TYPE)); 421 422 smb_info_bcopy(stp->smbst_hdr, &ch, sizeof (ch)); 423 bzero(chp, sizeof (smbios_chassis_t)); 424 425 chp->smbc_oemdata = ch.smbch_oemdata; 426 chp->smbc_lock = (ch.smbch_type & SMB_CHT_LOCK) != 0; 427 chp->smbc_type = ch.smbch_type & ~SMB_CHT_LOCK; 428 chp->smbc_bustate = ch.smbch_bustate; 429 chp->smbc_psstate = ch.smbch_psstate; 430 chp->smbc_thstate = ch.smbch_thstate; 431 chp->smbc_security = ch.smbch_security; 432 chp->smbc_uheight = ch.smbch_uheight; 433 chp->smbc_cords = ch.smbch_cords; 434 chp->smbc_elems = ch.smbch_cn; 435 chp->smbc_elemlen = ch.smbch_cm; 436 437 return (0); 438 } 439 440 int 441 smbios_info_processor(smbios_hdl_t *shp, id_t id, smbios_processor_t *pp) 442 { 443 const smb_struct_t *stp = smb_lookup_id(shp, id); 444 smb_processor_t p; 445 446 if (stp == NULL) 447 return (-1); /* errno is set for us */ 448 449 if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR) 450 return (smb_set_errno(shp, ESMB_TYPE)); 451 452 smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p)); 453 bzero(pp, sizeof (smbios_processor_t)); 454 455 pp->smbp_cpuid = p.smbpr_cpuid; 456 pp->smbp_type = p.smbpr_type; 457 pp->smbp_family = p.smbpr_family; 458 pp->smbp_voltage = p.smbpr_voltage; 459 pp->smbp_maxspeed = p.smbpr_maxspeed; 460 pp->smbp_curspeed = p.smbpr_curspeed; 461 pp->smbp_status = p.smbpr_status; 462 pp->smbp_upgrade = p.smbpr_upgrade; 463 pp->smbp_l1cache = p.smbpr_l1cache; 464 pp->smbp_l2cache = p.smbpr_l2cache; 465 pp->smbp_l3cache = p.smbpr_l3cache; 466 467 return (0); 468 } 469 470 int 471 smbios_info_cache(smbios_hdl_t *shp, id_t id, smbios_cache_t *cap) 472 { 473 const smb_struct_t *stp = smb_lookup_id(shp, id); 474 smb_cache_t c; 475 476 if (stp == NULL) 477 return (-1); /* errno is set for us */ 478 479 if (stp->smbst_hdr->smbh_type != SMB_TYPE_CACHE) 480 return (smb_set_errno(shp, ESMB_TYPE)); 481 482 smb_info_bcopy(stp->smbst_hdr, &c, sizeof (c)); 483 bzero(cap, sizeof (smbios_cache_t)); 484 485 cap->smba_maxsize = SMB_CACHE_SIZE(c.smbca_maxsize); 486 cap->smba_size = SMB_CACHE_SIZE(c.smbca_size); 487 cap->smba_stype = c.smbca_stype; 488 cap->smba_ctype = c.smbca_ctype; 489 cap->smba_speed = c.smbca_speed; 490 cap->smba_etype = c.smbca_etype; 491 cap->smba_ltype = c.smbca_ltype; 492 cap->smba_assoc = c.smbca_assoc; 493 cap->smba_level = SMB_CACHE_CFG_LEVEL(c.smbca_config); 494 cap->smba_mode = SMB_CACHE_CFG_MODE(c.smbca_config); 495 cap->smba_location = SMB_CACHE_CFG_LOCATION(c.smbca_config); 496 497 if (SMB_CACHE_CFG_ENABLED(c.smbca_config)) 498 cap->smba_flags |= SMB_CAF_ENABLED; 499 500 if (SMB_CACHE_CFG_SOCKETED(c.smbca_config)) 501 cap->smba_flags |= SMB_CAF_SOCKETED; 502 503 return (0); 504 } 505 506 int 507 smbios_info_port(smbios_hdl_t *shp, id_t id, smbios_port_t *pop) 508 { 509 const smb_struct_t *stp = smb_lookup_id(shp, id); 510 smb_port_t p; 511 512 if (stp == NULL) 513 return (-1); /* errno is set for us */ 514 515 if (stp->smbst_hdr->smbh_type != SMB_TYPE_PORT) 516 return (smb_set_errno(shp, ESMB_TYPE)); 517 518 smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p)); 519 bzero(pop, sizeof (smbios_port_t)); 520 521 pop->smbo_iref = smb_strptr(stp, p.smbpo_iref); 522 pop->smbo_eref = smb_strptr(stp, p.smbpo_eref); 523 524 pop->smbo_itype = p.smbpo_itype; 525 pop->smbo_etype = p.smbpo_etype; 526 pop->smbo_ptype = p.smbpo_ptype; 527 528 return (0); 529 } 530 531 int 532 smbios_info_slot(smbios_hdl_t *shp, id_t id, smbios_slot_t *sp) 533 { 534 const smb_struct_t *stp = smb_lookup_id(shp, id); 535 smb_slot_t s; 536 537 if (stp == NULL) 538 return (-1); /* errno is set for us */ 539 540 if (stp->smbst_hdr->smbh_type != SMB_TYPE_SLOT) 541 return (smb_set_errno(shp, ESMB_TYPE)); 542 543 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 544 bzero(sp, sizeof (smbios_slot_t)); 545 546 sp->smbl_name = smb_strptr(stp, s.smbsl_name); 547 sp->smbl_type = s.smbsl_type; 548 sp->smbl_width = s.smbsl_width; 549 sp->smbl_usage = s.smbsl_usage; 550 sp->smbl_length = s.smbsl_length; 551 sp->smbl_id = s.smbsl_id; 552 sp->smbl_ch1 = s.smbsl_ch1; 553 sp->smbl_ch2 = s.smbsl_ch2; 554 sp->smbl_sg = s.smbsl_sg; 555 sp->smbl_bus = s.smbsl_bus; 556 sp->smbl_df = s.smbsl_df; 557 558 return (0); 559 } 560 561 int 562 smbios_info_obdevs_ext(smbios_hdl_t *shp, id_t id, smbios_obdev_ext_t *oep) 563 { 564 const smb_struct_t *stp = smb_lookup_id(shp, id); 565 smb_obdev_ext_t obe; 566 567 if (stp == NULL) 568 return (-1); /* errno is set for us */ 569 570 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVEXT) 571 return (smb_set_errno(shp, ESMB_TYPE)); 572 573 smb_info_bcopy(stp->smbst_hdr, &obe, sizeof (obe)); 574 bzero(oep, sizeof (smbios_obdev_ext_t)); 575 576 oep->smboe_name = smb_strptr(stp, obe.smbobe_name); 577 oep->smboe_dtype = obe.smbobe_dtype; 578 oep->smboe_dti = obe.smbobe_dti; 579 oep->smboe_sg = obe.smbobe_sg; 580 oep->smboe_bus = obe.smbobe_bus; 581 oep->smboe_df = obe.smbobe_df; 582 583 return (0); 584 } 585 586 int 587 smbios_info_obdevs(smbios_hdl_t *shp, id_t id, int obc, smbios_obdev_t *obp) 588 { 589 const smb_struct_t *stp = smb_lookup_id(shp, id); 590 const smb_obdev_t *op; 591 int i, m, n; 592 593 if (stp == NULL) 594 return (-1); /* errno is set for us */ 595 596 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVS) 597 return (smb_set_errno(shp, ESMB_TYPE)); 598 599 op = (smb_obdev_t *)((uintptr_t)stp->smbst_hdr + sizeof (smb_header_t)); 600 m = (stp->smbst_hdr->smbh_len - sizeof (smb_header_t)) / sizeof (*op); 601 n = MIN(m, obc); 602 603 for (i = 0; i < n; i++, op++, obp++) { 604 obp->smbd_name = smb_strptr(stp, op->smbob_name); 605 obp->smbd_type = op->smbob_type & ~SMB_OBT_ENABLED; 606 obp->smbd_enabled = (op->smbob_type & SMB_OBT_ENABLED) != 0; 607 } 608 609 return (m); 610 } 611 612 /* 613 * The implementation structures for OEMSTR, SYSCONFSTR, and LANG all use the 614 * first byte to indicate the size of a string table at the end of the record. 615 * Therefore, smbios_info_strtab() can be used to retrieve the table size and 616 * strings for any of these underlying record types. 617 */ 618 int 619 smbios_info_strtab(smbios_hdl_t *shp, id_t id, int argc, const char *argv[]) 620 { 621 const smb_struct_t *stp = smb_lookup_id(shp, id); 622 smb_strtab_t s; 623 int i, n; 624 625 if (stp == NULL) 626 return (-1); /* errno is set for us */ 627 628 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR && 629 stp->smbst_hdr->smbh_type != SMB_TYPE_SYSCONFSTR && 630 stp->smbst_hdr->smbh_type != SMB_TYPE_LANG) 631 return (smb_set_errno(shp, ESMB_TYPE)); 632 633 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 634 n = MIN(s.smbtb_count, argc); 635 636 for (i = 0; i < n; i++) 637 argv[i] = smb_strptr(stp, i + 1); 638 639 return (s.smbtb_count); 640 } 641 642 id_t 643 smbios_info_lang(smbios_hdl_t *shp, smbios_lang_t *lp) 644 { 645 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_LANG); 646 smb_lang_t l; 647 648 if (stp == NULL) 649 return (-1); /* errno is set for us */ 650 651 smb_info_bcopy(stp->smbst_hdr, &l, sizeof (l)); 652 bzero(lp, sizeof (smbios_lang_t)); 653 654 lp->smbla_cur = smb_strptr(stp, l.smblang_cur); 655 lp->smbla_fmt = l.smblang_flags & 1; 656 lp->smbla_num = l.smblang_num; 657 658 return (stp->smbst_hdr->smbh_hdl); 659 } 660 661 id_t 662 smbios_info_eventlog(smbios_hdl_t *shp, smbios_evlog_t *evp) 663 { 664 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_EVENTLOG); 665 const smb_sel_t *sel; 666 size_t len; 667 668 if (stp == NULL) 669 return (-1); /* errno is set for us */ 670 671 if (stp->smbst_hdr->smbh_len < sizeof (smb_sel_t) - sizeof (uint8_t)) 672 return (smb_set_errno(shp, ESMB_CORRUPT)); 673 674 sel = (smb_sel_t *)(uintptr_t)stp->smbst_hdr; 675 len = stp->smbst_hdr->smbh_len - sizeof (smb_sel_t) + sizeof (uint8_t); 676 bzero(evp, sizeof (smbios_evlog_t)); 677 678 if (len < sel->smbsel_typec * sel->smbsel_typesz) 679 return (smb_set_errno(shp, ESMB_CORRUPT)); 680 681 evp->smbev_size = sel->smbsel_len; 682 evp->smbev_hdr = sel->smbsel_hdroff; 683 evp->smbev_data = sel->smbsel_dataoff; 684 evp->smbev_method = sel->smbsel_method; 685 evp->smbev_flags = sel->smbsel_status; 686 evp->smbev_format = sel->smbsel_format; 687 evp->smbev_token = sel->smbsel_token; 688 evp->smbev_addr.eva_addr = sel->smbsel_addr; 689 690 if (sel->smbsel_typesz == sizeof (smbios_evtype_t)) { 691 evp->smbev_typec = sel->smbsel_typec; 692 evp->smbev_typev = (void *)(uintptr_t)sel->smbsel_typev; 693 } 694 695 return (stp->smbst_hdr->smbh_hdl); 696 } 697 698 int 699 smbios_info_memarray(smbios_hdl_t *shp, id_t id, smbios_memarray_t *map) 700 { 701 const smb_struct_t *stp = smb_lookup_id(shp, id); 702 smb_memarray_t m; 703 704 if (stp == NULL) 705 return (-1); /* errno is set for us */ 706 707 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAY) 708 return (smb_set_errno(shp, ESMB_TYPE)); 709 710 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 711 bzero(map, sizeof (smbios_memarray_t)); 712 713 map->smbma_location = m.smbmarr_loc; 714 map->smbma_use = m.smbmarr_use; 715 map->smbma_ecc = m.smbmarr_ecc; 716 map->smbma_ndevs = m.smbmarr_ndevs; 717 map->smbma_err = m.smbmarr_err; 718 719 if (m.smbmarr_cap != 0x80000000) 720 map->smbma_size = (uint64_t)m.smbmarr_cap * 1024; 721 else 722 map->smbma_size = 0; /* unknown */ 723 724 return (0); 725 } 726 727 int 728 smbios_info_memarrmap(smbios_hdl_t *shp, id_t id, smbios_memarrmap_t *map) 729 { 730 const smb_struct_t *stp = smb_lookup_id(shp, id); 731 smb_memarrmap_t m; 732 733 if (stp == NULL) 734 return (-1); /* errno is set for us */ 735 736 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAYMAP) 737 return (smb_set_errno(shp, ESMB_TYPE)); 738 739 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 740 bzero(map, sizeof (smbios_memarrmap_t)); 741 742 map->smbmam_array = m.smbamap_array; 743 map->smbmam_width = m.smbamap_width; 744 map->smbmam_addr = (uint64_t)m.smbamap_start * 1024; 745 map->smbmam_size = (uint64_t) 746 (m.smbamap_end - m.smbamap_start + 1) * 1024; 747 748 return (0); 749 } 750 751 int 752 smbios_info_memdevice(smbios_hdl_t *shp, id_t id, smbios_memdevice_t *mdp) 753 { 754 const smb_struct_t *stp = smb_lookup_id(shp, id); 755 smb_memdevice_t m; 756 757 if (stp == NULL) 758 return (-1); /* errno is set for us */ 759 760 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICE) 761 return (smb_set_errno(shp, ESMB_TYPE)); 762 763 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 764 bzero(mdp, sizeof (smbios_memdevice_t)); 765 766 mdp->smbmd_array = m.smbmdev_array; 767 mdp->smbmd_error = m.smbmdev_error; 768 mdp->smbmd_twidth = m.smbmdev_twidth == 0xFFFF ? -1U : m.smbmdev_twidth; 769 mdp->smbmd_dwidth = m.smbmdev_dwidth == 0xFFFF ? -1U : m.smbmdev_dwidth; 770 771 if (mdp->smbmd_size != 0xFFFF) { 772 mdp->smbmd_size = (uint64_t)(m.smbmdev_size & ~SMB_MDS_KBYTES); 773 if (m.smbmdev_size & SMB_MDS_KBYTES) 774 mdp->smbmd_size *= 1024; 775 else 776 mdp->smbmd_size *= 1024 * 1024; 777 } else 778 mdp->smbmd_size = -1ULL; /* size unknown */ 779 780 mdp->smbmd_form = m.smbmdev_form; 781 mdp->smbmd_set = m.smbmdev_set; 782 mdp->smbmd_type = m.smbmdev_type; 783 mdp->smbmd_flags = m.smbmdev_flags; 784 mdp->smbmd_dloc = smb_strptr(stp, m.smbmdev_dloc); 785 mdp->smbmd_bloc = smb_strptr(stp, m.smbmdev_bloc); 786 787 if (m.smbmdev_speed != 0) 788 mdp->smbmd_speed = 1000 / m.smbmdev_speed; /* MHz -> nsec */ 789 790 return (0); 791 } 792 793 int 794 smbios_info_memdevmap(smbios_hdl_t *shp, id_t id, smbios_memdevmap_t *mdp) 795 { 796 const smb_struct_t *stp = smb_lookup_id(shp, id); 797 smb_memdevmap_t m; 798 799 if (stp == NULL) 800 return (-1); /* errno is set for us */ 801 802 if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICEMAP) 803 return (smb_set_errno(shp, ESMB_TYPE)); 804 805 smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m)); 806 bzero(mdp, sizeof (smbios_memdevmap_t)); 807 808 mdp->smbmdm_device = m.smbdmap_device; 809 mdp->smbmdm_arrmap = m.smbdmap_array; 810 mdp->smbmdm_addr = (uint64_t)m.smbdmap_start * 1024; 811 mdp->smbmdm_size = (uint64_t) 812 (m.smbdmap_end - m.smbdmap_start + 1) * 1024; 813 mdp->smbmdm_rpos = m.smbdmap_rpos; 814 mdp->smbmdm_ipos = m.smbdmap_ipos; 815 mdp->smbmdm_idepth = m.smbdmap_idepth; 816 817 return (0); 818 } 819 820 id_t 821 smbios_info_hwsec(smbios_hdl_t *shp, smbios_hwsec_t *hsp) 822 { 823 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SECURITY); 824 smb_hwsec_t hs; 825 826 if (stp == NULL) 827 return (-1); /* errno is set for us */ 828 829 smb_info_bcopy(stp->smbst_hdr, &hs, sizeof (hs)); 830 bzero(hsp, sizeof (smbios_hwsec_t)); 831 832 hsp->smbh_pwr_ps = SMB_HWS_PWR_PS(hs.smbhs_settings); 833 hsp->smbh_kbd_ps = SMB_HWS_KBD_PS(hs.smbhs_settings); 834 hsp->smbh_adm_ps = SMB_HWS_ADM_PS(hs.smbhs_settings); 835 hsp->smbh_pan_ps = SMB_HWS_PAN_PS(hs.smbhs_settings); 836 837 return (stp->smbst_hdr->smbh_hdl); 838 } 839 840 id_t 841 smbios_info_boot(smbios_hdl_t *shp, smbios_boot_t *bp) 842 { 843 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BOOT); 844 const smb_boot_t *b = (smb_boot_t *)(uintptr_t)stp->smbst_hdr; 845 846 if (stp == NULL) 847 return (-1); /* errno is set for us */ 848 849 bzero(bp, sizeof (smbios_boot_t)); 850 851 bp->smbt_status = b->smbbo_status[0]; 852 bp->smbt_size = stp->smbst_hdr->smbh_len - sizeof (smb_boot_t); 853 bp->smbt_data = bp->smbt_size ? &b->smbbo_status[1] : NULL; 854 855 return (stp->smbst_hdr->smbh_hdl); 856 } 857 858 id_t 859 smbios_info_ipmi(smbios_hdl_t *shp, smbios_ipmi_t *ip) 860 { 861 const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_IPMIDEV); 862 smb_ipmi_t i; 863 864 if (stp == NULL) 865 return (-1); /* errno is set for us */ 866 867 smb_info_bcopy(stp->smbst_hdr, &i, sizeof (i)); 868 bzero(ip, sizeof (smbios_ipmi_t)); 869 870 ip->smbip_type = i.smbipm_type; 871 ip->smbip_vers.smbv_major = SMB_IPM_SPEC_MAJOR(i.smbipm_spec); 872 ip->smbip_vers.smbv_minor = SMB_IPM_SPEC_MINOR(i.smbipm_spec); 873 ip->smbip_i2c = i.smbipm_i2c; 874 ip->smbip_addr = i.smbipm_addr & ~SMB_IPM_ADDR_IO; 875 ip->smbip_intr = i.smbipm_intr; 876 877 if (i.smbipm_bus != (uint8_t)-1) 878 ip->smbip_bus = i.smbipm_bus; 879 else 880 ip->smbip_bus = -1u; 881 882 if (SMB_IPM_INFO_LSB(i.smbipm_info)) 883 ip->smbip_addr |= 1; /* turn on least-significant bit of addr */ 884 885 if (i.smbipm_addr & SMB_IPM_ADDR_IO) { 886 switch (SMB_IPM_INFO_REGS(i.smbipm_info)) { 887 case SMB_IPM_REGS_1B: 888 ip->smbip_regspacing = 1; 889 break; 890 case SMB_IPM_REGS_4B: 891 ip->smbip_regspacing = 4; 892 break; 893 case SMB_IPM_REGS_16B: 894 ip->smbip_regspacing = 16; 895 break; 896 default: 897 ip->smbip_regspacing = 1; 898 } 899 ip->smbip_flags |= SMB_IPMI_F_IOADDR; 900 } 901 902 if (SMB_IPM_INFO_ISPEC(i.smbipm_info)) 903 ip->smbip_flags |= SMB_IPMI_F_INTRSPEC; 904 905 if (SMB_IPM_INFO_IPOL(i.smbipm_info) == SMB_IPM_IPOL_HI) 906 ip->smbip_flags |= SMB_IPMI_F_INTRHIGH; 907 908 if (SMB_IPM_INFO_IMODE(i.smbipm_info) == SMB_IPM_IMODE_EDGE) 909 ip->smbip_flags |= SMB_IPMI_F_INTREDGE; 910 911 return (stp->smbst_hdr->smbh_hdl); 912 } 913 914 static boolean_t 915 smbios_has_oemstr(smbios_hdl_t *shp, const char *oemstr) 916 { 917 const smb_struct_t *stp = shp->sh_structs; 918 smb_strtab_t s; 919 int i, j; 920 921 for (i = 0; i < shp->sh_nstructs; i++, stp++) { 922 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR) 923 continue; 924 925 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s)); 926 for (j = 0; j < s.smbtb_count; j++) 927 if (strcmp(smb_strptr(stp, j + 1), oemstr) == 0) 928 return (B_TRUE); 929 } 930 931 return (B_FALSE); 932 } 933 934 static const char * 935 smb_serial_valid(const char *serial) 936 { 937 char buf[MAXNAMELEN]; 938 int i = 0; 939 940 if (serial == NULL) 941 return (NULL); 942 943 (void) strlcpy(buf, serial, sizeof (buf)); 944 945 while (buf[i] != '\0' && buf[i] == ' ') 946 i++; 947 948 if (buf[i] == '\0' || strstr(buf, SMB_DEFAULT1) != NULL || 949 strstr(buf, SMB_DEFAULT2) != NULL) 950 return (NULL); 951 952 return (serial); 953 } 954 955 /* 956 * Get chassis SN or product SN 957 */ 958 static int 959 smb_get_sn(smbios_hdl_t *shp, const char **psnp, const char **csnp) 960 { 961 const smb_struct_t *stp; 962 smbios_info_t s1, s3; 963 964 if (psnp == NULL || csnp == NULL) 965 return (smb_set_errno(shp, ESMB_INVAL)); 966 967 *psnp = *csnp = NULL; 968 969 /* 970 * If SMBIOS meets Sun's PRMS requirements, retrieve product SN 971 * from type 1 structure, and chassis SN from type 3 structure. 972 * Otherwise return SN in type 1 structure as chassis SN. 973 */ 974 975 /* Get type 1 SN */ 976 if ((stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM)) == NULL || 977 smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s1) == SMB_ERR) 978 s1.smbi_serial = NULL; 979 980 /* Get type 3 SN */ 981 if ((stp = smb_lookup_type(shp, SMB_TYPE_CHASSIS)) == NULL || 982 smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s3) == SMB_ERR) 983 s3.smbi_serial = NULL; 984 985 if (smbios_has_oemstr(shp, SMB_PRMS1)) { 986 *psnp = smb_serial_valid(s1.smbi_serial); 987 *csnp = smb_serial_valid(s3.smbi_serial); 988 } else { 989 *csnp = smb_serial_valid(s1.smbi_serial); 990 } 991 992 return (0); 993 } 994 995 const char * 996 smbios_psn(smbios_hdl_t *shp) 997 { 998 const char *psn, *csn; 999 1000 return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : psn); 1001 } 1002 1003 const char * 1004 smbios_csn(smbios_hdl_t *shp) 1005 { 1006 const char *psn, *csn; 1007 1008 return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : csn); 1009 } 1010 1011 int 1012 smbios_info_extprocessor(smbios_hdl_t *shp, id_t id, 1013 smbios_processor_ext_t *epp) 1014 { 1015 const smb_struct_t *stp = smb_lookup_id(shp, id); 1016 smb_processor_ext_t *exp; 1017 1018 if (stp == NULL) 1019 return (-1); /* errno is set for us */ 1020 1021 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PROCESSOR) 1022 return (smb_set_errno(shp, ESMB_TYPE)); 1023 1024 exp = (smb_processor_ext_t *)(uintptr_t)stp->smbst_hdr; 1025 bzero(epp, sizeof (smbios_processor_ext_t)); 1026 1027 epp->smbpe_processor = exp->smbpre_processor; 1028 epp->smbpe_fru = exp->smbpre_fru; 1029 epp->smbpe_n = exp->smbpre_n; 1030 epp->smbpe_apicid = exp->smbpre_apicid; 1031 1032 return (0); 1033 } 1034 1035 int 1036 smbios_info_extport(smbios_hdl_t *shp, id_t id, smbios_port_ext_t *eportp) 1037 { 1038 const smb_struct_t *stp = smb_lookup_id(shp, id); 1039 smb_port_ext_t *ep; 1040 1041 if (stp == NULL) 1042 return (-1); /* errno is set for us */ 1043 1044 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PORT) 1045 return (smb_set_errno(shp, ESMB_TYPE)); 1046 1047 ep = (smb_port_ext_t *)(uintptr_t)stp->smbst_hdr; 1048 bzero(eportp, sizeof (smbios_port_ext_t)); 1049 1050 eportp->smbporte_chassis = ep->smbpoe_chassis; 1051 eportp->smbporte_port = ep->smbpoe_port; 1052 eportp->smbporte_dtype = ep->smbpoe_dtype; 1053 eportp->smbporte_devhdl = ep->smbpoe_devhdl; 1054 eportp->smbporte_phy = ep->smbpoe_phy; 1055 1056 return (0); 1057 } 1058 1059 int 1060 smbios_info_pciexrc(smbios_hdl_t *shp, id_t id, 1061 smbios_pciexrc_t *rcp) 1062 { 1063 const smb_struct_t *stp = smb_lookup_id(shp, id); 1064 smb_pciexrc_t rc; 1065 1066 if (stp == NULL) 1067 return (-1); /* errno is set for us */ 1068 1069 if (stp->smbst_hdr->smbh_type != SUN_OEM_PCIEXRC) 1070 return (smb_set_errno(shp, ESMB_TYPE)); 1071 1072 smb_info_bcopy(stp->smbst_hdr, &rc, sizeof (rc)); 1073 bzero(rcp, sizeof (smbios_pciexrc_t)); 1074 1075 rcp->smbpcie_bb = rc.smbpciexrc_bboard; 1076 rcp->smbpcie_bdf = rc.smbpciexrc_bdf; 1077 1078 return (0); 1079 } 1080 1081 int 1082 smbios_info_extmemarray(smbios_hdl_t *shp, id_t id, smbios_memarray_ext_t *emap) 1083 { 1084 const smb_struct_t *stp = smb_lookup_id(shp, id); 1085 smb_memarray_ext_t exma; 1086 1087 if (stp == NULL) 1088 return (-1); /* errno is set for us */ 1089 1090 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMARRAY) 1091 return (smb_set_errno(shp, ESMB_TYPE)); 1092 1093 smb_info_bcopy(stp->smbst_hdr, &exma, sizeof (exma)); 1094 bzero(emap, sizeof (smbios_memarray_ext_t)); 1095 1096 emap->smbmae_ma = exma.smbmarre_ma; 1097 emap->smbmae_comp = exma.smbmarre_component; 1098 emap->smbmae_bdf = exma.smbmarre_bdf; 1099 1100 return (0); 1101 } 1102 1103 int 1104 smbios_info_extmemdevice(smbios_hdl_t *shp, id_t id, 1105 smbios_memdevice_ext_t *emdp) 1106 { 1107 const smb_struct_t *stp = smb_lookup_id(shp, id); 1108 smb_memdevice_ext_t exmd; 1109 1110 if (stp == NULL) 1111 return (-1); /* errno is set for us */ 1112 1113 if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMDEVICE) 1114 return (smb_set_errno(shp, ESMB_TYPE)); 1115 1116 smb_info_bcopy(stp->smbst_hdr, &exmd, sizeof (exmd)); 1117 bzero(emdp, sizeof (smbios_memdevice_ext_t)); 1118 1119 emdp->smbmdeve_md = exmd.smbmdeve_mdev; 1120 emdp->smbmdeve_drch = exmd.smbmdeve_dchan; 1121 emdp->smbmdeve_ncs = exmd.smbmdeve_ncs; 1122 emdp->smbmdeve_cs = exmd.smbmdeve_cs; 1123 1124 return (0); 1125 } 1126