1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2015 OmniTI Computer Consulting, Inc.  All rights reserved.
  24  * Copyright (c) 2017, Joyent, Inc.
  25  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  */
  28 
  29 /*
  30  * SMBIOS Information Routines
  31  *
  32  * The routines in this file are used to convert from the SMBIOS data format to
  33  * a more reasonable and stable set of structures offered as part of our ABI.
  34  * These functions take the general form:
  35  *
  36  *      stp = smb_lookup_type(shp, foo);
  37  *      smb_foo_t foo;
  38  *
  39  *      smb_info_bcopy(stp->smbst_hdr, &foo, sizeof (foo));
  40  *      bzero(caller's struct);
  41  *
  42  *      copy/convert foo members into caller's struct
  43  *
  44  * We copy the internal structure on to an automatic variable so as to avoid
  45  * checks everywhere for structures that the BIOS has improperly truncated, and
  46  * also to automatically handle the case of a structure that has been extended.
  47  * When necessary, this code can use smb_gteq() to determine whether the SMBIOS
  48  * data is of a particular revision that is supposed to contain a new field.
  49  *
  50  * Note, when trying to bzero the caller's struct you have to be careful about
  51  * versions. One can only bzero the initial version that existed in illumos. In
  52  * other words, if someone passes an older library handle that doesn't support a
  53  * version you cannot assume that their structures have those additional members
  54  * in them. Instead, a 'base' version is introduced for such types that have
  55  * differences and instead we only bzero out the base version and then handle
  56  * the additional members. In general, because all additional members will be
  57  * assigned, there's no reason to zero them out unless they are arrays that
  58  * won't be entirely filled in.
  59  *
  60  * Due to history, anything added after the update from version 2.4, in other
  61  * words additions from or after '5094 Update libsmbios with recent items'
  62  * (4e901881) is currently being used for this. While we don't allow software
  63  * compiling against this to get an older form, this was the first major update
  64  * and a good starting point for us to enforce this behavior which is useful for
  65  * moving forward to making this more public.
  66  */
  67 
  68 #include <sys/smbios_impl.h>
  69 #include <sys/byteorder.h>
  70 
  71 #ifdef _KERNEL
  72 #include <sys/sunddi.h>
  73 #else
  74 #include <fcntl.h>
  75 #include <unistd.h>
  76 #include <string.h>
  77 #endif
  78 
  79 /*
  80  * A large number of SMBIOS structures contain a set of common strings used to
  81  * describe a h/w component's serial number, manufacturer, etc.  These fields
  82  * helpfully have different names and offsets and sometimes aren't consistent.
  83  * To simplify life for our clients, we factor these common things out into
  84  * smbios_info_t, which can be retrieved for any structure.  The following
  85  * table describes the mapping from a given structure to the smbios_info_t.
  86  * Multiple SMBIOS stuctures' contained objects are also handled here.
  87  */
  88 static const struct smb_infospec {
  89         uint8_t is_type;                /* structure type */
  90         uint8_t is_manu;                /* manufacturer offset */
  91         uint8_t is_product;             /* product name offset */
  92         uint8_t is_version;             /* version offset */
  93         uint8_t is_serial;              /* serial number offset */
  94         uint8_t is_asset;               /* asset tag offset */
  95         uint8_t is_location;            /* location string offset */
  96         uint8_t is_part;                /* part number offset */
  97         uint8_t is_contc;               /* contained count */
  98         uint8_t is_contsz;              /* contained size */
  99         uint8_t is_contv;               /* contained objects */
 100 } _smb_infospecs[] = {
 101         { SMB_TYPE_SYSTEM,
 102                 offsetof(smb_system_t, smbsi_manufacturer),
 103                 offsetof(smb_system_t, smbsi_product),
 104                 offsetof(smb_system_t, smbsi_version),
 105                 offsetof(smb_system_t, smbsi_serial),
 106                 0,
 107                 0,
 108                 0,
 109                 0,
 110                 0,
 111                 0 },
 112         { SMB_TYPE_BASEBOARD,
 113                 offsetof(smb_bboard_t, smbbb_manufacturer),
 114                 offsetof(smb_bboard_t, smbbb_product),
 115                 offsetof(smb_bboard_t, smbbb_version),
 116                 offsetof(smb_bboard_t, smbbb_serial),
 117                 offsetof(smb_bboard_t, smbbb_asset),
 118                 offsetof(smb_bboard_t, smbbb_location),
 119                 0,
 120                 offsetof(smb_bboard_t, smbbb_cn),
 121                 SMB_CONT_WORD,
 122                 offsetof(smb_bboard_t, smbbb_cv) },
 123         { SMB_TYPE_CHASSIS,
 124                 offsetof(smb_chassis_t, smbch_manufacturer),
 125                 0,
 126                 offsetof(smb_chassis_t, smbch_version),
 127                 offsetof(smb_chassis_t, smbch_serial),
 128                 offsetof(smb_chassis_t, smbch_asset),
 129                 0,
 130                 0,
 131                 offsetof(smb_chassis_t, smbch_cn),
 132                 SMB_CONT_BYTE,
 133                 offsetof(smb_chassis_t, smbch_cv) },
 134         { SMB_TYPE_PROCESSOR,
 135                 offsetof(smb_processor_t, smbpr_manufacturer),
 136                 0,
 137                 offsetof(smb_processor_t, smbpr_version),
 138                 offsetof(smb_processor_t, smbpr_serial),
 139                 offsetof(smb_processor_t, smbpr_asset),
 140                 offsetof(smb_processor_t, smbpr_socket),
 141                 offsetof(smb_processor_t, smbpr_part),
 142                 0,
 143                 0,
 144                 0 },
 145         { SMB_TYPE_CACHE,
 146                 0,
 147                 0,
 148                 0,
 149                 0,
 150                 0,
 151                 offsetof(smb_cache_t, smbca_socket),
 152                 0,
 153                 0,
 154                 0,
 155                 0 },
 156         { SMB_TYPE_PORT,
 157                 0,
 158                 0,
 159                 0,
 160                 0,
 161                 0,
 162                 offsetof(smb_port_t, smbpo_iref),
 163                 0,
 164                 0,
 165                 0,
 166                 0 },
 167         { SMB_TYPE_SLOT,
 168                 0,
 169                 0,
 170                 0,
 171                 0,
 172                 0,
 173                 offsetof(smb_slot_t, smbsl_name),
 174                 0,
 175                 0,
 176                 0,
 177                 0 },
 178         { SMB_TYPE_MEMDEVICE,
 179                 offsetof(smb_memdevice_t, smbmdev_manufacturer),
 180                 0,
 181                 0,
 182                 offsetof(smb_memdevice_t, smbmdev_serial),
 183                 offsetof(smb_memdevice_t, smbmdev_asset),
 184                 offsetof(smb_memdevice_t, smbmdev_dloc),
 185                 offsetof(smb_memdevice_t, smbmdev_part),
 186                 0,
 187                 0,
 188                 0 },
 189         { SMB_TYPE_POWERSUP,
 190                 offsetof(smb_powersup_t, smbpsup_manufacturer),
 191                 offsetof(smb_powersup_t, smbpsup_devname),
 192                 offsetof(smb_powersup_t, smbpsup_rev),
 193                 offsetof(smb_powersup_t, smbpsup_serial),
 194                 offsetof(smb_powersup_t, smbpsup_asset),
 195                 offsetof(smb_powersup_t, smbpsup_loc),
 196                 offsetof(smb_powersup_t, smbpsup_part),
 197                 0,
 198                 0,
 199                 0 },
 200         { SMB_TYPE_EOT }
 201 };
 202 
 203 static const char *
 204 smb_info_strptr(const smb_struct_t *stp, uint8_t off, int *n)
 205 {
 206         const uint8_t *sp = (const uint8_t *)(uintptr_t)stp->smbst_hdr;
 207 
 208         if (off != 0 && sp + off < stp->smbst_end) {
 209                 (*n)++; /* indicate success for caller */
 210                 return (smb_strptr(stp, sp[off]));
 211         }
 212 
 213         return (smb_strptr(stp, 0));
 214 }
 215 
 216 static void
 217 smb_info_bcopy(const smb_header_t *hp, void *dst, size_t dstlen)
 218 {
 219         if (dstlen > hp->smbh_len) {
 220                 bcopy(hp, dst, hp->smbh_len);
 221                 bzero((char *)dst + hp->smbh_len, dstlen - hp->smbh_len);
 222         } else
 223                 bcopy(hp, dst, dstlen);
 224 }
 225 
 226 smbios_entry_point_t
 227 smbios_info_smbios(smbios_hdl_t *shp, smbios_entry_t *ep)
 228 {
 229         bcopy(&shp->sh_ent, ep, sizeof (smbios_entry_t));
 230         return (shp->sh_ent_type);
 231 }
 232 
 233 void
 234 smbios_info_smbios_version(smbios_hdl_t *shp, smbios_version_t *v)
 235 {
 236         v->smbv_major = SMB_MAJOR(shp->sh_smbvers);
 237         v->smbv_minor = SMB_MINOR(shp->sh_smbvers);
 238 }
 239 
 240 #ifndef _KERNEL
 241 static char smbios_product_override[256];
 242 static boolean_t smbios_product_checked;
 243 #endif
 244 
 245 int
 246 smbios_info_common(smbios_hdl_t *shp, id_t id, smbios_info_t *ip)
 247 {
 248         const smb_struct_t *stp = smb_lookup_id(shp, id);
 249         const struct smb_infospec *isp;
 250         int n = 0;
 251 
 252         if (stp == NULL)
 253                 return (-1); /* errno is set for us */
 254 
 255         for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) {
 256                 if (isp->is_type == stp->smbst_hdr->smbh_type)
 257                         break;
 258         }
 259 
 260         ip->smbi_manufacturer = smb_info_strptr(stp, isp->is_manu, &n);
 261         ip->smbi_product = smb_info_strptr(stp, isp->is_product, &n);
 262         ip->smbi_version = smb_info_strptr(stp, isp->is_version, &n);
 263         ip->smbi_serial = smb_info_strptr(stp, isp->is_serial, &n);
 264         ip->smbi_asset = smb_info_strptr(stp, isp->is_asset, &n);
 265         ip->smbi_location = smb_info_strptr(stp, isp->is_location, &n);
 266         ip->smbi_part = smb_info_strptr(stp, isp->is_part, &n);
 267 
 268         /*
 269          * This private file allows developers to experiment with reporting
 270          * different platform strings from SMBIOS.  It is not a supported
 271          * mechanism in the long term, and does not work in the kernel.
 272          */
 273 #ifndef _KERNEL
 274         if (isp->is_type == SMB_TYPE_SYSTEM) {
 275                 if (!smbios_product_checked) {
 276                         int fd = open("/etc/smbios_product", O_RDONLY);
 277                         if (fd >= 0) {
 278                                 (void) read(fd, smbios_product_override,
 279                                     sizeof (smbios_product_override) - 1);
 280                                 (void) close(fd);
 281                         }
 282                         smbios_product_checked = B_TRUE;
 283                 }
 284 
 285                 if (smbios_product_override[0] != '\0')
 286                         ip->smbi_product = smbios_product_override;
 287         }
 288 #endif
 289 
 290         /*
 291          * If we have a port with an empty internal reference designator string
 292          * try using the external reference designator string instead.
 293          */
 294         if (isp->is_type == SMB_TYPE_PORT && ip->smbi_location[0] == '\0') {
 295                 ip->smbi_location = smb_info_strptr(stp,
 296                     offsetof(smb_port_t, smbpo_eref), &n);
 297         }
 298 
 299         return (n ? 0 : smb_set_errno(shp, ESMB_NOINFO));
 300 }
 301 
 302 /*
 303  * Returns the actual number of contained objects.
 304  *
 305  * idc - number of contained objects
 306  * idv - returned array of contained objects
 307  */
 308 int
 309 smbios_info_contains(smbios_hdl_t *shp, id_t id, uint_t idc, id_t *idv)
 310 {
 311         const smb_struct_t *stp = smb_lookup_id(shp, id);
 312         const struct smb_infospec *isp;
 313         id_t *cp;
 314         uint_t size;
 315         uint8_t cnt;
 316         int i, n;
 317 
 318         if (stp == NULL) {
 319                 return (-1); /* errno is set for us */
 320         }
 321 
 322         for (isp = _smb_infospecs; isp->is_type != SMB_TYPE_EOT; isp++) {
 323                 if (isp->is_type == stp->smbst_hdr->smbh_type)
 324                         break;
 325         }
 326         if (isp->is_type == SMB_TYPE_EOT)
 327                 return (smb_set_errno(shp, ESMB_TYPE));
 328 
 329         size = isp->is_contsz;
 330         cnt = *((uint8_t *)(uintptr_t)stp->smbst_hdr + isp->is_contc);
 331         cp = (id_t *)((uintptr_t)stp->smbst_hdr + isp->is_contv);
 332 
 333         n = MIN(cnt, idc);
 334         for (i = 0; i < n; i++) {
 335                 if (size == SMB_CONT_WORD)
 336                         idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 2));
 337                 else if (size == SMB_CONT_BYTE)
 338                         idv[i] = *((uint8_t *)(uintptr_t)cp + (i * 3));
 339                 else
 340                         return (smb_set_errno(shp, ESMB_INVAL));
 341         }
 342 
 343         return (cnt);
 344 }
 345 
 346 id_t
 347 smbios_info_bios(smbios_hdl_t *shp, smbios_bios_t *bp)
 348 {
 349         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BIOS);
 350         const smb_bios_t *bip;
 351 
 352         if (stp == NULL)
 353                 return (-1); /* errno is set for us */
 354 
 355         if (stp->smbst_hdr->smbh_len < sizeof (smb_bios_t) - sizeof (uint8_t))
 356                 return (smb_set_errno(shp, ESMB_CORRUPT));
 357 
 358         bip = (smb_bios_t *)(uintptr_t)stp->smbst_hdr;
 359         bzero(bp, sizeof (smb_base_bios_t));
 360         if (smb_libgteq(shp, SMB_VERSION_31)) {
 361                 bp->smbb_extromsize = 0;
 362         }
 363 
 364         bp->smbb_vendor = smb_strptr(stp, bip->smbbi_vendor);
 365         bp->smbb_version = smb_strptr(stp, bip->smbbi_version);
 366         bp->smbb_segment = bip->smbbi_segment;
 367         bp->smbb_reldate = smb_strptr(stp, bip->smbbi_reldate);
 368         bp->smbb_romsize = 64 * 1024 * ((uint32_t)bip->smbbi_romsize + 1);
 369         bp->smbb_runsize = 16 * (0x10000 - (uint32_t)bip->smbbi_segment);
 370         bp->smbb_cflags = bip->smbbi_cflags;
 371 
 372         /*
 373          * If one or more extension bytes are present, reset smbb_xcflags to
 374          * point to them.  Otherwise leave this member set to NULL.
 375          */
 376         if (stp->smbst_hdr->smbh_len >= sizeof (smb_bios_t)) {
 377                 bp->smbb_xcflags = bip->smbbi_xcflags;
 378                 bp->smbb_nxcflags = stp->smbst_hdr->smbh_len -
 379                     sizeof (smb_bios_t) + 1;
 380 
 381                 if (bp->smbb_nxcflags > SMB_BIOSXB_ECFW_MIN &&
 382                     smb_gteq(shp, SMB_VERSION_24)) {
 383                         bp->smbb_biosv.smbv_major =
 384                             bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MAJ];
 385                         bp->smbb_biosv.smbv_minor =
 386                             bip->smbbi_xcflags[SMB_BIOSXB_BIOS_MIN];
 387                         bp->smbb_ecfwv.smbv_major =
 388                             bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MAJ];
 389                         bp->smbb_ecfwv.smbv_minor =
 390                             bip->smbbi_xcflags[SMB_BIOSXB_ECFW_MIN];
 391                 }
 392 
 393                 if (bp->smbb_nxcflags > SMB_BIOSXB_EXTROM + 1 &&
 394                     smb_gteq(shp, SMB_VERSION_31)) {
 395                         uint16_t val;
 396                         uint64_t rs;
 397 
 398                         /*
 399                          * Because of the fact that the extended size is a
 400                          * uint16_t and we'd need to define an explicit
 401                          * endian-aware way to access it, we don't include it in
 402                          * the number of extended flags below and thus subtract
 403                          * its size.
 404                          */
 405                         bp->smbb_nxcflags -= sizeof (uint16_t);
 406                         bcopy(&bip->smbbi_xcflags[SMB_BIOSXB_EXTROM], &val,
 407                             sizeof (val));
 408                         val = LE_16(val);
 409 
 410                         /*
 411                          * The upper two bits of the extended rom size are used
 412                          * to indicate whether the other 14 bits are in MB or
 413                          * GB.
 414                          */
 415                         rs = SMB_BIOS_EXTROM_VALUE_MASK(val);
 416                         switch (SMB_BIOS_EXTROM_SHIFT_MASK(val)) {
 417                         case 0:
 418                                 rs *= 1024ULL * 1024ULL;
 419                                 break;
 420                         case 1:
 421                                 rs *= 1024ULL * 1024ULL * 1024ULL;
 422                                 break;
 423                         default:
 424                                 rs = 0;
 425                                 break;
 426                         }
 427 
 428                         if (smb_libgteq(shp, SMB_VERSION_31)) {
 429                                 bp->smbb_extromsize = rs;
 430                         }
 431                 }
 432         }
 433 
 434         if (smb_libgteq(shp, SMB_VERSION_31) && bp->smbb_extromsize == 0) {
 435                 bp->smbb_extromsize = bp->smbb_romsize;
 436         }
 437 
 438         return (stp->smbst_hdr->smbh_hdl);
 439 }
 440 
 441 id_t
 442 smbios_info_system(smbios_hdl_t *shp, smbios_system_t *sip)
 443 {
 444         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM);
 445         smb_system_t si;
 446 
 447         if (stp == NULL)
 448                 return (-1); /* errno is set for us */
 449 
 450         smb_info_bcopy(stp->smbst_hdr, &si, sizeof (si));
 451         bzero(sip, sizeof (smbios_system_t));
 452 
 453         sip->smbs_uuid = ((smb_system_t *)stp->smbst_hdr)->smbsi_uuid;
 454         sip->smbs_uuidlen = sizeof (si.smbsi_uuid);
 455         sip->smbs_wakeup = si.smbsi_wakeup;
 456         sip->smbs_sku = smb_strptr(stp, si.smbsi_sku);
 457         sip->smbs_family = smb_strptr(stp, si.smbsi_family);
 458 
 459         return (stp->smbst_hdr->smbh_hdl);
 460 }
 461 
 462 int
 463 smbios_info_bboard(smbios_hdl_t *shp, id_t id, smbios_bboard_t *bbp)
 464 {
 465         const smb_struct_t *stp = smb_lookup_id(shp, id);
 466         smb_bboard_t bb;
 467 
 468         if (stp == NULL)
 469                 return (-1); /* errno is set for us */
 470 
 471         if (stp->smbst_hdr->smbh_type != SMB_TYPE_BASEBOARD)
 472                 return (smb_set_errno(shp, ESMB_TYPE));
 473 
 474         smb_info_bcopy(stp->smbst_hdr, &bb, sizeof (bb));
 475         bzero(bbp, sizeof (smbios_bboard_t));
 476 
 477         bbp->smbb_chassis = bb.smbbb_chassis;
 478         bbp->smbb_flags = bb.smbbb_flags;
 479         bbp->smbb_type = bb.smbbb_type;
 480         bbp->smbb_contn = bb.smbbb_cn;
 481 
 482         return (0);
 483 }
 484 
 485 int
 486 smbios_info_chassis(smbios_hdl_t *shp, id_t id, smbios_chassis_t *chp)
 487 {
 488         const smb_struct_t *stp = smb_lookup_id(shp, id);
 489         /* Length is measurable by one byte, so it'll be no more than 255. */
 490         uint8_t buf[256];
 491         smb_chassis_t *ch = (smb_chassis_t *)&buf[0];
 492 
 493         if (stp == NULL)
 494                 return (-1); /* errno is set for us */
 495 
 496         if (stp->smbst_hdr->smbh_type != SMB_TYPE_CHASSIS)
 497                 return (smb_set_errno(shp, ESMB_TYPE));
 498 
 499         smb_info_bcopy(stp->smbst_hdr, ch, sizeof (buf));
 500         bzero(chp, sizeof (smb_base_chassis_t));
 501         if (smb_libgteq(shp, SMB_VERSION_27)) {
 502                 bzero(chp->smbc_sku, sizeof (chp->smbc_sku));
 503         }
 504 
 505         chp->smbc_oemdata = ch->smbch_oemdata;
 506         chp->smbc_lock = (ch->smbch_type & SMB_CHT_LOCK) != 0;
 507         chp->smbc_type = ch->smbch_type & ~SMB_CHT_LOCK;
 508         chp->smbc_bustate = ch->smbch_bustate;
 509         chp->smbc_psstate = ch->smbch_psstate;
 510         chp->smbc_thstate = ch->smbch_thstate;
 511         chp->smbc_security = ch->smbch_security;
 512         chp->smbc_uheight = ch->smbch_uheight;
 513         chp->smbc_cords = ch->smbch_cords;
 514         chp->smbc_elems = ch->smbch_cn;
 515         chp->smbc_elemlen = ch->smbch_cm;
 516 
 517         if (smb_libgteq(shp, SMB_VERSION_27)) {
 518                 (void) strlcpy(chp->smbc_sku, SMB_CH_SKU(ch),
 519                     sizeof (chp->smbc_sku));
 520         }
 521 
 522         return (0);
 523 }
 524 
 525 int
 526 smbios_info_processor(smbios_hdl_t *shp, id_t id, smbios_processor_t *pp)
 527 {
 528         const smb_struct_t *stp = smb_lookup_id(shp, id);
 529         smb_processor_t p;
 530 
 531         if (stp == NULL)
 532                 return (-1); /* errno is set for us */
 533 
 534         if (stp->smbst_hdr->smbh_type != SMB_TYPE_PROCESSOR)
 535                 return (smb_set_errno(shp, ESMB_TYPE));
 536 
 537         smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p));
 538         bzero(pp, sizeof (smb_base_processor_t));
 539 
 540         pp->smbp_cpuid = p.smbpr_cpuid;
 541         pp->smbp_type = p.smbpr_type;
 542         pp->smbp_family = p.smbpr_family;
 543         pp->smbp_voltage = p.smbpr_voltage;
 544         pp->smbp_maxspeed = p.smbpr_maxspeed;
 545         pp->smbp_curspeed = p.smbpr_curspeed;
 546         pp->smbp_status = p.smbpr_status;
 547         pp->smbp_upgrade = p.smbpr_upgrade;
 548         pp->smbp_l1cache = p.smbpr_l1cache;
 549         pp->smbp_l2cache = p.smbpr_l2cache;
 550         pp->smbp_l3cache = p.smbpr_l3cache;
 551 
 552         if (smb_libgteq(shp, SMB_VERSION_25)) {
 553                 pp->smbp_corecount = p.smbpr_corecount;
 554                 pp->smbp_coresenabled = p.smbpr_coresenabled;
 555                 pp->smbp_threadcount = p.smbpr_threadcount;
 556                 pp->smbp_cflags = p.smbpr_cflags;
 557         }
 558 
 559         if (smb_libgteq(shp, SMB_VERSION_26)) {
 560                 pp->smbp_family2 = p.smbpr_family2;
 561         }
 562 
 563         if (smb_libgteq(shp, SMB_VERSION_30)) {
 564                 pp->smbp_corecount2 = p.smbpr_corecount2;
 565                 pp->smbp_coresenabled2 = p.smbpr_coresenabled2;
 566                 pp->smbp_threadcount2 = p.smbpr_threadcount2;
 567         }
 568 
 569         return (0);
 570 }
 571 
 572 int
 573 smbios_info_cache(smbios_hdl_t *shp, id_t id, smbios_cache_t *cap)
 574 {
 575         const smb_struct_t *stp = smb_lookup_id(shp, id);
 576         smb_cache_t c;
 577 
 578         if (stp == NULL)
 579                 return (-1); /* errno is set for us */
 580 
 581         if (stp->smbst_hdr->smbh_type != SMB_TYPE_CACHE)
 582                 return (smb_set_errno(shp, ESMB_TYPE));
 583 
 584         smb_info_bcopy(stp->smbst_hdr, &c, sizeof (c));
 585         bzero(cap, sizeof (smb_base_cache_t));
 586 
 587         cap->smba_maxsize = SMB_CACHE_SIZE(c.smbca_maxsize);
 588         cap->smba_size = SMB_CACHE_SIZE(c.smbca_size);
 589         cap->smba_stype = c.smbca_stype;
 590         cap->smba_ctype = c.smbca_ctype;
 591         cap->smba_speed = c.smbca_speed;
 592         cap->smba_etype = c.smbca_etype;
 593         cap->smba_ltype = c.smbca_ltype;
 594         cap->smba_assoc = c.smbca_assoc;
 595         cap->smba_level = SMB_CACHE_CFG_LEVEL(c.smbca_config);
 596         cap->smba_mode = SMB_CACHE_CFG_MODE(c.smbca_config);
 597         cap->smba_location = SMB_CACHE_CFG_LOCATION(c.smbca_config);
 598 
 599         if (SMB_CACHE_CFG_ENABLED(c.smbca_config))
 600                 cap->smba_flags |= SMB_CAF_ENABLED;
 601 
 602         if (SMB_CACHE_CFG_SOCKETED(c.smbca_config))
 603                 cap->smba_flags |= SMB_CAF_SOCKETED;
 604 
 605         if (smb_libgteq(shp, SMB_VERSION_31)) {
 606                 if (smb_gteq(shp, SMB_VERSION_31)) {
 607                         cap->smba_maxsize2 =
 608                             SMB_CACHE_EXT_SIZE(c.smbca_maxsize2);
 609                         cap->smba_size2 = SMB_CACHE_EXT_SIZE(c.smbca_size2);
 610                 } else {
 611                         cap->smba_maxsize2 = cap->smba_maxsize;
 612                         cap->smba_size2 = cap->smba_size;
 613                 }
 614         }
 615 
 616         return (0);
 617 }
 618 
 619 int
 620 smbios_info_port(smbios_hdl_t *shp, id_t id, smbios_port_t *pop)
 621 {
 622         const smb_struct_t *stp = smb_lookup_id(shp, id);
 623         smb_port_t p;
 624 
 625         if (stp == NULL)
 626                 return (-1); /* errno is set for us */
 627 
 628         if (stp->smbst_hdr->smbh_type != SMB_TYPE_PORT)
 629                 return (smb_set_errno(shp, ESMB_TYPE));
 630 
 631         smb_info_bcopy(stp->smbst_hdr, &p, sizeof (p));
 632         bzero(pop, sizeof (smbios_port_t));
 633 
 634         pop->smbo_iref = smb_strptr(stp, p.smbpo_iref);
 635         pop->smbo_eref = smb_strptr(stp, p.smbpo_eref);
 636 
 637         pop->smbo_itype = p.smbpo_itype;
 638         pop->smbo_etype = p.smbpo_etype;
 639         pop->smbo_ptype = p.smbpo_ptype;
 640 
 641         return (0);
 642 }
 643 
 644 int
 645 smbios_info_slot(smbios_hdl_t *shp, id_t id, smbios_slot_t *sp)
 646 {
 647         const smb_struct_t *stp = smb_lookup_id(shp, id);
 648         smb_slot_t s;
 649 
 650         if (stp == NULL)
 651                 return (-1); /* errno is set for us */
 652 
 653         if (stp->smbst_hdr->smbh_type != SMB_TYPE_SLOT)
 654                 return (smb_set_errno(shp, ESMB_TYPE));
 655 
 656         smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
 657         bzero(sp, sizeof (smbios_slot_t));
 658 
 659         sp->smbl_name = smb_strptr(stp, s.smbsl_name);
 660         sp->smbl_type = s.smbsl_type;
 661         sp->smbl_width = s.smbsl_width;
 662         sp->smbl_usage = s.smbsl_usage;
 663         sp->smbl_length = s.smbsl_length;
 664         sp->smbl_id = s.smbsl_id;
 665         sp->smbl_ch1 = s.smbsl_ch1;
 666         sp->smbl_ch2 = s.smbsl_ch2;
 667         sp->smbl_sg = s.smbsl_sg;
 668         sp->smbl_bus = s.smbsl_bus;
 669         sp->smbl_df = s.smbsl_df;
 670 
 671         return (0);
 672 }
 673 
 674 int
 675 smbios_info_obdevs_ext(smbios_hdl_t *shp, id_t id, smbios_obdev_ext_t *oep)
 676 {
 677         const smb_struct_t *stp = smb_lookup_id(shp, id);
 678         smb_obdev_ext_t obe;
 679 
 680         if (stp == NULL)
 681                 return (-1); /* errno is set for us */
 682 
 683         if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVEXT)
 684                 return (smb_set_errno(shp, ESMB_TYPE));
 685 
 686         smb_info_bcopy(stp->smbst_hdr, &obe, sizeof (obe));
 687         bzero(oep, sizeof (smbios_obdev_ext_t));
 688 
 689         oep->smboe_name = smb_strptr(stp, obe.smbobe_name);
 690         oep->smboe_dtype = obe.smbobe_dtype;
 691         oep->smboe_dti = obe.smbobe_dti;
 692         oep->smboe_sg = obe.smbobe_sg;
 693         oep->smboe_bus = obe.smbobe_bus;
 694         oep->smboe_df = obe.smbobe_df;
 695 
 696         return (0);
 697 }
 698 
 699 int
 700 smbios_info_obdevs(smbios_hdl_t *shp, id_t id, int obc, smbios_obdev_t *obp)
 701 {
 702         const smb_struct_t *stp = smb_lookup_id(shp, id);
 703         const smb_obdev_t *op;
 704         int i, m, n;
 705 
 706         if (stp == NULL)
 707                 return (-1); /* errno is set for us */
 708 
 709         if (stp->smbst_hdr->smbh_type != SMB_TYPE_OBDEVS)
 710                 return (smb_set_errno(shp, ESMB_TYPE));
 711 
 712         op = (smb_obdev_t *)((uintptr_t)stp->smbst_hdr + sizeof (smb_header_t));
 713         m = (stp->smbst_hdr->smbh_len - sizeof (smb_header_t)) / sizeof (*op);
 714         n = MIN(m, obc);
 715 
 716         for (i = 0; i < n; i++, op++, obp++) {
 717                 obp->smbd_name = smb_strptr(stp, op->smbob_name);
 718                 obp->smbd_type = op->smbob_type & ~SMB_OBT_ENABLED;
 719                 obp->smbd_enabled = (op->smbob_type & SMB_OBT_ENABLED) != 0;
 720         }
 721 
 722         return (m);
 723 }
 724 
 725 /*
 726  * The implementation structures for OEMSTR, SYSCONFSTR, and LANG all use the
 727  * first byte to indicate the size of a string table at the end of the record.
 728  * Therefore, smbios_info_strtab() can be used to retrieve the table size and
 729  * strings for any of these underlying record types.
 730  */
 731 int
 732 smbios_info_strtab(smbios_hdl_t *shp, id_t id, int argc, const char *argv[])
 733 {
 734         const smb_struct_t *stp = smb_lookup_id(shp, id);
 735         smb_strtab_t s;
 736         int i, n;
 737 
 738         if (stp == NULL)
 739                 return (-1); /* errno is set for us */
 740 
 741         if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR &&
 742             stp->smbst_hdr->smbh_type != SMB_TYPE_SYSCONFSTR &&
 743             stp->smbst_hdr->smbh_type != SMB_TYPE_LANG)
 744                 return (smb_set_errno(shp, ESMB_TYPE));
 745 
 746         smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
 747         n = MIN(s.smbtb_count, argc);
 748 
 749         for (i = 0; i < n; i++)
 750                 argv[i] = smb_strptr(stp, i + 1);
 751 
 752         return (s.smbtb_count);
 753 }
 754 
 755 id_t
 756 smbios_info_lang(smbios_hdl_t *shp, smbios_lang_t *lp)
 757 {
 758         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_LANG);
 759         smb_lang_t l;
 760 
 761         if (stp == NULL)
 762                 return (-1); /* errno is set for us */
 763 
 764         smb_info_bcopy(stp->smbst_hdr, &l, sizeof (l));
 765         bzero(lp, sizeof (smbios_lang_t));
 766 
 767         lp->smbla_cur = smb_strptr(stp, l.smblang_cur);
 768         lp->smbla_fmt = l.smblang_flags & 1;
 769         lp->smbla_num = l.smblang_num;
 770 
 771         return (stp->smbst_hdr->smbh_hdl);
 772 }
 773 
 774 id_t
 775 smbios_info_eventlog(smbios_hdl_t *shp, smbios_evlog_t *evp)
 776 {
 777         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_EVENTLOG);
 778         const smb_sel_t *sel;
 779         size_t len;
 780 
 781         if (stp == NULL)
 782                 return (-1); /* errno is set for us */
 783 
 784         if (stp->smbst_hdr->smbh_len < sizeof (smb_sel_t) - sizeof (uint8_t))
 785                 return (smb_set_errno(shp, ESMB_CORRUPT));
 786 
 787         sel = (smb_sel_t *)(uintptr_t)stp->smbst_hdr;
 788         len = stp->smbst_hdr->smbh_len - sizeof (smb_sel_t) + sizeof (uint8_t);
 789         bzero(evp, sizeof (smbios_evlog_t));
 790 
 791         if (len < sel->smbsel_typec * sel->smbsel_typesz)
 792                 return (smb_set_errno(shp, ESMB_CORRUPT));
 793 
 794         evp->smbev_size = sel->smbsel_len;
 795         evp->smbev_hdr = sel->smbsel_hdroff;
 796         evp->smbev_data = sel->smbsel_dataoff;
 797         evp->smbev_method = sel->smbsel_method;
 798         evp->smbev_flags = sel->smbsel_status;
 799         evp->smbev_format = sel->smbsel_format;
 800         evp->smbev_token = sel->smbsel_token;
 801         evp->smbev_addr.eva_addr = sel->smbsel_addr;
 802 
 803         if (sel->smbsel_typesz == sizeof (smbios_evtype_t)) {
 804                 evp->smbev_typec = sel->smbsel_typec;
 805                 evp->smbev_typev = (void *)(uintptr_t)sel->smbsel_typev;
 806         }
 807 
 808         return (stp->smbst_hdr->smbh_hdl);
 809 }
 810 
 811 int
 812 smbios_info_memarray(smbios_hdl_t *shp, id_t id, smbios_memarray_t *map)
 813 {
 814         const smb_struct_t *stp = smb_lookup_id(shp, id);
 815         smb_memarray_t m;
 816 
 817         if (stp == NULL)
 818                 return (-1); /* errno is set for us */
 819 
 820         if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAY)
 821                 return (smb_set_errno(shp, ESMB_TYPE));
 822 
 823         smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
 824         bzero(map, sizeof (smbios_memarray_t));
 825 
 826         map->smbma_location = m.smbmarr_loc;
 827         map->smbma_use = m.smbmarr_use;
 828         map->smbma_ecc = m.smbmarr_ecc;
 829         map->smbma_ndevs = m.smbmarr_ndevs;
 830         map->smbma_err = m.smbmarr_err;
 831 
 832         if (m.smbmarr_cap != 0x80000000)
 833                 map->smbma_size = (uint64_t)m.smbmarr_cap * 1024;
 834         else if (m.smbmarr_extcap != 0)
 835                 map->smbma_size = m.smbmarr_extcap;
 836         else
 837                 map->smbma_size = 0; /* unknown */
 838 
 839         return (0);
 840 }
 841 
 842 int
 843 smbios_info_memarrmap(smbios_hdl_t *shp, id_t id, smbios_memarrmap_t *map)
 844 {
 845         const smb_struct_t *stp = smb_lookup_id(shp, id);
 846         smb_memarrmap_t m;
 847 
 848         if (stp == NULL)
 849                 return (-1); /* errno is set for us */
 850 
 851         if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMARRAYMAP)
 852                 return (smb_set_errno(shp, ESMB_TYPE));
 853 
 854         smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
 855         bzero(map, sizeof (smbios_memarrmap_t));
 856 
 857         map->smbmam_array = m.smbamap_array;
 858         map->smbmam_width = m.smbamap_width;
 859 
 860         if (m.smbamap_start != 0xFFFFFFFF && m.smbamap_end != 0xFFFFFFFF) {
 861                 map->smbmam_addr = (uint64_t)m.smbamap_start * 1024;
 862                 map->smbmam_size = (uint64_t)
 863                     (m.smbamap_end - m.smbamap_start + 1) * 1024;
 864         } else if (m.smbamap_extstart != 0 && m.smbamap_extend != 0) {
 865                 map->smbmam_addr = m.smbamap_extstart;
 866                 map->smbmam_size = m.smbamap_extend - m.smbamap_extstart + 1;
 867         }
 868 
 869         return (0);
 870 }
 871 
 872 int
 873 smbios_info_memdevice(smbios_hdl_t *shp, id_t id, smbios_memdevice_t *mdp)
 874 {
 875         const smb_struct_t *stp = smb_lookup_id(shp, id);
 876         smb_memdevice_t m;
 877 
 878         if (stp == NULL)
 879                 return (-1); /* errno is set for us */
 880 
 881         if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICE)
 882                 return (smb_set_errno(shp, ESMB_TYPE));
 883 
 884         smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
 885         bzero(mdp, sizeof (smb_base_memdevice_t));
 886 
 887         mdp->smbmd_array = m.smbmdev_array;
 888         mdp->smbmd_error = m.smbmdev_error;
 889         mdp->smbmd_twidth = m.smbmdev_twidth == 0xFFFF ? -1U : m.smbmdev_twidth;
 890         mdp->smbmd_dwidth = m.smbmdev_dwidth == 0xFFFF ? -1U : m.smbmdev_dwidth;
 891 
 892         if (m.smbmdev_size == 0x7FFF) {
 893                 mdp->smbmd_size = (uint64_t)m.smbmdev_extsize;
 894                 mdp->smbmd_size *= 1024 * 1024; /* convert MB to bytes */
 895         } else if (m.smbmdev_size != 0xFFFF) {
 896                 mdp->smbmd_size = (uint64_t)(m.smbmdev_size & ~SMB_MDS_KBYTES);
 897                 if (m.smbmdev_size & SMB_MDS_KBYTES)
 898                         mdp->smbmd_size *= 1024;
 899                 else
 900                         mdp->smbmd_size *= 1024 * 1024;
 901         } else
 902                 mdp->smbmd_size = -1ULL; /* size unknown */
 903 
 904         mdp->smbmd_form = m.smbmdev_form;
 905         mdp->smbmd_set = m.smbmdev_set;
 906         mdp->smbmd_type = m.smbmdev_type;
 907         mdp->smbmd_speed = m.smbmdev_speed;
 908         mdp->smbmd_flags = m.smbmdev_flags;
 909         mdp->smbmd_dloc = smb_strptr(stp, m.smbmdev_dloc);
 910         mdp->smbmd_bloc = smb_strptr(stp, m.smbmdev_bloc);
 911 
 912         if (smb_libgteq(shp, SMB_VERSION_26)) {
 913                 mdp->smbmd_rank = m.smbmdev_attrs & 0x0F;
 914         }
 915 
 916         if (smb_libgteq(shp, SMB_VERSION_27)) {
 917                 mdp->smbmd_clkspeed = m.smbmdev_clkspeed;
 918         }
 919 
 920         if (smb_libgteq(shp, SMB_VERSION_28)) {
 921                 mdp->smbmd_minvolt = m.smbmdev_minvolt;
 922                 mdp->smbmd_maxvolt = m.smbmdev_maxvolt;
 923                 mdp->smbmd_confvolt = m.smbmdev_confvolt;
 924         }
 925 
 926         return (0);
 927 }
 928 
 929 int
 930 smbios_info_memdevmap(smbios_hdl_t *shp, id_t id, smbios_memdevmap_t *mdp)
 931 {
 932         const smb_struct_t *stp = smb_lookup_id(shp, id);
 933         smb_memdevmap_t m;
 934 
 935         if (stp == NULL)
 936                 return (-1); /* errno is set for us */
 937 
 938         if (stp->smbst_hdr->smbh_type != SMB_TYPE_MEMDEVICEMAP)
 939                 return (smb_set_errno(shp, ESMB_TYPE));
 940 
 941         smb_info_bcopy(stp->smbst_hdr, &m, sizeof (m));
 942         bzero(mdp, sizeof (smbios_memdevmap_t));
 943 
 944         mdp->smbmdm_device = m.smbdmap_device;
 945         mdp->smbmdm_arrmap = m.smbdmap_array;
 946         mdp->smbmdm_rpos = m.smbdmap_rpos;
 947         mdp->smbmdm_ipos = m.smbdmap_ipos;
 948         mdp->smbmdm_idepth = m.smbdmap_idepth;
 949 
 950         if (m.smbdmap_start != 0xFFFFFFFF && m.smbdmap_end != 0xFFFFFFFF) {
 951                 mdp->smbmdm_addr = (uint64_t)m.smbdmap_start * 1024;
 952                 mdp->smbmdm_size = (uint64_t)
 953                     (m.smbdmap_end - m.smbdmap_start + 1) * 1024;
 954         } else if (m.smbdmap_extstart != 0 && m.smbdmap_extend != 0) {
 955                 mdp->smbmdm_addr = m.smbdmap_extstart;
 956                 mdp->smbmdm_size = m.smbdmap_extend - m.smbdmap_extstart + 1;
 957         }
 958 
 959         return (0);
 960 }
 961 
 962 id_t
 963 smbios_info_hwsec(smbios_hdl_t *shp, smbios_hwsec_t *hsp)
 964 {
 965         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_SECURITY);
 966         smb_hwsec_t hs;
 967 
 968         if (stp == NULL)
 969                 return (-1); /* errno is set for us */
 970 
 971         smb_info_bcopy(stp->smbst_hdr, &hs, sizeof (hs));
 972         bzero(hsp, sizeof (smbios_hwsec_t));
 973 
 974         hsp->smbh_pwr_ps = SMB_HWS_PWR_PS(hs.smbhs_settings);
 975         hsp->smbh_kbd_ps = SMB_HWS_KBD_PS(hs.smbhs_settings);
 976         hsp->smbh_adm_ps = SMB_HWS_ADM_PS(hs.smbhs_settings);
 977         hsp->smbh_pan_ps = SMB_HWS_PAN_PS(hs.smbhs_settings);
 978 
 979         return (stp->smbst_hdr->smbh_hdl);
 980 }
 981 
 982 id_t
 983 smbios_info_boot(smbios_hdl_t *shp, smbios_boot_t *bp)
 984 {
 985         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_BOOT);
 986         const smb_boot_t *b = (smb_boot_t *)(uintptr_t)stp->smbst_hdr;
 987 
 988         if (stp == NULL)
 989                 return (-1); /* errno is set for us */
 990 
 991         bzero(bp, sizeof (smbios_boot_t));
 992 
 993         bp->smbt_status = b->smbbo_status[0];
 994         bp->smbt_size = stp->smbst_hdr->smbh_len - sizeof (smb_boot_t);
 995         bp->smbt_data = bp->smbt_size ? &b->smbbo_status[1] : NULL;
 996 
 997         return (stp->smbst_hdr->smbh_hdl);
 998 }
 999 
