| /* ----------------------------------------------------------------------- * |
| * |
| * Copyright 2011 Intel Corporation; author: H. Peter Anvin |
| * |
| * Permission is hereby granted, free of charge, to any person |
| * obtaining a copy of this software and associated documentation |
| * files (the "Software"), to deal in the Software without |
| * restriction, including without limitation the rights to use, |
| * copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following |
| * conditions: |
| * |
| * The above copyright notice and this permission notice shall |
| * be included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * ----------------------------------------------------------------------- */ |
| |
| /* |
| * Search DMI information for specific data or strings |
| */ |
| |
| #include <string.h> |
| #include <stdio.h> |
| #include <sys/bitops.h> |
| #include <sys/cpu.h> |
| #include <syslinux/sysappend.h> |
| #include "core.h" |
| |
| struct dmi_table { |
| uint8_t type; |
| uint8_t length; |
| uint16_t handle; |
| }; |
| |
| struct dmi_header { |
| char signature[5]; |
| uint8_t csum; |
| uint16_t tbllen; |
| uint32_t tbladdr; |
| uint16_t nstruc; |
| uint8_t revision; |
| uint8_t reserved; |
| }; |
| |
| struct smbios_header { |
| char signature[4]; |
| uint8_t csum; |
| uint8_t len; |
| uint8_t major; |
| uint8_t minor; |
| uint16_t maxsize; |
| uint8_t revision; |
| uint8_t fmt[5]; |
| |
| struct dmi_header dmi; |
| }; |
| |
| static const struct dmi_header *dmi; |
| |
| static uint8_t checksum(const void *buf, size_t len) |
| { |
| const uint8_t *p = buf; |
| uint8_t csum = 0; |
| |
| while (len--) |
| csum += *p++; |
| |
| return csum; |
| } |
| |
| static bool is_old_dmi(size_t dptr) |
| { |
| const struct dmi_header *dmi = (void *)dptr; |
| |
| return !memcmp(dmi->signature, "_DMI_", 5) && |
| !checksum(dmi, 0x0f); |
| return false; |
| } |
| |
| static bool is_smbios(size_t dptr) |
| { |
| const struct smbios_header *smb = (void *)dptr; |
| |
| return !memcmp(smb->signature, "_SM_", 4) && |
| !checksum(smb, smb->len) && |
| is_old_dmi(dptr+16); |
| } |
| |
| /* |
| * Find the root structure |
| */ |
| static void dmi_find_header(void) |
| { |
| size_t dptr; |
| |
| /* Search for _SM_ or _DMI_ structure */ |
| for (dptr = 0xf0000 ; dptr < 0x100000 ; dptr += 16) { |
| if (is_smbios(dptr)) { |
| dmi = (const struct dmi_header *)(dptr + 16); |
| break; |
| } else if (is_old_dmi(dptr)) { |
| dmi = (const struct dmi_header *)dptr; |
| break; |
| } |
| } |
| } |
| |
| /* |
| * Return a specific data element in a specific table, and verify |
| * that it is within the bounds of the table. |
| */ |
| static const void *dmi_find_data(uint8_t type, uint8_t base, uint8_t length) |
| { |
| const struct dmi_table *table; |
| size_t offset, end; |
| unsigned int tblcount; |
| |
| if (!dmi) |
| return NULL; |
| |
| if (base < 2) |
| return NULL; |
| |
| end = base+length; |
| |
| offset = 0; |
| tblcount = dmi->nstruc; |
| |
| while (offset+6 <= dmi->tbllen && tblcount--) { |
| table = (const struct dmi_table *)(dmi->tbladdr + offset); |
| |
| if (table->type == 127) /* End of table */ |
| break; |
| |
| if (table->length < sizeof *table) |
| break; /* Invalid length */ |
| |
| offset += table->length; |
| |
| if (table->type == type && end <= table->length) |
| return (const char *)table + base; |
| |
| /* Search for a double NUL terminating the string table */ |
| while (offset+2 <= dmi->tbllen && |
| *(const uint16_t *)(dmi->tbladdr + offset) != 0) |
| offset++; |
| |
| offset += 2; |
| } |
| |
| return NULL; |
| } |
| |
| /* |
| * Return a specific string in a specific table. |
| */ |
| static const char *dmi_find_string(uint8_t type, uint8_t base) |
| { |
| const struct dmi_table *table; |
| size_t offset; |
| unsigned int tblcount; |
| |
| if (!dmi) |
| return NULL; |
| |
| if (base < 2) |
| return NULL; |
| |
| offset = 0; |
| tblcount = dmi->nstruc; |
| |
| while (offset+6 <= dmi->tbllen && tblcount--) { |
| table = (const struct dmi_table *)(dmi->tbladdr + offset); |
| |
| if (table->type == 127) /* End of table */ |
| break; |
| |
| if (table->length < sizeof *table) |
| break; /* Invalid length */ |
| |
| offset += table->length; |
| |
| if (table->type == type && base < table->length) { |
| uint8_t index = ((const uint8_t *)table)[base]; |
| const char *p = (const char *)table + table->length; |
| const char *str; |
| char c; |
| |
| if (!index) |
| return NULL; /* String not present */ |
| |
| while (--index) { |
| if (!*p) |
| return NULL; |
| |
| do { |
| if (offset++ >= dmi->tbllen) |
| return NULL; |
| c = *p++; |
| } while (c); |
| } |
| |
| /* Make sure the string is null-terminated */ |
| str = p; |
| do { |
| if (offset++ >= dmi->tbllen) |
| return NULL; |
| c = *p++; |
| } while (c); |
| return str; |
| } |
| |
| /* Search for a double NUL terminating the string table */ |
| while (offset+2 <= dmi->tbllen && |
| *(const uint16_t *)(dmi->tbladdr + offset) != 0) |
| offset++; |
| |
| offset += 2; |
| } |
| |
| return NULL; |
| } |
| |
| struct sysappend_dmi_strings { |
| const char *prefix; |
| enum syslinux_sysappend sa; |
| uint8_t index; |
| uint8_t offset; |
| }; |
| |
| static const struct sysappend_dmi_strings dmi_strings[] = { |
| { "SYSVENDOR=", SYSAPPEND_SYSVENDOR, 1, 0x04 }, |
| { "SYSPRODUCT=", SYSAPPEND_SYSPRODUCT, 1, 0x05 }, |
| { "SYSVERSION=", SYSAPPEND_SYSVERSION, 1, 0x06 }, |
| { "SYSSERIAL=", SYSAPPEND_SYSSERIAL, 1, 0x07 }, |
| { "SYSSKU=", SYSAPPEND_SYSSKU, 1, 0x19 }, |
| { "SYSFAMILY=", SYSAPPEND_SYSFAMILY, 1, 0x1a }, |
| { "MBVENDOR=", SYSAPPEND_MBVENDOR, 2, 0x04 }, |
| { "MBPRODUCT=", SYSAPPEND_MBPRODUCT, 2, 0x05 }, |
| { "MBVERSION=", SYSAPPEND_MBVERSION, 2, 0x06 }, |
| { "MBSERIAL=", SYSAPPEND_MBSERIAL, 2, 0x07 }, |
| { "MBASSET=", SYSAPPEND_MBASSET, 2, 0x08 }, |
| { "BIOSVENDOR=", SYSAPPEND_BIOSVENDOR, 0, 0x04 }, |
| { "BIOSVERSION=", SYSAPPEND_BIOSVERSION, 0, 0x05 }, |
| { NULL, 0, 0, 0 } |
| }; |
| |
| /* |
| * Install the string in the string table, if nonempty, after |
| * removing leading and trailing whitespace. |
| */ |
| static bool is_ctl_or_whitespace(char c) |
| { |
| return (c <= ' ' || c == '\x7f'); |
| } |
| |
| static const char *dmi_install_string(const char *pfx, const char *str) |
| { |
| const char *p, *ep; |
| size_t pfxlen; |
| char *nstr, *q; |
| |
| if (!str) |
| return NULL; |
| |
| while (*str && is_ctl_or_whitespace(*str)) |
| str++; |
| |
| if (!*str) |
| return NULL; |
| |
| ep = p = str; |
| while (*p) { |
| if (!is_ctl_or_whitespace(*p)) |
| ep = p+1; |
| p++; |
| } |
| |
| pfxlen = strlen(pfx); |
| q = nstr = malloc(pfxlen + (ep-str) + 1); |
| if (!nstr) |
| return NULL; |
| memcpy(q, pfx, pfxlen); |
| q += pfxlen; |
| memcpy(q, str, ep-str); |
| q += (ep-str); |
| *q = '\0'; |
| |
| return nstr; |
| } |
| |
| static void sysappend_set_sysff(const uint8_t *type) |
| { |
| static char sysff_str[] = "SYSFF=000"; |
| |
| if (!type || !*type) |
| return; |
| |
| sprintf(sysff_str+6, "%u", *type & 0x7f); |
| sysappend_strings[SYSAPPEND_SYSFF] = sysff_str; |
| } |
| |
| struct cpuflag { |
| uint8_t bit; |
| char flag; |
| }; |
| |
| static void sysappend_set_cpu(void) |
| { |
| static char cpu_str[6+6] = "CPU="; |
| char *p = cpu_str + 4; |
| static const struct cpuflag cpuflags[] = { |
| { 0*32+ 6, 'P' }, /* PAE */ |
| { 1*32+ 5, 'V' }, /* VMX */ |
| { 1*32+ 6, 'T' }, /* SMX (TXT) */ |
| { 2*32+20, 'X' }, /* XD/NX */ |
| { 2*32+29, 'L' }, /* Long mode (x86-64) */ |
| { 3*32+ 2, 'S' }, /* SVM */ |
| { 0, 0 } |
| }; |
| const struct cpuflag *cf; |
| |
| /* Not technically from DMI, but it fit here... */ |
| |
| if (!cpu_has_eflag(EFLAGS_ID)) { |
| /* No CPUID */ |
| *p++ = cpu_has_eflag(EFLAGS_AC) ? '4' : '3'; |
| } else { |
| uint32_t flags[4], eax, ebx, family; |
| uint32_t ext_level; |
| |
| cpuid(1, &eax, &ebx, &flags[1], &flags[0]); |
| family = (eax & 0x0ff00f00) >> 8; |
| *p++ = family >= 6 ? '6' : family + '0'; |
| |
| ext_level = cpuid_eax(0x80000000); |
| if (ext_level >= 0x80000001 && ext_level <= 0x8000ffff) { |
| cpuid(0x80000001, &eax, &ebx, &flags[3], &flags[2]); |
| } else { |
| flags[2] = flags[3] = 0; |
| } |
| |
| for (cf = cpuflags; cf->flag; cf++) { |
| if (test_bit(cf->bit, flags)) |
| *p++ = cf->flag; |
| } |
| } |
| |
| *p = '\0'; |
| |
| sysappend_strings[SYSAPPEND_CPU] = cpu_str; |
| } |
| |
| void dmi_init(void) |
| { |
| const struct sysappend_dmi_strings *ds; |
| |
| sysappend_set_cpu(); |
| |
| dmi_find_header(); |
| if (!dmi) |
| return; |
| |
| sysappend_set_uuid(dmi_find_data(1, 0x08, 16)); |
| sysappend_set_sysff(dmi_find_data(3, 0x05, 1)); |
| |
| for (ds = dmi_strings; ds->prefix; ds++) { |
| if (!sysappend_strings[ds->sa]) { |
| const char *str = dmi_find_string(ds->index, ds->offset); |
| sysappend_strings[ds->sa] = dmi_install_string(ds->prefix, str); |
| } |
| } |
| } |