x86: qemu: add the ability to load and link ACPI tables from QEMU

This patch adds the ability to load and link ACPI tables provided by QEMU.
QEMU tells guests how to load and patch ACPI tables through its fw_cfg
interface, by adding a firmware file 'etc/table-loader'. Guests are
supposed to parse this file and execute corresponding QEMU commands.

Signed-off-by: Miao Yan <yanmiaobest@gmail.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>

diff --git a/arch/x86/cpu/qemu/Makefile b/arch/x86/cpu/qemu/Makefile
index 176ea54ae4ef831b6d5b93661ab67d99e837503a..801413a1cb1478f49fb2caa4094793556a8625e0 100644 (file)
--- a/arch/x86/cpu/qemu/Makefile
+++ b/arch/x86/cpu/qemu/Makefile
@@ -8,4 +8,6 @@ ifndef CONFIG_EFI_STUB
 obj-y += car.o dram.o
 endif
 obj-y += cpu.o fw_cfg.o qemu.o
+ifndef CONFIG_QEMU_ACPI_TABLE
 obj-$(CONFIG_GENERATE_ACPI_TABLE) += acpi.o dsdt.o
+endif

diff --git a/arch/x86/cpu/qemu/fw_cfg.c b/arch/x86/cpu/qemu/fw_cfg.c
index bcd34afe06bc8a9b3aa396689db60bdc43d7da84..5ea7a6e2e539c53b15801969b84ed908d80f1c31 100644 (file)
--- a/arch/x86/cpu/qemu/fw_cfg.c
+++ b/arch/x86/cpu/qemu/fw_cfg.c
@@ -10,7 +10,10 @@
 #include <malloc.h>
 #include <asm/io.h>
 #include <asm/fw_cfg.h>
+#include <asm/tables.h>
+#include <asm/e820.h>
 #include <linux/list.h>
+#include <memalign.h>
 
 static bool fwcfg_present;
 static bool fwcfg_dma_present;
@@ -204,6 +207,256 @@ err:
        return -ENOMEM;
 }
 
