From: Julia Suvorova <jusual@redhat.com>

Date: Tue, 11 Oct 2022 13:17:28 +0200

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

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>

(cherry picked from commit 33bff4a85a2e4ad94899ecb15b6a91c8b64a6dcf)

References: bsc#1202282, jsc#PED-2592

Signed-off-by: Dario Faggioli <dfaggioli@suse.com>

---

 tests/qtest/bios-tables-test.c | 100 +++++++++++++++++++++++++--------

 1 file changed, 76 insertions(+), 24 deletions(-)

diff --git a/tests/qtest/bios-tables-test.c b/tests/qtest/bios-tables-test.c

index 7c5f736b513abbda7803afb2d28f..dcda3c508a77854415dad76998cc 100644

--- a/tests/qtest/bios-tables-test.c

+++ b/tests/qtest/bios-tables-test.c

@@ -88,8 +88,8 @@ typedef struct {

     uint64_t rsdp_addr;

     uint8_t rsdp_table[36 /* ACPI 2.0+ RSDP size */];

     GArray *tables;

-    uint32_t smbios_ep_addr;

-    struct smbios_21_entry_point smbios_ep_table;

+    uint64_t smbios_ep_addr[SMBIOS_ENTRY_POINT_TYPE__MAX];

+    SmbiosEntryPoint smbios_ep_table;

     uint16_t smbios_cpu_max_speed;

     uint16_t smbios_cpu_curr_speed;

     uint8_t *required_struct_types;

@@ -533,10 +533,9 @@ static void test_acpi_asl(test_data *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;

-    uint32_t addr = data->smbios_ep_addr;

+    struct smbios_21_entry_point *ep_table = &data->smbios_ep_table.ep21;

     qtest_memread(data->qts, addr, ep_table, sizeof(*ep_table));

     if (memcmp(ep_table->anchor_string, "_SM_", 4)) {

@@ -559,13 +558,29 @@ static bool smbios_ep_table_ok(test_data *data)

     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;

     /* find smbios entry point structure */

     for (off = 0xf0000; off < 0x100000; off += 0x10) {

-        uint8_t sig[] = "_SM_";

+        uint8_t sig[] = "_SM_", sig3[] = "_SM3_";

         int 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)) {

             /* signature match, but is this a valid entry point? */

-            data->smbios_ep_addr = off;

-            if (smbios_ep_table_ok(data)) {

+            if (smbios_ep2_table_ok(data, off)) {

+                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;

             }

         }

     }

-    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)

@@ -625,16 +656,23 @@ static bool smbios_cpu_test(test_data *data, uint32_t addr)

     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 };

-    struct smbios_21_entry_point *ep_table = &data->smbios_ep_table;

-    uint32_t addr = le32_to_cpu(ep_table->structure_table_address);

-    int i, len, max_len = 0;

+

+    SmbiosEntryPoint *ep_table = &data->smbios_ep_table;

+    int i = 0, len, max_len = 0;

     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 */

-    for (i = 0; i < le16_to_cpu(ep_table->number_of_structures); i++) {

+    do {

         /* grab type and formatted area length from struct header */

         type = qtest_readb(data->qts, addr);

@@ -660,19 +698,33 @@ static void test_smbios_structs(test_data *data)

         }

         /* keep track of max. struct size */

-        if (max_len < len) {

+        if (ep_type == SMBIOS_ENTRY_POINT_TYPE_32 && 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 */

         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), ==,

-                     addr - le32_to_cpu(ep_table->structure_table_address));

-    g_assert_cmpuint(le16_to_cpu(ep_table->max_structure_size), ==, max_len);

+    /*

+     * Until all structures have been scanned (ep21)

+     * or an EOF structure is found (ep30)

+     */

+    } 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 */

     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

      */

     if (!use_uefi) {

-        test_smbios_entry_point(data);

-        test_smbios_structs(data);

+        SmbiosEntryPointType ep_type = test_smbios_entry_point(data);

+        test_smbios_structs(data, ep_type);

     }

     qtest_quit(data->qts);