xen-project/xen
1
0 Fork 0
mirror of https://github.com/xen-project/xen.git synced 2026-10-28 02:01:24 +01:00
Code Issues Activity
Files
9f114abb37f42df858ed658f2d1149c818c12f11
xen/tools/firmware/hvmloader/smbios.c
T
Anton Belousov 9f114abb37 hvmloader: add new SMBIOS tables (7, 8, 9, 26, 27, 28) 
Some SMBIOS tables are used by certain malware families to detect virtualized
environments via WMI queries.

To improve stealth for sandboxing purposes, this patch adds support
for populating these SMBIOS tables from an external binary specified
via the "smbios_firmware" domain config option:

* 7 - Cache Info
* 8 - Port Connector
* 9 - System Slots
* 26 - Voltage Probe
* 27 - Cooling Device
* 28 - Temperature Probe

If particular table is absent in binary file, then it will not be mapped to
memory. This method works for Windows domains as tables 7,8,9,26,27,28 are not
critical for OS boot and runtime. Also if "smbios_firmware" parameter is not
provided, these tables will be skipped in write_smbios_tables function.

From: Anton Belousov <blsvntn@outlook.com>
Signed-off-by: Petr Beneš <w1benny@gmail.com>
Acked-by: Jan Beulich <jbeulich@suse.com>
2025-08-27 11:26:33 +02:00

1170 lines
32 KiB
C
Raw Blame History

