motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-08 02:03:56 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

bios-tables-test: teach test to use smbios 3.0 tables

Browse source 
Introduce the 64-bit entry point. Since we no longer have a total
number of structures, stop checking for the new ones at the EOF
structure (type 127).

Signed-off-by: Julia Suvorova <jusual@redhat.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20220731162141.178443-3-jusual@redhat.com>
Message-Id: <20221011111731.101412-3-jusual@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Julia Suvorova 2022-10-11 13:17:28 +02:00 • committed by Michael S. Tsirkin
parent 05e27d74c7
commit 33bff4a85a
1 changed files with 76 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

100
tests/qtest/bios-tables-test.c
View file

@ -88,8 +88,8 @@ typedef struct {
uint64_t rsdp_addr; uint64_t rsdp_addr;
uint8_t rsdp_table[36 /* ACPI 2.0+ RSDP size */]; uint8_t rsdp_table[36 /* ACPI 2.0+ RSDP size */];
GArray *tables; GArray *tables;
uint32_t smbios_ep_addr; uint64_t smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE__MAX];
struct smbios_21_entry_point smbios_ep_table; SmbiosEntryPoint smbios_ep_table;
uint16_t smbios_cpu_max_speed; uint16_t smbios_cpu_max_speed;
uint16_t smbios_cpu_curr_speed; uint16_t smbios_cpu_curr_speed;
uint8_t *required_struct_types; uint8_t *required_struct_types;
@ -533,10 +533,9 @@ static void test_acpi_asl(test_data *data)
free_test_data(&exp_data); free_test_data(&exp_data);
} }
static bool smbios_ep_table_ok(test_data *data) static bool smbios_ep2_table_ok(test_data *data, uint32_t addr)
{ {
struct smbios_21_entry_point *ep_table = &data->smbios_ep_table; struct smbios_21_entry_point *ep_table = &data->smbios_ep_table.ep21;
uint32_t addr = data->smbios_ep_addr;
qtest_memread(data->qts, addr, ep_table, sizeof(*ep_table)); qtest_memread(data->qts, addr, ep_table, sizeof(*ep_table));
if (memcmp(ep_table->anchor_string, "_SM_", 4)) { if (memcmp(ep_table->anchor_string, "_SM_", 4)) {
@ -559,13 +558,29 @@ static bool smbios_ep_table_ok(test_data *data)
return true; return true;
} }
static void test_smbios_entry_point(test_data *data) static bool smbios_ep3_table_ok(test_data *data, uint64_t addr)
{
struct smbios_30_entry_point *ep_table = &data->smbios_ep_table.ep30;
qtest_memread(data->qts, addr, ep_table, sizeof(*ep_table));
if (memcmp(ep_table->anchor_string, "_SM3_", 5)) {
return false;
}
if (acpi_calc_checksum((uint8_t *)ep_table, sizeof *ep_table)) {
return false;
}
return true;
}
static SmbiosEntryPointType test_smbios_entry_point(test_data *data)
{ {
uint32_t off; uint32_t off;
/* find smbios entry point structure */ /* find smbios entry point structure */
for (off = 0xf0000; off < 0x100000; off += 0x10) { for (off = 0xf0000; off < 0x100000; off += 0x10) {
uint8_t sig[] = "_SM_"; uint8_t sig[] = "_SM_", sig3[] = "_SM3_";
int i; int i;
for (i = 0; i < sizeof sig - 1; ++i) { for (i = 0; i < sizeof sig - 1; ++i) {
@ -574,14 +589,30 @@ static void test_smbios_entry_point(test_data *data)
if (!memcmp(sig, "_SM_", sizeof sig)) { if (!memcmp(sig, "_SM_", sizeof sig)) {
/* signature match, but is this a valid entry point? */ /* signature match, but is this a valid entry point? */
data->smbios_ep_addr = off; if (smbios_ep2_table_ok(data, off)) {
if (smbios_ep_table_ok(data)) { data->smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE_32] = off;
}
}
for (i = 0; i < sizeof sig3 - 1; ++i) {
sig3[i] = qtest_readb(data->qts, off + i);
}
if (!memcmp(sig3, "_SM3_", sizeof sig3)) {
if (smbios_ep3_table_ok(data, off)) {
data->smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE_64] = off;
/* found 64-bit entry point, no need to look for 32-bit one */
break; break;
} }
} }
} }
g_assert_cmphex(off, <, 0x100000); /* found at least one entry point */
g_assert_true(data->smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE_32] ||
data->smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE_64]);
return data->smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE_64] ?
SMBIOS_ENTRY_POINT_TYPE_64 : SMBIOS_ENTRY_POINT_TYPE_32;
} }
static inline bool smbios_single_instance(uint8_t type) static inline bool smbios_single_instance(uint8_t type)
@ -625,16 +656,23 @@ static bool smbios_cpu_test(test_data *data, uint32_t addr)
return true; return true;
} }
static void test_smbios_structs(test_data *data) static void test_smbios_structs(test_data *data, SmbiosEntryPointType ep_type)
{ {
DECLARE_BITMAP(struct_bitmap, SMBIOS_MAX_TYPE+1) = { 0 }; DECLARE_BITMAP(struct_bitmap, SMBIOS_MAX_TYPE+1) = { 0 };
struct smbios_21_entry_point *ep_table = &data->smbios_ep_table;
uint32_t addr = le32_to_cpu(ep_table->structure_table_address); SmbiosEntryPoint *ep_table = &data->smbios_ep_table;
int i, len, max_len = 0; int i = 0, len, max_len = 0;
uint8_t type, prv, crt; uint8_t type, prv, crt;
uint64_t addr;
if (ep_type == SMBIOS_ENTRY_POINT_TYPE_32) {
addr = le32_to_cpu(ep_table->ep21.structure_table_address);
} else {
addr = le64_to_cpu(ep_table->ep30.structure_table_address);
}
/* walk the smbios tables */ /* walk the smbios tables */
for (i = 0; i < le16_to_cpu(ep_table->number_of_structures); i++) { do {
/* grab type and formatted area length from struct header */ /* grab type and formatted area length from struct header */
type = qtest_readb(data->qts, addr); type = qtest_readb(data->qts, addr);
@ -660,19 +698,33 @@ static void test_smbios_structs(test_data *data)
} }
/* keep track of max. struct size */ /* keep track of max. struct size */
if (max_len < len) { if (ep_type == SMBIOS_ENTRY_POINT_TYPE_32 && max_len < len) {
max_len = len; max_len = len;
g_assert_cmpuint(max_len, <=, ep_table->max_structure_size); g_assert_cmpuint(max_len, <=, ep_table->ep21.max_structure_size);
} }
/* start of next structure */ /* start of next structure */
addr += len; addr += len;
}
/* total table length and max struct size must match entry point values */ /*
g_assert_cmpuint(le16_to_cpu(ep_table->structure_table_length), ==, * Until all structures have been scanned (ep21)
addr - le32_to_cpu(ep_table->structure_table_address)); * or an EOF structure is found (ep30)
g_assert_cmpuint(le16_to_cpu(ep_table->max_structure_size), ==, max_len); */
} while (ep_type == SMBIOS_ENTRY_POINT_TYPE_32 ?
++i < le16_to_cpu(ep_table->ep21.number_of_structures) :
type != 127);
if (ep_type == SMBIOS_ENTRY_POINT_TYPE_32) {
/*
* Total table length and max struct size
* must match entry point values
*/
g_assert_cmpuint(le16_to_cpu(ep_table->ep21.structure_table_length), ==,
addr - le32_to_cpu(ep_table->ep21.structure_table_address));
g_assert_cmpuint(le16_to_cpu(ep_table->ep21.max_structure_size), ==,
max_len);
}
/* required struct types must all be present */ /* required struct types must all be present */
for (i = 0; i < data->required_struct_types_len; i++) { for (i = 0; i < data->required_struct_types_len; i++) {
@ -756,8 +808,8 @@ static void test_acpi_one(const char *params, test_data *data)
* https://bugs.launchpad.net/qemu/+bug/1821884 * https://bugs.launchpad.net/qemu/+bug/1821884
*/ */
if (!use_uefi) { if (!use_uefi) {
test_smbios_entry_point(data); SmbiosEntryPointType ep_type = test_smbios_entry_point(data);
test_smbios_structs(data); test_smbios_structs(data, ep_type);
} }
qtest_quit(data->qts); qtest_quit(data->qts);