1000 id_t
1001 smbios_info_ipmi(smbios_hdl_t *shp, smbios_ipmi_t *ip)
1002 {
1003         const smb_struct_t *stp = smb_lookup_type(shp, SMB_TYPE_IPMIDEV);
1004         smb_ipmi_t i;
1005 
1006         if (stp == NULL)
1007                 return (-1); /* errno is set for us */
1008 
1009         smb_info_bcopy(stp->smbst_hdr, &i, sizeof (i));
1010         bzero(ip, sizeof (smbios_ipmi_t));
1011 
1012         ip->smbip_type = i.smbipm_type;
1013         ip->smbip_vers.smbv_major = SMB_IPM_SPEC_MAJOR(i.smbipm_spec);
1014         ip->smbip_vers.smbv_minor = SMB_IPM_SPEC_MINOR(i.smbipm_spec);
1015         ip->smbip_i2c = i.smbipm_i2c;
1016         ip->smbip_addr = i.smbipm_addr & ~SMB_IPM_ADDR_IO;
1017         ip->smbip_intr = i.smbipm_intr;
1018 
1019         if (i.smbipm_bus != (uint8_t)-1)
1020                 ip->smbip_bus = i.smbipm_bus;
1021         else
1022                 ip->smbip_bus = -1u;
1023 
1024         if (SMB_IPM_INFO_LSB(i.smbipm_info))
1025                 ip->smbip_addr |= 1; /* turn on least-significant bit of addr */
1026 
1027         if (i.smbipm_addr & SMB_IPM_ADDR_IO) {
1028                 switch (SMB_IPM_INFO_REGS(i.smbipm_info)) {
1029                 case SMB_IPM_REGS_1B:
1030                         ip->smbip_regspacing = 1;
1031                         break;
1032                 case SMB_IPM_REGS_4B:
1033                         ip->smbip_regspacing = 4;
1034                         break;
1035                 case SMB_IPM_REGS_16B:
1036                         ip->smbip_regspacing = 16;
1037                         break;
1038                 default:
1039                         ip->smbip_regspacing = 1;
1040                 }
1041                 ip->smbip_flags |= SMB_IPMI_F_IOADDR;
1042         }
1043 
1044         if (SMB_IPM_INFO_ISPEC(i.smbipm_info))
1045                 ip->smbip_flags |= SMB_IPMI_F_INTRSPEC;
1046 
1047         if (SMB_IPM_INFO_IPOL(i.smbipm_info) == SMB_IPM_IPOL_HI)
1048                 ip->smbip_flags |= SMB_IPMI_F_INTRHIGH;
1049 
1050         if (SMB_IPM_INFO_IMODE(i.smbipm_info) == SMB_IPM_IMODE_EDGE)
1051                 ip->smbip_flags |= SMB_IPMI_F_INTREDGE;
1052 
1053         return (stp->smbst_hdr->smbh_hdl);
1054 }
1055 
1056 static boolean_t
1057 smbios_has_oemstr(smbios_hdl_t *shp, const char *oemstr)
1058 {
1059         const smb_struct_t *stp = shp->sh_structs;
1060         smb_strtab_t s;
1061         int i, j;
1062 
1063         for (i = 0; i < shp->sh_nstructs; i++, stp++) {
1064                 if (stp->smbst_hdr->smbh_type != SMB_TYPE_OEMSTR)
1065                         continue;
1066 
1067                 smb_info_bcopy(stp->smbst_hdr, &s, sizeof (s));
1068                 for (j = 0; j < s.smbtb_count; j++)
1069                         if (strcmp(smb_strptr(stp, j + 1), oemstr) == 0)
1070                                 return (B_TRUE);
1071         }
1072 
1073         return (B_FALSE);
1074 }
1075 
1076 static const char *
1077 smb_serial_valid(const char *serial)
1078 {
1079         char buf[MAXNAMELEN];
1080         int i = 0;
1081 
1082         if (serial == NULL)
1083                 return (NULL);
1084 
1085         (void) strlcpy(buf, serial, sizeof (buf));
1086 
1087         while (buf[i] != '\0' && buf[i] == ' ')
1088                 i++;
1089 
1090         if (buf[i] == '\0' || strstr(buf, SMB_DEFAULT1) != NULL ||
1091             strstr(buf, SMB_DEFAULT2) != NULL)
1092                 return (NULL);
1093 
1094         return (serial);
1095 }
1096 
1097 /*
1098  * Get chassis SN or product SN
1099  */
1100 static int
1101 smb_get_sn(smbios_hdl_t *shp, const char **psnp, const char **csnp)
1102 {
1103         const smb_struct_t *stp;
1104         smbios_info_t s1, s3;
1105 
1106         if (psnp == NULL || csnp == NULL)
1107                 return (smb_set_errno(shp, ESMB_INVAL));
1108 
1109         *psnp = *csnp = NULL;
1110 
1111         /*
1112          * If SMBIOS meets Sun's PRMS requirements, retrieve product SN
1113          * from type 1 structure, and chassis SN from type 3 structure.
1114          * Otherwise return SN in type 1 structure as chassis SN.
1115          */
1116 
1117         /* Get type 1 SN */
1118         if ((stp = smb_lookup_type(shp, SMB_TYPE_SYSTEM)) == NULL ||
1119             smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s1) == SMB_ERR)
1120                 s1.smbi_serial = NULL;
1121 
1122         /* Get type 3 SN */
1123         if ((stp = smb_lookup_type(shp, SMB_TYPE_CHASSIS)) == NULL ||
1124             smbios_info_common(shp, stp->smbst_hdr->smbh_hdl, &s3) == SMB_ERR)
1125                 s3.smbi_serial = NULL;
1126 
1127         if (smbios_has_oemstr(shp, SMB_PRMS1)) {
1128                 *psnp = smb_serial_valid(s1.smbi_serial);
1129                 *csnp = smb_serial_valid(s3.smbi_serial);
1130         } else {
1131                 *csnp = smb_serial_valid(s1.smbi_serial);
1132         }
1133 
1134         return (0);
1135 }
1136 
1137 const char *
1138 smbios_psn(smbios_hdl_t *shp)
1139 {
1140         const char *psn, *csn;
1141 
1142         return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : psn);
1143 }
1144 
1145 const char *
1146 smbios_csn(smbios_hdl_t *shp)
1147 {
1148         const char *psn, *csn;
1149 
1150         return (smb_get_sn(shp, &psn, &csn) == SMB_ERR ? NULL : csn);
1151 }
1152 
1153 int
1154 smbios_info_extprocessor(smbios_hdl_t *shp, id_t id,
1155     smbios_processor_ext_t *epp)
1156 {
1157         const smb_struct_t *stp = smb_lookup_id(shp, id);
1158         smb_processor_ext_t *exp;
1159 
1160         if (stp == NULL)
1161                 return (-1); /* errno is set for us */
1162 
1163         if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PROCESSOR)
1164                 return (smb_set_errno(shp, ESMB_TYPE));
1165 
1166         exp = (smb_processor_ext_t *)(uintptr_t)stp->smbst_hdr;
1167         bzero(epp, sizeof (smbios_processor_ext_t));
1168 
1169         epp->smbpe_processor = exp->smbpre_processor;
1170         epp->smbpe_fru = exp->smbpre_fru;
1171         epp->smbpe_n = exp->smbpre_n;
1172         epp->smbpe_apicid = exp->smbpre_apicid;
1173 
1174         return (0);
1175 }
1176 
1177 int
1178 smbios_info_extport(smbios_hdl_t *shp, id_t id, smbios_port_ext_t *eportp)
1179 {
1180         const smb_struct_t *stp = smb_lookup_id(shp, id);
1181         smb_port_ext_t *ep;
1182 
1183         if (stp == NULL)
1184                 return (-1); /* errno is set for us */
1185 
1186         if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_PORT)
1187                 return (smb_set_errno(shp, ESMB_TYPE));
1188 
1189         ep = (smb_port_ext_t *)(uintptr_t)stp->smbst_hdr;
1190         bzero(eportp, sizeof (smbios_port_ext_t));
1191 
1192         eportp->smbporte_chassis = ep->smbpoe_chassis;
1193         eportp->smbporte_port = ep->smbpoe_port;
1194         eportp->smbporte_dtype = ep->smbpoe_dtype;
1195         eportp->smbporte_devhdl = ep->smbpoe_devhdl;
1196         eportp->smbporte_phy = ep->smbpoe_phy;
1197 
1198         return (0);
1199 }
1200 
1201 int
1202 smbios_info_pciexrc(smbios_hdl_t *shp, id_t id,
1203     smbios_pciexrc_t *rcp)
1204 {
1205         const smb_struct_t *stp = smb_lookup_id(shp, id);
1206         smb_pciexrc_t rc;
1207 
1208         if (stp == NULL)
1209                 return (-1); /* errno is set for us */
1210 
1211         if (stp->smbst_hdr->smbh_type != SUN_OEM_PCIEXRC)
1212                 return (smb_set_errno(shp, ESMB_TYPE));
1213 
1214         smb_info_bcopy(stp->smbst_hdr, &rc, sizeof (rc));
1215         bzero(rcp, sizeof (smbios_pciexrc_t));
1216 
1217         rcp->smbpcie_bb = rc.smbpciexrc_bboard;
1218         rcp->smbpcie_bdf = rc.smbpciexrc_bdf;
1219 
1220         return (0);
1221 }
1222 
1223 int
1224 smbios_info_extmemarray(smbios_hdl_t *shp, id_t id, smbios_memarray_ext_t *emap)
1225 {
1226         const smb_struct_t *stp = smb_lookup_id(shp, id);
1227         smb_memarray_ext_t exma;
1228 
1229         if (stp == NULL)
1230                 return (-1); /* errno is set for us */
1231 
1232         if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMARRAY)
1233                 return (smb_set_errno(shp, ESMB_TYPE));
1234 
1235         smb_info_bcopy(stp->smbst_hdr, &exma, sizeof (exma));
1236         bzero(emap, sizeof (smbios_memarray_ext_t));
1237 
1238         emap->smbmae_ma = exma.smbmarre_ma;
1239         emap->smbmae_comp = exma.smbmarre_component;
1240         emap->smbmae_bdf = exma.smbmarre_bdf;
1241 
1242         return (0);
1243 }
1244 
1245 int
1246 smbios_info_extmemdevice(smbios_hdl_t *shp, id_t id,
1247     smbios_memdevice_ext_t *emdp)
1248 {
1249         const smb_struct_t *stp = smb_lookup_id(shp, id);
1250         smb_memdevice_ext_t exmd;
1251 
1252         if (stp == NULL)
1253                 return (-1); /* errno is set for us */
1254 
1255         if (stp->smbst_hdr->smbh_type != SUN_OEM_EXT_MEMDEVICE)
1256                 return (smb_set_errno(shp, ESMB_TYPE));
1257 
1258         smb_info_bcopy(stp->smbst_hdr, &exmd, sizeof (exmd));
1259         bzero(emdp, sizeof (smbios_memdevice_ext_t));
1260 
1261         emdp->smbmdeve_md = exmd.smbmdeve_mdev;
1262         emdp->smbmdeve_drch = exmd.smbmdeve_dchan;
1263         emdp->smbmdeve_ncs  = exmd.smbmdeve_ncs;
1264         emdp->smbmdeve_cs = exmd.smbmdeve_cs;
1265 
1266         return (0);
1267 }
1268 
1269 int
1270 smbios_info_powersup(smbios_hdl_t *shp, id_t id, smbios_powersup_t *psup)
1271 {
1272         const smb_struct_t *stp = smb_lookup_id(shp, id);
1273         smb_powersup_t psu;
1274 
1275         if (stp == NULL)
1276                 return (-1); /* errno is set for us */
1277 
1278         if (stp->smbst_hdr->smbh_type != SMB_TYPE_POWERSUP)
1279                 return (smb_set_errno(shp, ESMB_TYPE));
1280 
1281         /* The minimum length required by the spec is 0x10. */
1282         if (stp->smbst_hdr->smbh_len < 0x10)
1283                 return (smb_set_errno(shp, ESMB_SHORT));
1284 
1285         bzero(psup, sizeof (*psup));
1286         smb_info_bcopy(stp->smbst_hdr, &psu, sizeof (psu));
1287         psup->smbps_group = psu.smbpsup_group;
1288         psup->smbps_maxout = psu.smbpsup_max;
1289 
1290         if (SMB_PSU_CHARS_ISHOT(psu.smbpsup_char))
1291                 psup->smbps_flags |= SMB_POWERSUP_F_HOT;
1292         if (SMB_PSU_CHARS_ISPRES(psu.smbpsup_char))
1293                 psup->smbps_flags |= SMB_POWERSUP_F_PRESENT;
1294         if (SMB_PSU_CHARS_ISUNPLUG(psu.smbpsup_char))
1295                 psup->smbps_flags |= SMB_POWERSUP_F_UNPLUG;
1296 
1297         psup->smbps_ivrs = SMB_PSU_CHARS_IVRS(psu.smbpsup_char);
1298         psup->smbps_status = SMB_PSU_CHARS_STATUS(psu.smbpsup_char);
1299         psup->smbps_pstype = SMB_PSU_CHARS_TYPE(psu.smbpsup_char);
1300 
1301         if (stp->smbst_hdr->smbh_len >= 0x12) {
1302                 psup->smbps_vprobe = psu.smbpsup_vprobe;
1303         } else {
1304                 psup->smbps_vprobe = 0xffff;
1305         }
1306 
1307         if (stp->smbst_hdr->smbh_len >= 0x14) {
1308                 psup->smbps_cooldev = psu.smbpsup_cooldev;
1309         } else {
1310                 psup->smbps_cooldev = 0xffff;
1311         }
1312 
1313         if (stp->smbst_hdr->smbh_len >= 0x16) {
1314                 psup->smbps_iprobe = psu.smbpsup_iprobe;
1315         } else {
1316                 psup->smbps_iprobe = 0xffff;
1317         }
1318 
1319         return (0);
1320 }
1321 
1322 int
1323 smbios_info_vprobe(smbios_hdl_t *shp, id_t id, smbios_vprobe_t *vprobe)
1324 {
1325         const smb_struct_t *stp = smb_lookup_id(shp, id);
1326         smb_vprobe_t vp;
1327 
1328         if (stp == NULL)
1329                 return (-1); /* errno is set for us */
1330 
1331         if (stp->smbst_hdr->smbh_type != SMB_TYPE_VPROBE)
1332                 return (smb_set_errno(shp, ESMB_TYPE));
1333 
1334         if (stp->smbst_hdr->smbh_len < SMB_VPROBE_MINLEN)
1335                 return (smb_set_errno(shp, ESMB_SHORT));
1336 
1337         bzero(vprobe, sizeof (*vprobe));
1338         smb_info_bcopy(stp->smbst_hdr, &vp, sizeof (vp));
1339         vprobe->smbvp_description = smb_strptr(stp, vp.smbvpr_descr);
1340         vprobe->smbvp_location = SMB_VPROBE_LOCATION(vp.smbvpr_locstat);
1341         vprobe->smbvp_status = SMB_VPROBE_STATUS(vp.smbvpr_locstat);
1342         vprobe->smbvp_maxval = vp.smbvpr_maxval;
1343         vprobe->smbvp_minval = vp.smbvpr_minval;
1344         vprobe->smbvp_resolution = vp.smbvpr_resolution;
1345         vprobe->smbvp_tolerance      = vp.smbvpr_tolerance;
1346         vprobe->smbvp_accuracy = vp.smbvpr_accuracy;
1347 
1348         if (stp->smbst_hdr->smbh_len >= SMB_VPROBE_NOMINAL_MINLEN) {
1349                 vprobe->smbvp_nominal = vp.smbvpr_nominal;
1350         } else {
1351                 vprobe->smbvp_nominal = SMB_PROBE_UNKNOWN_VALUE;
1352         }
1353 
1354         return (0);
1355 }
1356 
1357 int
1358 smbios_info_cooldev(smbios_hdl_t *shp, id_t id, smbios_cooldev_t *cooldev)
1359 {
1360         const smb_struct_t *stp = smb_lookup_id(shp, id);
1361         smb_cooldev_t cd;
1362 
1363         if (stp == NULL)
1364                 return (-1); /* errno is set for us */
1365 
1366         if (stp->smbst_hdr->smbh_type != SMB_TYPE_COOLDEV)
1367                 return (smb_set_errno(shp, ESMB_TYPE));
1368 
1369         if (stp->smbst_hdr->smbh_len < SMB_COOLDEV_MINLEN)
1370                 return (smb_set_errno(shp, ESMB_SHORT));
1371 
1372         bzero(cooldev, sizeof (*cooldev));
1373         smb_info_bcopy(stp->smbst_hdr, &cd, sizeof (cd));
1374         cooldev->smbcd_tprobe = cd.smbcdev_tprobe;
1375         cooldev->smbcd_type = SMB_COOLDEV_TYPE(cd.smbcdev_typstat);
1376         cooldev->smbcd_status = SMB_COOLDEV_STATUS(cd.smbcdev_typstat);
1377         cooldev->smbcd_group = cd.smbcdev_group;
1378         cooldev->smbcd_oem = cd.smbcdev_oem;
1379 
1380         if (stp->smbst_hdr->smbh_len >= SMB_COOLDEV_NOMINAL_MINLEN) {
1381                 cooldev->smbcd_nominal = cd.smbcdev_nominal;
1382         } else {
1383                 cooldev->smbcd_nominal = SMB_PROBE_UNKNOWN_VALUE;
1384         }
1385 
1386         /*
1387          * The description field was added in SMBIOS version 2.7. The
1388          * SMB_TYPE_COOLDEV support was only added after all of the 2.7+ fields
1389          * were added in the spec. So while a user may request an older version,
1390          * we don't have to worry about old structures and just simply skip it
1391          * if they're not asking for it.
1392          */
1393         if (smb_libgteq(shp, SMB_VERSION_27) &&
1394             smb_gteq(shp, SMB_VERSION_27) &&
1395             stp->smbst_hdr->smbh_len >= SMB_COOLDEV_DESCR_MINLEN) {
1396                 cooldev->smbcd_descr = smb_strptr(stp, cd.smbcdev_descr);
1397         } else {
1398                 cooldev->smbcd_descr = NULL;
1399         }
1400 
1401         return (0);
1402 }
1403 
1404 int
1405 smbios_info_tprobe(smbios_hdl_t *shp, id_t id, smbios_tprobe_t *tprobe)
1406 {
1407         const smb_struct_t *stp = smb_lookup_id(shp, id);
1408         smb_tprobe_t tp;
1409 
1410         if (stp == NULL)
1411                 return (-1); /* errno is set for us */
1412 
1413         if (stp->smbst_hdr->smbh_type != SMB_TYPE_TPROBE)
1414                 return (smb_set_errno(shp, ESMB_TYPE));
1415 
1416         if (stp->smbst_hdr->smbh_len < SMB_TPROBE_MINLEN)
1417                 return (smb_set_errno(shp, ESMB_SHORT));
1418 
1419         bzero(tprobe, sizeof (*tprobe));
1420         smb_info_bcopy(stp->smbst_hdr, &tp, sizeof (tp));
1421         tprobe->smbtp_description = smb_strptr(stp, tp.smbtpr_descr);
1422         tprobe->smbtp_location = SMB_TPROBE_LOCATION(tp.smbtpr_locstat);
1423         tprobe->smbtp_status = SMB_TPROBE_STATUS(tp.smbtpr_locstat);
1424         tprobe->smbtp_maxval = tp.smbtpr_maxval;
1425         tprobe->smbtp_minval = tp.smbtpr_minval;
1426         tprobe->smbtp_resolution = tp.smbtpr_resolution;
1427         tprobe->smbtp_tolerance      = tp.smbtpr_tolerance;
1428         tprobe->smbtp_accuracy = tp.smbtpr_accuracy;
1429 
1430         if (stp->smbst_hdr->smbh_len >= SMB_TPROBE_NOMINAL_MINLEN) {
1431                 tprobe->smbtp_nominal = tp.smbtpr_nominal;
1432         } else {
1433                 tprobe->smbtp_nominal = SMB_PROBE_UNKNOWN_VALUE;
1434         }
1435 
1436         return (0);
1437 }
1438 
1439 int
1440 smbios_info_iprobe(smbios_hdl_t *shp, id_t id, smbios_iprobe_t *iprobe)
1441 {
1442         const smb_struct_t *sip = smb_lookup_id(shp, id);
1443         smb_iprobe_t ip;
1444 
1445         if (sip == NULL)
1446                 return (-1); /* errno is set for us */
1447 
1448         if (sip->smbst_hdr->smbh_type != SMB_TYPE_IPROBE)
1449                 return (smb_set_errno(shp, ESMB_TYPE));
1450 
1451         if (sip->smbst_hdr->smbh_len < SMB_IPROBE_MINLEN)
1452                 return (smb_set_errno(shp, ESMB_SHORT));
1453 
1454         bzero(iprobe, sizeof (*iprobe));
1455         smb_info_bcopy(sip->smbst_hdr, &ip, sizeof (ip));
1456         iprobe->smbip_description = smb_strptr(sip, ip.smbipr_descr);
1457         iprobe->smbip_location = SMB_IPROBE_LOCATION(ip.smbipr_locstat);
1458         iprobe->smbip_status = SMB_IPROBE_STATUS(ip.smbipr_locstat);
1459         iprobe->smbip_maxval = ip.smbipr_maxval;
1460         iprobe->smbip_minval = ip.smbipr_minval;
1461         iprobe->smbip_resolution = ip.smbipr_resolution;
1462         iprobe->smbip_tolerance      = ip.smbipr_tolerance;
1463         iprobe->smbip_accuracy = ip.smbipr_accuracy;
1464 
1465         if (sip->smbst_hdr->smbh_len >= SMB_IPROBE_NOMINAL_MINLEN) {
1466                 iprobe->smbip_nominal = ip.smbipr_nominal;
1467         } else {
1468                 iprobe->smbip_nominal = SMB_PROBE_UNKNOWN_VALUE;
1469         }
1470 
1471         return (0);
1472 }