+#ifdef CONFIG_QEMU_ACPI_TABLE
+static struct fw_file *qemu_fwcfg_find_file(const char *name)
+{
+       struct list_head *entry;
+       struct fw_file *file;
+
+       list_for_each(entry, &fw_list) {
+               file = list_entry(entry, struct fw_file, list);
+               if (!strcmp(file->cfg.name, name))
+                       return file;
+       }
+
+       return NULL;
+}
+
+/*
+ * This function allocates memory for ACPI tables
+ *
+ * @entry : BIOS linker command entry which tells where to allocate memory
+ *          (either high memory or low memory)
+ * @addr  : The address that should be used for low memory allcation. If the
+ *          memory allocation request is 'ZONE_HIGH' then this parameter will
+ *          be ignored.
+ * @return: 0 on success, or negative value on failure
+ */
+static int bios_linker_allocate(struct bios_linker_entry *entry,
+                          unsigned long *addr)
+{
+       uint32_t size, align;
+       struct fw_file *file;
+       unsigned long aligned_addr;
+
+       align = le32_to_cpu(entry->alloc.align);
+       /* align must be power of 2 */
+       if (align & (align - 1)) {
+               printf("error: wrong alignment %u\n", align);
+               return -EINVAL;
+       }
+
+       file = qemu_fwcfg_find_file(entry->alloc.file);
+       if (!file) {
+               printf("error: can't find file %s\n", entry->alloc.file);
+               return -ENOENT;
+       }
+
+       size = be32_to_cpu(file->cfg.size);
+
+       /*
+        * ZONE_HIGH means we need to allocate from high memory, since
+        * malloc space is already at the end of RAM, so we directly use it.
+        * If allocation zone is ZONE_FSEG, then we use the 'addr' passed
+        * in which is low memory
+        */
+       if (entry->alloc.zone == BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH) {
+               aligned_addr = (unsigned long)memalign(align, size);
+               if (!aligned_addr) {
+                       printf("error: allocating resource\n");
+                       return -ENOMEM;
+               }
+       } else if (entry->alloc.zone == BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG) {
+               aligned_addr = ALIGN(*addr, align);
+       } else {
+               printf("error: invalid allocation zone\n");
+               return -EINVAL;
+       }
+
+       debug("bios_linker_allocate: allocate file %s, size %u, zone %d, align %u, addr 0x%lx\n",
+             file->cfg.name, size, entry->alloc.zone, align, aligned_addr);
+
+       qemu_fwcfg_read_entry(be16_to_cpu(file->cfg.select),
+                             size, (void *)aligned_addr);
+       file->addr = aligned_addr;
+
+       /* adjust address for low memory allocation */
+       if (entry->alloc.zone == BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG)
+               *addr = (aligned_addr + size);
+
+       return 0;
+}
+
+/*
+ * This function patches ACPI tables previously loaded
+ * by bios_linker_allocate()
+ *
+ * @entry : BIOS linker command entry which tells how to patch
+ *          ACPI tables
+ * @return: 0 on success, or negative value on failure
+ */
+static int bios_linker_add_pointer(struct bios_linker_entry *entry)
+{
+       struct fw_file *dest, *src;
+       uint32_t offset = le32_to_cpu(entry->pointer.offset);
+       uint64_t pointer = 0;
+
+       dest = qemu_fwcfg_find_file(entry->pointer.dest_file);
+       if (!dest || !dest->addr)
+               return -ENOENT;
+       src = qemu_fwcfg_find_file(entry->pointer.src_file);
+       if (!src || !src->addr)
+               return -ENOENT;
+
+       debug("bios_linker_add_pointer: dest->addr 0x%lx, src->addr 0x%lx, offset 0x%x size %u, 0x%llx\n",
+             dest->addr, src->addr, offset, entry->pointer.size, pointer);
+
+       memcpy(&pointer, (char *)dest->addr + offset, entry->pointer.size);
+       pointer = le64_to_cpu(pointer);
+       pointer += (unsigned long)src->addr;
+       pointer = cpu_to_le64(pointer);
+       memcpy((char *)dest->addr + offset, &pointer, entry->pointer.size);
+
+       return 0;
+}
+
+/*
+ * This function updates checksum fields of ACPI tables previously loaded
+ * by bios_linker_allocate()
+ *
+ * @entry : BIOS linker command entry which tells where to update ACPI table
+ *          checksums
+ * @return: 0 on success, or negative value on failure
+ */
+static int bios_linker_add_checksum(struct bios_linker_entry *entry)
+{
+       struct fw_file *file;
+       uint8_t *data, cksum = 0;
+       uint8_t *cksum_start;
+
+       file = qemu_fwcfg_find_file(entry->cksum.file);
+       if (!file || !file->addr)
+               return -ENOENT;
+
+       data = (uint8_t *)(file->addr + le32_to_cpu(entry->cksum.offset));
+       cksum_start = (uint8_t *)(file->addr + le32_to_cpu(entry->cksum.start));
+       cksum = table_compute_checksum(cksum_start,
+                                      le32_to_cpu(entry->cksum.length));
+       *data = cksum;
+
+       return 0;
+}
+
+unsigned install_e820_map(unsigned max_entries, struct e820entry *entries)
+{
+       entries[0].addr = 0;
+       entries[0].size = ISA_START_ADDRESS;
+       entries[0].type = E820_RAM;
+
+       entries[1].addr = ISA_START_ADDRESS;
+       entries[1].size = ISA_END_ADDRESS - ISA_START_ADDRESS;
+       entries[1].type = E820_RESERVED;
+
+       /*
+        * since we use memalign(malloc) to allocate high memory for
+        * storing ACPI tables, we need to reserve them in e820 tables,
+        * otherwise kernel will reclaim them and data will be corrupted
+        */
+       entries[2].addr = ISA_END_ADDRESS;
+       entries[2].size = gd->relocaddr - TOTAL_MALLOC_LEN - ISA_END_ADDRESS;
+       entries[2].type = E820_RAM;
+
+       /* for simplicity, reserve entire malloc space */
+       entries[3].addr = gd->relocaddr - TOTAL_MALLOC_LEN;
+       entries[3].size = TOTAL_MALLOC_LEN;
+       entries[3].type = E820_RESERVED;
+
+       entries[4].addr = gd->relocaddr;
+       entries[4].size = gd->ram_size - gd->relocaddr;
+       entries[4].type = E820_RESERVED;
+
+       entries[5].addr = CONFIG_PCIE_ECAM_BASE;
+       entries[5].size = CONFIG_PCIE_ECAM_SIZE;
+       entries[5].type = E820_RESERVED;
+
+       return 6;
+}
+
+/* This function loads and patches ACPI tables provided by QEMU */
+unsigned long write_acpi_tables(unsigned long addr)
+{
+       int i, ret = 0;
+       struct fw_file *file;
+       struct bios_linker_entry *table_loader;
+       struct bios_linker_entry *entry;
+       uint32_t size;
+       struct list_head *list;
+
+       /* make sure fw_list is loaded */
+       ret = qemu_fwcfg_read_firmware_list();
+       if (ret) {
+               printf("error: can't read firmware file list\n");
+               return addr;
+       }
+
+       file = qemu_fwcfg_find_file("etc/table-loader");
+       if (!file) {
+               printf("error: can't find etc/table-loader\n");
+               return addr;
+       }
+
+       size = be32_to_cpu(file->cfg.size);
+       if ((size % sizeof(*entry)) != 0) {
+               printf("error: table-loader maybe corrupted\n");
+               return addr;
+       }
+
+       table_loader = malloc(size);
+       if (!table_loader) {
+               printf("error: no memory for table-loader\n");
+               return addr;
+       }
+
+       qemu_fwcfg_read_entry(be16_to_cpu(file->cfg.select),
+                             size, table_loader);
+
+       for (i = 0; i < (size / sizeof(*entry)); i++) {
+               entry = table_loader + i;
+               switch (le32_to_cpu(entry->command)) {
+               case BIOS_LINKER_LOADER_COMMAND_ALLOCATE:
+                       ret = bios_linker_allocate(entry, &addr);
+                       if (ret)
+                               goto out;
+                       break;
+               case BIOS_LINKER_LOADER_COMMAND_ADD_POINTER:
+                       ret = bios_linker_add_pointer(entry);
+                       if (ret)
+                               goto out;
+                       break;
+               case BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM:
+                       ret = bios_linker_add_checksum(entry);
+                       if (ret)
+                               goto out;
+                       break;
+               default:
+                       break;
+               }
+       }
+
+out:
+       if (ret) {
+               list_for_each(list, &fw_list) {
+                       file = list_entry(list, struct fw_file, list);
+                       if (file->addr)
+                               free((void *)file->addr);
+               }
+       }
+
+       free(table_loader);
+       return addr;
+}
+#endif
+
 static int qemu_fwcfg_list_firmware(void)
 {
        int ret;

diff --git a/arch/x86/include/asm/fw_cfg.h b/arch/x86/include/asm/fw_cfg.h
index 2acf43eb8163645ec93e08b55ecc23b40f2efbd4..e9450c619687f246fdb5f6d2d46305ab06751cb2 100644 (file)
--- a/arch/x86/include/asm/fw_cfg.h
+++ b/arch/x86/include/asm/fw_cfg.h
@@ -47,11 +47,23 @@ enum qemu_fwcfg_items {
        FW_CFG_INVALID          = 0xffff,
 };
 
+enum {
+       BIOS_LINKER_LOADER_COMMAND_ALLOCATE     = 0x1,
+       BIOS_LINKER_LOADER_COMMAND_ADD_POINTER  = 0x2,
+       BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM = 0x3,
+};
+
+enum {
+       BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH = 0x1,
+       BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG = 0x2,
+};
+
 #define FW_CFG_FILE_SLOTS      0x10
 #define FW_CFG_MAX_ENTRY       (FW_CFG_FILE_FIRST + FW_CFG_FILE_SLOTS)
 #define FW_CFG_ENTRY_MASK       ~(FW_CFG_WRITE_CHANNEL | FW_CFG_ARCH_LOCAL)
 
 #define FW_CFG_MAX_FILE_PATH   56
+#define BIOS_LINKER_LOADER_FILESZ FW_CFG_MAX_FILE_PATH
 
 #define QEMU_FW_CFG_SIGNATURE  (('Q' << 24) | ('E' << 16) | ('M' << 8) | 'U')
 
@@ -81,6 +93,55 @@ struct fw_cfg_dma_access {
        __be64 address;
 };
 
+struct bios_linker_entry {
+       __le32 command;
+       union {
+               /*
+                * COMMAND_ALLOCATE - allocate a table from @alloc.file
+                * subject to @alloc.align alignment (must be power of 2)
+                * and @alloc.zone (can be HIGH or FSEG) requirements.
+                *
+                * Must appear exactly once for each file, and before
+                * this file is referenced by any other command.
+                */
+               struct {
+                       char file[BIOS_LINKER_LOADER_FILESZ];
+                       __le32 align;
+                       uint8_t zone;
+               } alloc;
+
+               /*
+                * COMMAND_ADD_POINTER - patch the table (originating from
+                * @dest_file) at @pointer.offset, by adding a pointer to the
+                * table originating from @src_file. 1,2,4 or 8 byte unsigned
+                * addition is used depending on @pointer.size.
+                */
+               struct {
+                       char dest_file[BIOS_LINKER_LOADER_FILESZ];
+                       char src_file[BIOS_LINKER_LOADER_FILESZ];
+                       __le32 offset;
+                       uint8_t size;
+               } pointer;
+
+               /*
+                * COMMAND_ADD_CHECKSUM - calculate checksum of the range
+                * specified by @cksum_start and @cksum_length fields,
+                * and then add the value at @cksum.offset.
+                * Checksum simply sums -X for each byte X in the range
+                * using 8-bit math.
+                */
+               struct {
+                       char file[BIOS_LINKER_LOADER_FILESZ];
+                       __le32 offset;
+                       __le32 start;
+                       __le32 length;
+               } cksum;
+
+               /* padding */
+               char pad[124];
+       };
+} __packed;
+
 /**
  * Initialize QEMU fw_cfg interface
  */

diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile
index d9fc296b6e4877a1a3b3a8766fe7d54f6ac54d67..50bc69a659f078ad8a0ec022d0083bcab9d4444d 100644 (file)
--- a/arch/x86/lib/Makefile
+++ b/arch/x86/lib/Makefile
@@ -32,7 +32,9 @@ obj-$(CONFIG_X86_RAMTEST) += ramtest.o
 obj-y += sfi.o
 obj-$(CONFIG_GENERATE_SMBIOS_TABLE) += smbios.o
 obj-y  += string.o
+ifndef CONFIG_QEMU_ACPI_TABLE
 obj-$(CONFIG_GENERATE_ACPI_TABLE) += acpi_table.o
+endif
 obj-y  += tables.o
 obj-$(CONFIG_CMD_ZBOOT)        += zimage.o
 obj-$(CONFIG_HAVE_FSP) += fsp/

diff --git a/arch/x86/lib/acpi_table.c b/arch/x86/lib/acpi_table.c
index ab1db7ec26eee8e08aabf101aa4add678415e5da..2ec5ad2fa4a0d11f7b56984036d739c50ccb63c3 100644 (file)
--- a/arch/x86/lib/acpi_table.c
+++ b/arch/x86/lib/acpi_table.c
@@ -331,6 +331,10 @@ static void acpi_create_ssdt_generator(acpi_header_t *ssdt,
        ssdt->checksum = table_compute_checksum((void *)ssdt, ssdt->length);
 }
 
+/*
+ * QEMU's version of write_acpi_tables is defined in
+ * arch/x86/cpu/qemu/fw_cfg.c
+ */
 unsigned long write_acpi_tables(unsigned long start)
 {
        unsigned long current;