/*
* smbios.c - Generate SMBIOS tables for Xen HVM domU's.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*
* Copyright (C) IBM Corporation, 2006
*
* Authors: Andrew D. Ball <aball@us.ibm.com>
*/
#include <stdint.h>
#include <xen/xen.h>
#include <xen/version.h>
#include "smbios_types.h"
#include "util.h"
#include "hypercall.h"
#include <xen/hvm/hvm_xs_strings.h>
/* SBMIOS handle base values */
#define SMBIOS_HANDLE_TYPE0 0x0000
#define SMBIOS_HANDLE_TYPE1 0x0100
#define SMBIOS_HANDLE_TYPE2 0x0200
#define SMBIOS_HANDLE_TYPE3 0x0300
#define SMBIOS_HANDLE_TYPE4 0x0400
#define SMBIOS_HANDLE_TYPE7 0x0700
#define SMBIOS_HANDLE_TYPE8 0x0800
#define SMBIOS_HANDLE_TYPE9 0x0900
#define SMBIOS_HANDLE_TYPE11 0x0B00
#define SMBIOS_HANDLE_TYPE16 0x1000
#define SMBIOS_HANDLE_TYPE17 0x1100
#define SMBIOS_HANDLE_TYPE19 0x1300
#define SMBIOS_HANDLE_TYPE20 0x1400
#define SMBIOS_HANDLE_TYPE22 0x1600
#define SMBIOS_HANDLE_TYPE26 0x1A00
#define SMBIOS_HANDLE_TYPE27 0x1B00
#define SMBIOS_HANDLE_TYPE28 0x1C00
#define SMBIOS_HANDLE_TYPE32 0x2000
#define SMBIOS_HANDLE_TYPE39 0x2700
#define SMBIOS_HANDLE_TYPE127 0x7f00
static void
smbios_pt_init(void);
static void*
get_smbios_pt_struct(uint8_t type, uint32_t *length_out);
static void *
smbios_pt_copy(void *start, uint8_t type, uint16_t handle, size_t table_size);
static void
get_cpu_manufacturer(char *buf, int len);
static int
write_smbios_tables(void *ep, void *start,
uint32_t vcpus, uint64_t memsize,
uint8_t uuid[16], char *xen_version,
uint32_t xen_major_version, uint32_t xen_minor_version,
unsigned *nr_structs, unsigned *max_struct_size);
static uint64_t
get_memsize(void);
static void
smbios_entry_point_init(void *start,
uint16_t max_structure_size,
uint16_t structure_table_length,
uint32_t structure_table_address,
uint16_t number_of_structures);
static void *
smbios_type_0_init(void *start, const char *xen_version,
uint32_t xen_major_version, uint32_t xen_minor_version);
static void *
smbios_type_1_init(void *start, const char *xen_version,
uint8_t uuid[16]);
static void *
smbios_type_2_init(void *start);
static void *
smbios_type_3_init(void *start);
static void *
smbios_type_4_init(void *start, unsigned int cpu_number,
char *cpu_manufacturer);
static void *
smbios_type_7_init(void *start);
static void *
smbios_type_8_init(void *start);
static void *
smbios_type_9_init(void *start);
static void *
smbios_type_11_init(void *start);
static void *
smbios_type_16_init(void *start, uint32_t memory_size_mb, int nr_mem_devs);
static void *
smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance);
static void *
smbios_type_19_init(void *start, uint32_t memory_size_mb, int instance);
static void *
smbios_type_20_init(void *start, uint32_t memory_size_mb, int instance);
static void *
smbios_type_22_init(void *start);
static void *
smbios_type_26_init(void *start);
static void *
smbios_type_27_init(void *start);
static void *
smbios_type_28_init(void *start);
static void *
smbios_type_32_init(void *start);
static void *
smbios_type_39_init(void *start);
static void *
smbios_type_vendor_oem_init(void *start);
static void *
smbios_type_127_init(void *start);
static uint32_t *smbios_pt_addr = NULL;
static uint32_t smbios_pt_length = 0;
static void
smbios_pt_init(void)
{
const char *s;
s = xenstore_read(HVM_XS_SMBIOS_PT_ADDRESS, NULL);
if ( s == NULL )
goto reset;
smbios_pt_addr = (uint32_t*)(uint32_t)strtoll(s, NULL, 0);
if ( smbios_pt_addr == NULL )
goto reset;
s = xenstore_read(HVM_XS_SMBIOS_PT_LENGTH, NULL);
if ( s == NULL )
goto reset;
smbios_pt_length = (uint32_t)strtoll(s, NULL, 0);
if ( smbios_pt_length == 0 )
goto reset;
return;
reset:
smbios_pt_addr = NULL;
smbios_pt_length = 0;
}
static void*
get_smbios_pt_struct(uint8_t type, uint32_t *length_out)
{
uint32_t *sep = smbios_pt_addr;
uint32_t total = 0;
uint8_t *ptr;
if ( sep == NULL )
return NULL;
while ( total < smbios_pt_length )
{
ptr = (uint8_t*)(sep + 1);
if ( ptr[0] == type )
{
*length_out = *sep;
return ptr;
}
total += (*sep + sizeof(uint32_t));
sep = (uint32_t*)(ptr + *sep);
}
return NULL;
}
static void *
smbios_pt_copy(void *start, uint8_t type, uint16_t handle, size_t min_size)
{
struct smbios_structure_header *header = start;
void *pts;
uint32_t length;
pts = get_smbios_pt_struct(type, &length);
if ( pts != NULL && length >= min_size )
{
memcpy(start, pts, length);
header->handle = handle;
return start + length;
}
return start;
}
static void
get_cpu_manufacturer(char *buf, int len)
{
char id[12];
uint32_t eax = 0;
cpuid(0, &eax, (uint32_t *)&id[0], (uint32_t *)&id[8],
(uint32_t *)&id[4]);
if ( memcmp(id, "GenuineIntel", 12) == 0 )
strncpy(buf, "Intel", len);
else if ( memcmp(id, "AuthenticAMD", 12) == 0 )
strncpy(buf, "AMD", len);
else
strncpy(buf, "unknown", len);
}
static int
write_smbios_tables(void *ep, void *start,
uint32_t vcpus, uint64_t memsize,
uint8_t uuid[16], char *xen_version,
uint32_t xen_major_version, uint32_t xen_minor_version,
unsigned *nr_structs, unsigned *max_struct_size)
{
unsigned cpu_num;
char *p, *q;
char cpu_manufacturer[15];
int i, nr_mem_devs;
smbios_pt_init();
get_cpu_manufacturer(cpu_manufacturer, 15);
p = (char *)start;
#define do_struct(fn) do { \
q = (fn); \
if ( q != p ) \
(*nr_structs)++; \
if ( (q - p) > *max_struct_size ) \
*max_struct_size = q - p; \
p = q; \
} while (0)
do_struct(smbios_type_0_init(p, xen_version, xen_major_version,
xen_minor_version));
do_struct(smbios_type_1_init(p, xen_version, uuid));
do_struct(smbios_type_2_init(p));
do_struct(smbios_type_3_init(p));
for ( cpu_num = 1; cpu_num <= vcpus; cpu_num++ )
do_struct(smbios_type_4_init(p, cpu_num, cpu_manufacturer));
do_struct(smbios_type_7_init(p));
do_struct(smbios_type_8_init(p));
do_struct(smbios_type_9_init(p));
do_struct(smbios_type_11_init(p));
/* Each 'memory device' covers up to 16GB of address space. */
nr_mem_devs = (memsize + 0x3fff) >> 14;
do_struct(smbios_type_16_init(p, memsize, nr_mem_devs));
for ( i = 0; i < nr_mem_devs; i++ )
{
uint32_t dev_memsize = 0x4000; /* all but last covers 16GB */
if ( (i == (nr_mem_devs - 1)) && ((memsize & 0x3fff) != 0) )
dev_memsize = memsize & 0x3fff; /* last dev is <16GB */
do_struct(smbios_type_17_init(p, dev_memsize, i));
do_struct(smbios_type_19_init(p, dev_memsize, i));
do_struct(smbios_type_20_init(p, dev_memsize, i));
}
do_struct(smbios_type_22_init(p));
do_struct(smbios_type_26_init(p));
do_struct(smbios_type_27_init(p));
do_struct(smbios_type_28_init(p));
do_struct(smbios_type_32_init(p));
do_struct(smbios_type_39_init(p));
do_struct(smbios_type_vendor_oem_init(p));
do_struct(smbios_type_127_init(p));
#undef do_struct
return ((char *)p - (char *)start);
}
/* Calculate how much pseudo-physical memory (in MB) is allocated to us. */
static uint64_t
get_memsize(void)
{
uint64_t sz;
sz = (uint64_t)hvm_info->low_mem_pgend << PAGE_SHIFT;
if ( hvm_info->high_mem_pgend )
sz += (((uint64_t)hvm_info->high_mem_pgend << PAGE_SHIFT) - GB(4));
/*
* Round up to the nearest MB. The user specifies domU pseudo-physical
* memory in megabytes, so not doing this could easily lead to reporting
* one less MB than the user specified.
*/
return (sz + MB(1) - 1) >> 20;
}
void
hvm_write_smbios_tables(
unsigned long ep, unsigned long smbios_start, unsigned long smbios_end)
{
xen_domain_handle_t uuid;
uint16_t xen_major_version, xen_minor_version;
uint32_t xen_version;
char xen_extra_version[XEN_EXTRAVERSION_LEN];
/* guess conservatively on buffer length for Xen version string */
char xen_version_str[80];
/* temporary variables used to build up Xen version string */
char *p = NULL; /* points to next point of insertion */
unsigned len = 0; /* length of string already composed */
char tmp[16]; /* holds result of itoa() */
unsigned tmp_len; /* length of next string to add */
unsigned nr_structs = 0, max_struct_size = 0;
hypercall_xen_version(XENVER_guest_handle, uuid);
BUILD_BUG_ON(sizeof(xen_domain_handle_t) != 16);
/* xen_version major and minor */
xen_version = hypercall_xen_version(XENVER_version, NULL);
xen_major_version = (uint16_t) (xen_version >> 16);
xen_minor_version = (uint16_t) xen_version;
hypercall_xen_version(XENVER_extraversion, xen_extra_version);
/* build up human-readable Xen version string */
p = xen_version_str;
len = 0;
itoa(tmp, xen_major_version);
tmp_len = strlen(tmp);
len += tmp_len;
if ( len >= sizeof(xen_version_str) )
goto error_out;
strcpy(p, tmp);
p += tmp_len;
len++;
if ( len >= sizeof(xen_version_str) )
goto error_out;
*p = '.';
p++;
itoa(tmp, xen_minor_version);
tmp_len = strlen(tmp);
len += tmp_len;
if ( len >= sizeof(xen_version_str) )
goto error_out;
strcpy(p, tmp);
p += tmp_len;
tmp_len = strlen(xen_extra_version);
len += tmp_len;
if ( len >= sizeof(xen_version_str) )
goto error_out;
strcpy(p, xen_extra_version);
p += tmp_len;
xen_version_str[sizeof(xen_version_str)-1] = '\0';
/* scratch_start is a safe large memory area for scratch. */
len = write_smbios_tables((void *)ep, (void *)scratch_start,
hvm_info->nr_vcpus, get_memsize(),
uuid, xen_version_str,
xen_major_version, xen_minor_version,
&nr_structs, &max_struct_size);
if ( smbios_start && smbios_start + len > smbios_end )
goto error_out;
if ( !smbios_start )
smbios_start = (unsigned long)mem_alloc(len, 0);
memcpy((void *)smbios_start, (void *)scratch_start, len);
smbios_entry_point_init(
(void *)ep, max_struct_size, len, smbios_start, nr_structs);
return;
error_out:
printf("Could not write SMBIOS tables, error in hvmloader.c:"
"hvm_write_smbios_tables()\n");
}
static void
smbios_entry_point_init(void *start,
uint16_t max_structure_size,
uint16_t structure_table_length,
uint32_t structure_table_address,
uint16_t number_of_structures)
{
uint8_t sum;
int i;
struct smbios_entry_point *ep = start;
memset(ep, 0, sizeof(*ep));
memcpy(ep->anchor_string, "_SM_", 4);
ep->length = 0x1f;
ep->smbios_major_version = 2;
ep->smbios_minor_version = 4;
ep->max_structure_size = max_structure_size;
ep->entry_point_revision = 0;
memcpy(ep->intermediate_anchor_string, "_DMI_", 5);
ep->structure_table_length = structure_table_length;
ep->structure_table_address = structure_table_address;
ep->number_of_structures = number_of_structures;
ep->smbios_bcd_revision = 0x24;
sum = 0;
for ( i = 0; i < 0x10; i++ )
sum += ((int8_t *)start)[i];
ep->checksum = -sum;
sum = 0;
for ( i = 0x10; i < ep->length; i++ )
sum += ((int8_t *)start)[i];
ep->intermediate_checksum = -sum;
}
/* Type 0 -- BIOS Information */
static void *
smbios_type_0_init(void *start, const char *xen_version,
uint32_t xen_major_version, uint32_t xen_minor_version)
{
struct smbios_type_0 *p = start;
static const char *smbios_release_date = __SMBIOS_DATE__;
const char *s;
void *next;
/*
* Specification says Type 0 table has length of at least 18h for v2.4-3.0.
*/
BUILD_BUG_ON(sizeof(*p) != 24);
next = smbios_pt_copy(start, 0, SMBIOS_HANDLE_TYPE0, sizeof(*p));
if ( next != start )
return next;
memset(p, 0, sizeof(*p));
p->header.type = 0;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE0;
p->vendor_str = 1;
p->version_str = 2;
p->starting_address_segment = 0xe800;
p->release_date_str = 3;
p->rom_size = 0;
/* BIOS Characteristics. */
p->characteristics[0] = 0x80; /* PCI is supported */
p->characteristics[2] = 0x08; /* EDD is supported */
/* Extended Characteristics: Enable Targeted Content Distribution. */
p->characteristics_extension_bytes[1] = 0x04;
p->major_release = xen_major_version;
p->minor_release = xen_minor_version;
p->embedded_controller_major = 0xff;
p->embedded_controller_minor = 0xff;
start += sizeof(*p);
s = xenstore_read(HVM_XS_BIOS_VENDOR, "Xen");
strcpy((char *)start, s);
start += strlen(s) + 1;
s = xenstore_read(HVM_XS_BIOS_VERSION, xen_version);
strcpy((char *)start, s);
start += strlen(s) + 1;
strcpy((char *)start, smbios_release_date);
start += strlen(smbios_release_date) + 1;
*((uint8_t *)start) = 0;
return start + 1;
}
/* Type 1 -- System Information */
static void *
smbios_type_1_init(void *start, const char *xen_version,
uint8_t uuid[16])
{
char uuid_str[37];
struct smbios_type_1 *p = start;
const char *s;
void *next;
/* Specification says Type 1 table has length of 1Bh for v2.4 and later. */
BUILD_BUG_ON(sizeof(*p) != 27);
next = smbios_pt_copy(start, 1, SMBIOS_HANDLE_TYPE1, sizeof(*p));
if ( next != start )
return next;
memset(p, 0, sizeof(*p));
p->header.type = 1;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE1;
p->manufacturer_str = 1;
p->product_name_str = 2;
p->version_str = 3;
p->serial_number_str = 4;
memcpy(p->uuid, uuid, 16);
p->wake_up_type = 0x06; /* power switch */
p->sku_str = 0;
p->family_str = 0;
start += sizeof(*p);
s = xenstore_read(HVM_XS_SYSTEM_MANUFACTURER, "Xen");
strcpy((char *)start, s);
start += strlen(s) + 1;
s = xenstore_read(HVM_XS_SYSTEM_PRODUCT_NAME, "HVM domU");
strcpy((char *)start, s);
start += strlen(s) + 1;
s = xenstore_read(HVM_XS_SYSTEM_VERSION, xen_version);
strcpy((char *)start, s);
start += strlen(s) + 1;
uuid_to_string(uuid_str, uuid);
s = xenstore_read(HVM_XS_SYSTEM_SERIAL_NUMBER, uuid_str);
strcpy((char *)start, s);
start += strlen(s) + 1;
*((uint8_t *)start) = 0;
return start + 1;
}
/* Type 2 -- System Board */
static void *
smbios_type_2_init(void *start)
{
struct smbios_type_2 *p = start;
const char *s;
void *next;
unsigned int counter = 0;
/*
* Specification says Type 2 table has length of at least 08h,
* which corresponds with the end of the "Serial Number" field.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_2, serial_number_str) != 8);
next = smbios_pt_copy(start, 2, SMBIOS_HANDLE_TYPE2,
endof_field(struct smbios_type_2, serial_number_str));
if ( next != start )
{
/* Set current chassis handle if present */
if ( p->header.length >= endof_field(struct smbios_type_2,
chassis_handle) )
{
if ( p->chassis_handle != 0 )
p->chassis_handle = SMBIOS_HANDLE_TYPE3;
}
return next;
}
memset(p, 0, sizeof(*p));
p->header.type = 2;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE2;
p->feature_flags = 0x09; /* Board is a hosting board and replaceable */
p->chassis_handle = SMBIOS_HANDLE_TYPE3;
p->board_type = 0x0a; /* Motherboard */
start += sizeof(*p);
s = xenstore_read(HVM_XS_BASEBOARD_MANUFACTURER, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->manufacturer_str = ++counter;
}
s = xenstore_read(HVM_XS_BASEBOARD_PRODUCT_NAME, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->product_name_str = ++counter;
}
s = xenstore_read(HVM_XS_BASEBOARD_VERSION, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->version_str = ++counter;
}
s = xenstore_read(HVM_XS_BASEBOARD_SERIAL_NUMBER, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->serial_number_str = ++counter;
}
s = xenstore_read(HVM_XS_BASEBOARD_ASSET_TAG, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->asset_tag_str = ++counter;
}
s = xenstore_read(HVM_XS_BASEBOARD_LOCATION_IN_CHASSIS, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->location_in_chassis_str = ++counter;
}
if ( counter )
{
*(uint8_t *)start = 0;
return start + 1;
}
/* Only present when passed in or with customized string */
return start - sizeof(*p);
}
/* Type 3 -- System Enclosure */
static void *
smbios_type_3_init(void *start)
{
struct smbios_type_3 *p = start;
const char *s;
void *next;
uint32_t counter = 0;
/*
* Specification says Type 3 table has length of at least 0Dh (for v2.1+),
* which corresponds with the end of the "Security Status" field.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_3, security_status) != 13);
next = smbios_pt_copy(start, 3, SMBIOS_HANDLE_TYPE3,
offsetof(struct smbios_type_3, security_status));
if ( next != start )
return next;
memset(p, 0, sizeof(*p));
p->header.type = 3;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE3;
p->manufacturer_str = ++counter;
p->type = 0x01; /* other */
p->version_str = 0;
p->serial_number_str = 0;
p->asset_tag_str = 0;
p->boot_up_state = 0x03; /* safe */
p->power_supply_state = 0x03; /* safe */
p->thermal_state = 0x03; /* safe */
p->security_status = 0x02; /* unknown */
start += sizeof(*p);
s = xenstore_read(HVM_XS_ENCLOSURE_MANUFACTURER, "Xen");
strcpy((char *)start, s);
start += strlen(s) + 1;
/* No internal defaults for following ones if the value is not set */
s = xenstore_read(HVM_XS_ENCLOSURE_SERIAL_NUMBER, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy((char *)start, s);
start += strlen(s) + 1;
p->serial_number_str = ++counter;
}
s = xenstore_read(HVM_XS_ENCLOSURE_ASSET_TAG, NULL);
if ( s != NULL && *s != '\0' )
{
strcpy(start, s);
start += strlen(s) + 1;
p->asset_tag_str = ++counter;
}
*((uint8_t *)start) = 0;
return start+1;
}
/* Type 4 -- Processor Information */
static void *
smbios_type_4_init(
void *start, unsigned int cpu_number, char *cpu_manufacturer)
{
char buf[80];
struct smbios_type_4 *p = start;
uint32_t eax, ebx, ecx, edx;
/* Specification says Type 4 table has length of 23h for v2.3+. */
BUILD_BUG_ON(sizeof(*p) != 35);
memset(p, 0, sizeof(*p));
p->header.type = 4;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE4 + cpu_number;
p->socket_designation_str = 1;
p->processor_type = 0x03; /* CPU */
p->processor_family = 0x01; /* other */
p->manufacturer_str = 2;
cpuid(1, &eax, &ebx, &ecx, &edx);
p->cpuid[0] = eax;
p->cpuid[1] = edx;
p->version_str = 0;
p->voltage = 0;
p->external_clock = 0;
p->max_speed = p->current_speed = get_cpu_mhz();
p->status = 0x41; /* socket populated, CPU enabled */
p->upgrade = 0x01; /* other */
p->l1_cache_handle = 0xffff; /* No cache information structure provided. */
p->l2_cache_handle = 0xffff; /* No cache information structure provided. */
p->l3_cache_handle = 0xffff; /* No cache information structure provided. */
start += sizeof(*p);
strncpy(buf, "CPU ", sizeof(buf));
if ( (sizeof(buf) - strlen("CPU ")) >= 3 )
itoa(buf + strlen("CPU "), cpu_number);
strcpy((char *)start, buf);
start += strlen(buf) + 1;
strcpy((char *)start, cpu_manufacturer);
start += strlen(cpu_manufacturer) + 1;
*((uint8_t *)start) = 0;
return start+1;
}
/* Type 7 -- Cache Information */
static void *
smbios_type_7_init(void *start)
{
/* Specification says Type 7 table has length of 13h for v2.1+. */
BUILD_BUG_ON(sizeof(struct smbios_type_7) != 19);
/* Only present when passed in. */
return smbios_pt_copy(start, 7, SMBIOS_HANDLE_TYPE7,
sizeof(struct smbios_type_7));
}
/* Type 8 -- Port Connector Information */
static void *
smbios_type_8_init(void *start)
{
/* Specification says Type 8 table has length of 09h. */
BUILD_BUG_ON(sizeof(struct smbios_type_8) != 9);
/* Only present when passed in. */
return smbios_pt_copy(start, 8, SMBIOS_HANDLE_TYPE8,
sizeof(struct smbios_type_8));
}
/* Type 9 -- System Slots */
static void *
smbios_type_9_init(void *start)
{
/* Specification says Type 9 table has length of 0Dh for v2.1-2.5. */
BUILD_BUG_ON(sizeof(struct smbios_type_9) != 13);
/* Only present when passed in. */
return smbios_pt_copy(start, 9, SMBIOS_HANDLE_TYPE9,
sizeof(struct smbios_type_9));
}
/* Type 11 -- OEM Strings */
static void *
smbios_type_11_init(void *start)
{
struct smbios_type_11 *p = start;
char path[20];
const char *s;
void *next;
int i;
/* Specification says Type 11 table has length of 05h. */
BUILD_BUG_ON(sizeof(*p) != 5);
next = smbios_pt_copy(start, 11, SMBIOS_HANDLE_TYPE11, sizeof(*p));
if ( next != start )
return next;
p->header.type = 11;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE11;
p->count = 0;
start += sizeof(*p);
/* Pull out as many oem-* strings we find in xenstore */
for ( i = 1; i < 100; i++ )
{
snprintf(path, sizeof(path), HVM_XS_OEM_STRINGS, i);
if ( ((s = xenstore_read(path, NULL)) == NULL) || (*s == '\0') )
break;
strcpy((char *)start, s);
start += strlen(s) + 1;
p->count++;
}
/* Make sure there's at least one type-11 string */
if ( p->count == 0 )
{
strcpy((char *)start, "Xen");
start += strlen("Xen") + 1;
p->count++;
}
*((uint8_t *)start) = 0;
return start+1;
}
/* Type 16 -- Physical Memory Array */
static void *
smbios_type_16_init(void *start, uint32_t memsize, int nr_mem_devs)
{
struct smbios_type_16 *p = start;
/* Specification says Type 16 table has length of 0Fh for v2.1-2.7. */
BUILD_BUG_ON(sizeof(*p) != 15);
memset(p, 0, sizeof(*p));
p->header.type = 16;
p->header.handle = SMBIOS_HANDLE_TYPE16;
p->header.length = sizeof(*p);
p->location = 0x01; /* other */
p->use = 0x03; /* system memory */
p->error_correction = 0x06; /* Multi-bit ECC to make Microsoft happy */
p->maximum_capacity = memsize * 1024;
p->memory_error_information_handle = 0xfffe; /* none provided */
p->number_of_memory_devices = nr_mem_devs;
start += sizeof(*p);
*((uint16_t *)start) = 0;
return start + 2;
}
/* Type 17 -- Memory Device */
static void *
smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance)
{
char buf[16];
struct smbios_type_17 *p = start;
/* Specification says Type 17 table has length of 1Bh for v2.3-2.6. */
BUILD_BUG_ON(sizeof(*p) != 27);
memset(p, 0, sizeof(*p));
p->header.type = 17;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE17 + instance;
p->physical_memory_array_handle = 0x1000;
p->total_width = 64;
p->data_width = 64;
ASSERT((memory_size_mb & ~0x7fff) == 0);
p->size = memory_size_mb;
p->form_factor = 0x09; /* DIMM */
p->device_set = 0;
p->device_locator_str = 1;
p->bank_locator_str = 0;
p->memory_type = 0x07; /* RAM */
p->type_detail = 0;
start += sizeof(*p);
strcpy(start, "DIMM ");
start += strlen("DIMM ");
itoa(buf, instance);
strcpy(start, buf);
start += strlen(buf) + 1;
*((uint8_t *)start) = 0;
return start+1;
}
/* Type 19 -- Memory Array Mapped Address */
static void *
smbios_type_19_init(void *start, uint32_t memory_size_mb, int instance)
{
struct smbios_type_19 *p = start;
/* Specification says Type 19 table has length of 0Fh for v2.1-2.7. */
BUILD_BUG_ON(sizeof(*p) != 15);
memset(p, 0, sizeof(*p));
p->header.type = 19;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE19 + instance;
p->starting_address = instance << 24;
p->ending_address = p->starting_address + (memory_size_mb << 10) - 1;
p->memory_array_handle = 0x1000;
p->partition_width = 1;
start += sizeof(*p);
*((uint16_t *)start) = 0;
return start + 2;
}
/* Type 20 -- Memory Device Mapped Address */
static void *
smbios_type_20_init(void *start, uint32_t memory_size_mb, int instance)
{
struct smbios_type_20 *p = start;
/* Specification says Type 20 table has length of 13h for v2.1-2.7. */
BUILD_BUG_ON(sizeof(*p) != 19);
memset(p, 0, sizeof(*p));
p->header.type = 20;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE20 + instance;
p->starting_address = instance << 24;
p->ending_address = p->starting_address + (memory_size_mb << 10) - 1;
p->memory_device_handle = 0x1100 + instance;
p->memory_array_mapped_address_handle = 0x1300 + instance;
p->partition_row_position = 1;
p->interleave_position = 0;
p->interleaved_data_depth = 0;
start += sizeof(*p);
*((uint16_t *)start) = 0;
return start+2;
}
/* Type 22 -- Portable Battery */
static void *
smbios_type_22_init(void *start)
{
struct smbios_type_22 *p = start;
static const char *smbios_release_date = __SMBIOS_DATE__;
const char *s;
void *next;
/* Specification says Type 22 table has length of 1Ah. */
BUILD_BUG_ON(sizeof(*p) != 26);
next = smbios_pt_copy(start, 22, SMBIOS_HANDLE_TYPE22, sizeof(*p));
if ( next != start )
return next;
s = xenstore_read(HVM_XS_SMBIOS_DEFAULT_BATTERY, "0");
if ( strncmp(s, "1", 1) != 0 )
return start;
memset(p, 0, sizeof(*p));
p->header.type = 22;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE22;
p->location_str = 1;
p->manufacturer_str = 2;
p->manufacturer_date_str = 3;
p->serial_number_str = 0;
p->device_name_str = 4;
p->device_chemistry = 0x2; /* unknown */
p->device_capacity = 0; /* unknown */
p->device_voltage = 0; /* unknown */
p->sbds_version_number = 0;
p->max_error = 0xff; /* unknown */
p->sbds_serial_number = 0;
p->sbds_manufacturer_date = 0;
p->sbds_device_chemistry = 0;
p->design_capacity_multiplier = 0;
p->oem_specific = 0;
start += sizeof(*p);
strcpy((char *)start, "Primary");
start += strlen("Primary") + 1;
s = xenstore_read(HVM_XS_BATTERY_MANUFACTURER, "Xen");
strcpy((char *)start, s);
start += strlen(s) + 1;
strcpy((char *)start, smbios_release_date);
start += strlen(smbios_release_date) + 1;
s = xenstore_read(HVM_XS_BATTERY_DEVICE_NAME, "XEN-VBAT");
strcpy((char *)start, s);
start += strlen(s) + 1;
*((uint8_t *)start) = 0;
return start + 1;
}
/* Type 26 -- Voltage Probe */
static void *
smbios_type_26_init(void *start)
{
/*
* Specification says Type 26 table has length of at least 14h,
* which corresponds with the end of the "OEM-defined" field.
*
* Only present when passed in.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_26, oem_defined) != 20);
return smbios_pt_copy(start, 26, SMBIOS_HANDLE_TYPE26,
endof_field(struct smbios_type_26, oem_defined));
}
/* Type 27 -- Cooling Device */
static void *
smbios_type_27_init(void *start)
{
/*
* Specification says Type 27 table has length of at least 0Ch,
* which corresponds with the end of the "OEM-defined" field.
*
* Only present when passed in.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_27, oem_defined) != 12);
return smbios_pt_copy(start, 27, SMBIOS_HANDLE_TYPE27,
endof_field(struct smbios_type_27, oem_defined));
}
/* Type 28 -- Temperature Probe */
static void *
smbios_type_28_init(void *start)
{
/*
* Specification says Type 28 table has length of at least 14h,
* which corresponds with the end of the "OEM-defined" field.
*
* Only present when passed in.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_28, oem_defined) != 20);
return smbios_pt_copy(start, 28, SMBIOS_HANDLE_TYPE28,
endof_field(struct smbios_type_28, oem_defined));
}
/* Type 32 -- System Boot Information */
static void *
smbios_type_32_init(void *start)
{
struct smbios_type_32 *p = start;
/* Specification says Type 32 table has length of at least 0Bh. */
BUILD_BUG_ON(sizeof(*p) != 11);
memset(p, 0, sizeof(*p));
p->header.type = 32;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE32;
memset(p->reserved, 0, 6);
p->boot_status = 0; /* no errors detected */
start += sizeof(*p);
*((uint16_t *)start) = 0;
return start+2;
}
/* Type 39 -- Power Supply */
static void *
smbios_type_39_init(void *start)
{
/*
* Specification says Type 39 table has length of at least 10h,
* which corresponds with the end of the "Characteristics" field.
*
* Only present when passed in.
*/
BUILD_BUG_ON(endof_field(struct smbios_type_39, characteristics) != 16);
return smbios_pt_copy(start, 39, SMBIOS_HANDLE_TYPE39,
endof_field(struct smbios_type_39, characteristics));
}
static void *
smbios_type_vendor_oem_init(void *start)
{
uint32_t *sep = smbios_pt_addr;
uint32_t total = 0;
uint8_t *ptr;
if ( sep == NULL )
return start;
while ( total < smbios_pt_length )
{
ptr = (uint8_t*)(sep + 1);
if ( ptr[0] >= 128 )
{
/* Vendor/OEM table, copy it in. Note the handle values cannot
* be changed since it is unknown what is in each of these tables
* but they could contain handle references to other tables. This
* means a slight risk of collision with the tables above but that
* would have to be dealt with on a case by case basis.
*/
memcpy(start, ptr, *sep);
start += *sep;
}
total += (*sep + sizeof(uint32_t));
sep = (uint32_t*)(ptr + *sep);
}
return start;
}
/* Type 127 -- End of Table */
static void *
smbios_type_127_init(void *start)
{
struct smbios_type_127 *p = start;
memset(p, 0, sizeof(*p));
p->header.type = 127;
p->header.length = sizeof(*p);
p->header.handle = SMBIOS_HANDLE_TYPE127;
start += sizeof(*p);
*((uint16_t *)start) = 0;
return start + 2;
}
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/
Reference in new issue View Git Blame Copy Permalink