ACPI reorganization for hardware-reduced support

ACPI tables are platform and machine type and even architecture agnostic, and as such we want to provide an internal ACPI API that only depends on platform agnostic information.

For the x86 architecture, in order to build ACPI tables independently from the PC or Q35 machine types, we are moving a few MachineState structure fields into a machine type agnostic structure called AcpiConfiguration. The structure fields we move are:

HotplugHandler *acpi_dev AcpiNVDIMMState acpi_nvdimm_state; FWCfgState *fw_cfg
ram_addr_t below_4g_mem_size, above_4g_mem_size bool apic_xrupt_override
unsigned apic_id_limit
uint64_t numa_nodes
uint64_t numa_mem

Signed-off-by Samuel Ortiz <[email protected]>

---
  hw/acpi/cpu_hotplug.c    |   9 +-
  hw/arm/virt-acpi-build.c |  10 ---
  hw/i386/acpi-build.c     | 135 ++++++++++++++----------------
  hw/i386/acpi-build.h     |   4 +-
  hw/i386/pc.c             | 175 ++++++++++++++++++++++++---------------
  hw/i386/pc_piix.c        |  21 ++---
  hw/i386/pc_q35.c         |  21 ++---
  hw/i386/xen/xen-hvm.c    |  19 +++--
  include/hw/acpi/acpi.h   |  43 ++++++++++
  include/hw/i386/pc.h     |  19 ++---
  10 files changed, 254 insertions(+), 202 deletions(-)

hw/acpi/cpu_hotplug.c +5 -4

index 5243918125..634dc3b846 100644
@@ -237,9 +237,9 @@ void build_legacy_cpu_hotplug_aml(Aml *ctx, MachineState *machine,
      /* The current AML generator can cover the APIC ID range [0..255],
       * inclusive, for VCPU hotplug. */
      QEMU_BUILD_BUG_ON(ACPI_CPU_HOTPLUG_ID_LIMIT > 256);
-    if (pcms->apic_id_limit > ACPI_CPU_HOTPLUG_ID_LIMIT) {
+    if (pcms->acpi_configuration.apic_id_limit > ACPI_CPU_HOTPLUG_ID_LIMIT) {
          error_report("max_cpus is too large. APIC ID of last CPU is %u",
-                     pcms->apic_id_limit - 1);
+                     pcms->acpi_configuration.apic_id_limit - 1);
          exit(1);
      }
 

@@ -316,8 +316,9 @@ void build_legacy_cpu_hotplug_aml(Aml *ctx, MachineState *machine,
       * ith up to 255 elements. Windows guests up to win2k8 fail when
       * VarPackageOp is used.
       */
-    pkg = pcms->apic_id_limit <= 255 ? aml_package(pcms->apic_id_limit) :
-                                       aml_varpackage(pcms->apic_id_limit);
+    pkg = pcms->acpi_configuration.apic_id_limit <= 255 ?
+        aml_package(pcms->acpi_configuration.apic_id_limit) :
+        aml_varpackage(pcms->acpi_configuration.apic_id_limit);
 
      for (i = 0, apic_idx = 0; i < apic_ids->len; i++) {
          int apic_id = apic_ids->cpus[i].arch_id;

hw/arm/virt-acpi-build.c +0 -10

index 5785fb697c..f28a2faa53 100644
@@ -790,16 +790,6 @@ build_dsdt(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms)
      free_aml_allocator();
  }
 
-typedef
-struct AcpiBuildState {
-    /* Copy of table in RAM (for patching). */
-    MemoryRegion *table_mr;
-    MemoryRegion *rsdp_mr;
-    MemoryRegion *linker_mr;
-    /* Is table patched? */
-    bool patched;
-} AcpiBuildState;
-
  static
  void virt_acpi_build(VirtMachineState *vms, AcpiBuildTables *tables)
  {

hw/i386/acpi-build.c +0 -0

index 1599caa7c5..c8545238c4 100644

hw/i386/acpi-build.c +58 -74

  {
-    MachineClass *mc = MACHINE_GET_CLASS(pcms);
-    const CPUArchIdList *apic_ids = mc->possible_cpu_arch_ids(MACHINE(pcms));
+    MachineClass *mc = MACHINE_GET_CLASS(ms);
+    const CPUArchIdList *apic_ids = mc->possible_cpu_arch_ids(ms);
      int madt_start = table_data->len;
-    AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(pcms->acpi_dev);
-    AcpiDeviceIf *adev = ACPI_DEVICE_IF(pcms->acpi_dev);
+    AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(conf->acpi_dev);
+    AcpiDeviceIf *adev = ACPI_DEVICE_IF(conf->acpi_dev);
      bool x2apic_mode = false;
 
      AcpiMultipleApicTable *madt;

@@ -370,7 +371,7 @@ build_madt(GArray *table_data, BIOSLinker *linker, PCMachineState *pcms)
      io_apic->address = cpu_to_le32(IO_APIC_DEFAULT_ADDRESS);
      io_apic->interrupt = cpu_to_le32(0);
 
-    if (pcms->apic_xrupt_override) {
+    if (conf->apic_xrupt_override) {
          intsrcovr = acpi_data_push(table_data, sizeof *intsrcovr);
          intsrcovr->type   = ACPI_APIC_XRUPT_OVERRIDE;
          intsrcovr->length = sizeof(*intsrcovr);

@@ -1786,13 +1787,12 @@ static Aml *build_q35_osc_method(void)
  static void
  build_dsdt(GArray *table_data, BIOSLinker *linker,
             AcpiPmInfo *pm, AcpiMiscInfo *misc,
-           Range *pci_hole, Range *pci_hole64, MachineState *machine)
+           Range *pci_hole, Range *pci_hole64,
+           MachineState *machine, AcpiConfiguration *conf)
  {
      CrsRangeEntry *entry;
      Aml *dsdt, *sb_scope, *scope, *dev, *method, *field, *pkg, *crs;
      CrsRangeSet crs_range_set;
-    PCMachineState *pcms = PC_MACHINE(machine);
-    PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(machine);
      uint32_t nr_mem = machine->ram_slots;
      int root_bus_limit = 0xFF;
      PCIBus *bus = NULL;

@@ -1836,7 +1836,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker,
          build_q35_pci0_int(dsdt);
      }
 
-    if (pcmc->legacy_cpu_hotplug) {
+    if (conf->legacy_cpu_hotplug) {
          build_legacy_cpu_hotplug_aml(dsdt, machine, pm->cpu_hp_io_base);
      } else {
          CPUHotplugFeatures opts = {

@@ -1860,7 +1860,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker,
              aml_append(scope, method);
          }
 
-        if (pcms->acpi_nvdimm_state.is_enabled) {
+        if (conf->acpi_nvdimm_state.is_enabled) {
              method = aml_method("_E04", 0, AML_NOTSERIALIZED);
              aml_append(method, aml_notify(aml_name("\\_SB.NVDR"),
                                            aml_int(0x80)));

@@ -2041,7 +2041,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker,
           * with half of the 16-bit control register. Hence, the total size
           * of the i/o region used is FW_CFG_CTL_SIZE; when using DMA, the
           * DMA control register is located at FW_CFG_DMA_IO_BASE + 4 */
-        uint8_t io_size = object_property_get_bool(OBJECT(pcms->fw_cfg),
+        uint8_t io_size = object_property_get_bool(OBJECT(conf->fw_cfg),
                                                     "dma_enabled", NULL) ?
                            ROUND_UP(FW_CFG_CTL_SIZE, 4) + sizeof(dma_addr_t) :
                            FW_CFG_CTL_SIZE;

@@ -2252,7 +2252,8 @@ build_tpm2(GArray *table_data, BIOSLinker *linker, GArray *tcpalog)
  #define HOLE_640K_END   (1 * MiB)
 
  static void
-build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
+build_srat(GArray *table_data, BIOSLinker *linker,
+           MachineState *machine, AcpiConfiguration *conf)
  {
      AcpiSystemResourceAffinityTable *srat;
      AcpiSratMemoryAffinity *numamem;

@@ -2262,9 +2263,8 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
      uint64_t mem_len, mem_base, next_base;
      MachineClass *mc = MACHINE_GET_CLASS(machine);
      const CPUArchIdList *apic_ids = mc->possible_cpu_arch_ids(machine);
-    PCMachineState *pcms = PC_MACHINE(machine);
      ram_addr_t hotplugabble_address_space_size =
-        object_property_get_int(OBJECT(pcms), PC_MACHINE_DEVMEM_REGION_SIZE,
+        object_property_get_int(OBJECT(machine), PC_MACHINE_DEVMEM_REGION_SIZE,
                                  NULL);
 
      srat_start = table_data->len;

@@ -2306,9 +2306,9 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
      next_base = 0;
      numa_start = table_data->len;
 
-    for (i = 1; i < pcms->numa_nodes + 1; ++i) {
+    for (i = 1; i < conf->numa_nodes + 1; ++i) {
          mem_base = next_base;
-        mem_len = pcms->node_mem[i - 1];
+        mem_len = conf->node_mem[i - 1];
          next_base = mem_base + mem_len;
 
          /* Cut out the 640K hole */

@@ -2331,16 +2331,16 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
          }
 
          /* Cut out the ACPI_PCI hole */
-        if (mem_base <= pcms->below_4g_mem_size &&
-            next_base > pcms->below_4g_mem_size) {
-            mem_len -= next_base - pcms->below_4g_mem_size;
+        if (mem_base <= conf->below_4g_mem_size &&
+            next_base > conf->below_4g_mem_size) {
+            mem_len -= next_base - conf->below_4g_mem_size;
              if (mem_len > 0) {
                  numamem = acpi_data_push(table_data, sizeof *numamem);
                  build_srat_memory(numamem, mem_base, mem_len, i - 1,
                                    MEM_AFFINITY_ENABLED);
              }
              mem_base = 1ULL << 32;
-            mem_len = next_base - pcms->below_4g_mem_size;
+            mem_len = next_base - conf->below_4g_mem_size;
              next_base = mem_base + mem_len;
          }
 

@@ -2351,7 +2351,7 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
          }
      }
      slots = (table_data->len - numa_start) / sizeof *numamem;
-    for (; slots < pcms->numa_nodes + 2; slots++) {
+    for (; slots < conf->numa_nodes + 2; slots++) {
          numamem = acpi_data_push(table_data, sizeof *numamem);
          build_srat_memory(numamem, 0, 0, 0, MEM_AFFINITY_NOFLAGS);
      }

@@ -2367,7 +2367,7 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
      if (hotplugabble_address_space_size) {
          numamem = acpi_data_push(table_data, sizeof *numamem);
          build_srat_memory(numamem, machine->device_memory->base,
-                          hotplugabble_address_space_size, pcms->numa_nodes - 1,
+                          hotplugabble_address_space_size, conf->numa_nodes - 1,
                            MEM_AFFINITY_HOTPLUGGABLE | MEM_AFFINITY_ENABLED);
      }
 

@@ -2546,17 +2546,6 @@ build_rsdp(GArray *rsdp_table, BIOSLinker *linker, unsigned rsdt_tbl_offset)
      return rsdp_table;
  }
 
-typedef
-struct AcpiBuildState {
-    /* Copy of table in RAM (for patching). */
-    MemoryRegion *table_mr;
-    /* Is table patched? */
-    uint8_t patched;
-    void *rsdp;
-    MemoryRegion *rsdp_mr;
-    MemoryRegion *linker_mr;
-} AcpiBuildState;
-
  static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg)
  {
      Object *pci_host;

@@ -2580,10 +2569,9 @@ static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg)
  }
 
  static
-void acpi_build(AcpiBuildTables *tables, MachineState *machine)
+void acpi_build(AcpiBuildTables *tables,
+                MachineState *machine, AcpiConfiguration *conf)
  {
-    PCMachineState *pcms = PC_MACHINE(machine);
-    PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
      GArray *table_offsets;
      unsigned facs, dsdt, rsdt, fadt;
      AcpiPmInfo pm;

@@ -2621,7 +2609,7 @@ void acpi_build(AcpiBuildTables *tables, MachineState *machine)
      /* DSDT is pointed to by FADT */
      dsdt = tables_blob->len;
      build_dsdt(tables_blob, tables->linker, &pm, &misc,
-               &pci_hole, &pci_hole64, machine);
+               &pci_hole, &pci_hole64, machine, conf);
 
      /* Count the size of the DSDT and SSDT, we will need it for legacy
       * sizing of ACPI tables.

@@ -2639,7 +2627,7 @@ void acpi_build(AcpiBuildTables *tables, MachineState *machine)
      aml_len += tables_blob->len - fadt;
 
      acpi_add_table(table_offsets, tables_blob);
-    build_madt(tables_blob, tables->linker, pcms);
+    build_madt(tables_blob, tables->linker, machine, conf);
 
      vmgenid_dev = find_vmgenid_dev();
      if (vmgenid_dev) {

@@ -2661,9 +2649,9 @@ void acpi_build(AcpiBuildTables *tables, MachineState *machine)
              build_tpm2(tables_blob, tables->linker, tables->tcpalog);
          }
      }
-    if (pcms->numa_nodes) {
+    if (conf->numa_nodes) {
          acpi_add_table(table_offsets, tables_blob);
-        build_srat(tables_blob, tables->linker, machine);
+        build_srat(tables_blob, tables->linker, machine, conf);
          if (have_numa_distance) {
              acpi_add_table(table_offsets, tables_blob);
              build_slit(tables_blob, tables->linker);

@@ -2683,9 +2671,9 @@ void acpi_build(AcpiBuildTables *tables, MachineState *machine)
              build_dmar_q35(tables_blob, tables->linker);
          }
      }
-    if (pcms->acpi_nvdimm_state.is_enabled) {
+    if (conf->acpi_nvdimm_state.is_enabled) {
          nvdimm_build_acpi(table_offsets, tables_blob, tables->linker,
-                          &pcms->acpi_nvdimm_state, machine->ram_slots);
+                          &conf->acpi_nvdimm_state, machine->ram_slots);
      }
 
      /* Add tables supplied by user (if any) */

@@ -2721,13 +2709,13 @@ void acpi_build(AcpiBuildTables *tables, MachineState *machine)
       *
       * All this is for PIIX4, since QEMU 2.0 didn't support Q35 migration.
       */
-    if (pcmc->legacy_acpi_table_size) {
+    if (conf->legacy_acpi_table_size) {
          /* Subtracting aml_len gives the size of fixed tables.  Then add the
           * size of the PIIX4 DSDT/SSDT in QEMU 2.0.
           */
          int legacy_aml_len =
-            pcmc->legacy_acpi_table_size +
-            ACPI_BUILD_LEGACY_CPU_AML_SIZE * pcms->apic_id_limit;
+            conf->legacy_acpi_table_size +
+            ACPI_BUILD_LEGACY_CPU_AML_SIZE * conf->apic_id_limit;
          int legacy_table_size =
              ROUND_UP(tables_blob->len - aml_len + legacy_aml_len,
                       ACPI_BUILD_ALIGN_SIZE);

@@ -2772,9 +2760,17 @@ static void acpi_ram_update(MemoryRegion *mr, GArray *data)
 
  static void acpi_build_update(void *build_opaque)
  {
-    AcpiBuildState *build_state = build_opaque;
+    AcpiConfiguration *conf = build_opaque;
+    AcpiBuildState *build_state;
      AcpiBuildTables tables;
 
+    /* No ACPI configuration? Nothing to do. */
+    if (!conf) {
+        return;
+    }
+
+    build_state = conf->build_state;
+
      /* No state to update or already patched? Nothing to do. */
      if (!build_state || build_state->patched) {
          return;

@@ -2783,7 +2779,7 @@ static void acpi_build_update(void *build_opaque)
 
      acpi_build_tables_init(&tables);
 
-    acpi_build(&tables, MACHINE(qdev_get_machine()));
+    acpi_build(&tables, MACHINE(qdev_get_machine()), conf);
 
      acpi_ram_update(build_state->table_mr, tables.table_data);
 

@@ -2803,12 +2799,12 @@ static void acpi_build_reset(void *build_opaque)
      build_state->patched = 0;
  }
 
-static MemoryRegion *acpi_add_rom_blob(AcpiBuildState *build_state,
+static MemoryRegion *acpi_add_rom_blob(AcpiConfiguration *conf,
                                         GArray *blob, const char *name,
                                         uint64_t max_size)
  {
      return rom_add_blob(name, blob->data, acpi_data_len(blob), max_size, -1,
-                        name, acpi_build_update, build_state, NULL, true);
+                        name, acpi_build_update, conf, NULL, true);
  }
 
  static const VMStateDescription vmstate_acpi_build = {

@@ -2816,59 +2812,48 @@ static const VMStateDescription vmstate_acpi_build = {
      .version_id = 1,
      .minimum_version_id = 1,
      .fields = (VMStateField[]) {
-        VMSTATE_UINT8(patched, AcpiBuildState),
+        VMSTATE_BOOL(patched, AcpiBuildState),
          VMSTATE_END_OF_LIST()
      },
  };
 
-void acpi_setup(void)
+void acpi_setup(MachineState *machine, AcpiConfiguration *conf)
  {
-    PCMachineState *pcms = PC_MACHINE(qdev_get_machine());
-    PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
      AcpiBuildTables tables;
      AcpiBuildState *build_state;
      Object *vmgenid_dev;
 
-    if (!pcms->fw_cfg) {
-        ACPI_BUILD_DPRINTF("No fw cfg. Bailing out.\n");
-        return;
-    }
-
-    if (!pcms->acpi_build_enabled) {
-        ACPI_BUILD_DPRINTF("ACPI build disabled. Bailing out.\n");
-        return;
-    }
-
-    if (!acpi_enabled) {
-        ACPI_BUILD_DPRINTF("ACPI disabled. Bailing out.\n");
+    if (!conf) {
+        ACPI_BUILD_DPRINTF("No ACPI config. Bailing out.\n");
          return;
      }
 
      build_state = g_malloc0(sizeof *build_state);
+    conf->build_state = build_state;
 
      acpi_build_tables_init(&tables);
-    acpi_build(&tables, MACHINE(pcms));
+    acpi_build(&tables, machine, conf);
 
      /* Now expose it all to Guest */
-    build_state->table_mr = acpi_add_rom_blob(build_state, tables.table_data,
+    build_state->table_mr = acpi_add_rom_blob(conf, tables.table_data,
                                                 ACPI_BUILD_TABLE_FILE,
                                                 ACPI_BUILD_TABLE_MAX_SIZE);
      assert(build_state->table_mr != NULL);
 
      build_state->linker_mr =
-        acpi_add_rom_blob(build_state, tables.linker->cmd_blob,
+        acpi_add_rom_blob(conf, tables.linker->cmd_blob,
                            "etc/table-loader", 0);
 
-    fw_cfg_add_file(pcms->fw_cfg, ACPI_BUILD_TPMLOG_FILE,
+    fw_cfg_add_file(conf->fw_cfg, ACPI_BUILD_TPMLOG_FILE,
                      tables.tcpalog->data, acpi_data_len(tables.tcpalog));
 
      vmgenid_dev = find_vmgenid_dev();
      if (vmgenid_dev) {
-        vmgenid_add_fw_cfg(VMGENID(vmgenid_dev), pcms->fw_cfg,
+        vmgenid_add_fw_cfg(VMGENID(vmgenid_dev), conf->fw_cfg,
                             tables.vmgenid);
      }
 
-    if (!pcmc->rsdp_in_ram) {
+    if (!conf->rsdp_in_ram) {
          /*
           * Keep for compatibility with old machine types.
           * Though RSDP is small, its contents isn't immutable, so

@@ -2877,13 +2862,13 @@ void acpi_setup(void)
          uint32_t rsdp_size = acpi_data_len(tables.rsdp);
 
          build_state->rsdp = g_memdup(tables.rsdp->data, rsdp_size);
-        fw_cfg_add_file_callback(pcms->fw_cfg, ACPI_BUILD_RSDP_FILE,
-                                 acpi_build_update, NULL, build_state,
+        fw_cfg_add_file_callback(conf->fw_cfg, ACPI_BUILD_RSDP_FILE,
+                                 acpi_build_update, NULL, conf,
                                   build_state->rsdp, rsdp_size, true);
          build_state->rsdp_mr = NULL;
      } else {
          build_state->rsdp = NULL;
-        build_state->rsdp_mr = acpi_add_rom_blob(build_state, tables.rsdp,
+        build_state->rsdp_mr = acpi_add_rom_blob(conf, tables.rsdp,
                                                    ACPI_BUILD_RSDP_FILE, 0);
      }
 

hw/i386/acpi-build.h +3 -1

index 007332e51c..1e6b5a7c2e 100644
@@ -2,6 +2,8 @@
  #ifndef HW_I386_ACPI_BUILD_H
  #define HW_I386_ACPI_BUILD_H
 
-void acpi_setup(void);
+#include "hw/acpi/acpi.h"
+
+void acpi_setup(MachineState *machine, AcpiConfiguration *conf);
 
  #endif

hw/i386/pc.c +106 -69

index f095725dba..bd4a77b856 100644
@@ -444,17 +444,18 @@ void pc_cmos_init(PCMachineState *pcms,
  {
      int val;
      static pc_cmos_init_late_arg arg;
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
      /* various important CMOS locations needed by PC/Bochs bios */
 
      /* memory size */
      /* base memory (first MiB) */
-    val = MIN(pcms->below_4g_mem_size / KiB, 640);
+    val = MIN(conf->below_4g_mem_size / KiB, 640);
      rtc_set_memory(s, 0x15, val);
      rtc_set_memory(s, 0x16, val >> 8);
      /* extended memory (next 64MiB) */
-    if (pcms->below_4g_mem_size > 1 * MiB) {
-        val = (pcms->below_4g_mem_size - 1 * MiB) / KiB;
+    if (conf->below_4g_mem_size > 1 * MiB) {
+        val = (conf->below_4g_mem_size - 1 * MiB) / KiB;
      } else {
          val = 0;
      }

@@ -465,8 +466,8 @@ void pc_cmos_init(PCMachineState *pcms,
      rtc_set_memory(s, 0x30, val);
      rtc_set_memory(s, 0x31, val >> 8);
      /* memory between 16MiB and 4GiB */
-    if (pcms->below_4g_mem_size > 16 * MiB) {
-        val = (pcms->below_4g_mem_size - 16 * MiB) / (64 * KiB);
+    if (conf->below_4g_mem_size > 16 * MiB) {
+        val = (conf->below_4g_mem_size - 16 * MiB) / (64 * KiB);
      } else {
          val = 0;
      }

@@ -475,7 +476,7 @@ void pc_cmos_init(PCMachineState *pcms,
      rtc_set_memory(s, 0x34, val);
      rtc_set_memory(s, 0x35, val >> 8);
      /* memory above 4GiB */
-    val = pcms->above_4g_mem_size / 65536;
+    val = conf->above_4g_mem_size / 65536;
      rtc_set_memory(s, 0x5b, val);
      rtc_set_memory(s, 0x5c, val >> 8);
      rtc_set_memory(s, 0x5d, val >> 16);

@@ -714,13 +715,14 @@ static void pc_build_smbios(PCMachineState *pcms)
      unsigned i, array_count;
      MachineState *ms = MACHINE(pcms);
      X86CPU *cpu = X86_CPU(ms->possible_cpus->cpus[0].cpu);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
      /* tell smbios about cpuid version and features */
      smbios_set_cpuid(cpu->env.cpuid_version, cpu->env.features[FEAT_1_EDX]);
 
      smbios_tables = smbios_get_table_legacy(&smbios_tables_len);
      if (smbios_tables) {
-        fw_cfg_add_bytes(pcms->fw_cfg, FW_CFG_SMBIOS_ENTRIES,
+        fw_cfg_add_bytes(conf->fw_cfg, FW_CFG_SMBIOS_ENTRIES,
                           smbios_tables, smbios_tables_len);
      }
 

@@ -741,9 +743,9 @@ static void pc_build_smbios(PCMachineState *pcms)
      g_free(mem_array);
 
      if (smbios_anchor) {
-        fw_cfg_add_file(pcms->fw_cfg, "etc/smbios/smbios-tables",
+        fw_cfg_add_file(conf->fw_cfg, "etc/smbios/smbios-tables",
                          smbios_tables, smbios_tables_len);
-        fw_cfg_add_file(pcms->fw_cfg, "etc/smbios/smbios-anchor",
+        fw_cfg_add_file(conf->fw_cfg, "etc/smbios/smbios-anchor",
                          smbios_anchor, smbios_anchor_len);
      }
  }

@@ -755,6 +757,7 @@ static FWCfgState *bochs_bios_init(AddressSpace *as, PCMachineState *pcms)
      int i;
      const CPUArchIdList *cpus;
      MachineClass *mc = MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
      fw_cfg = fw_cfg_init_io_dma(FW_CFG_IO_BASE, FW_CFG_IO_BASE + 4, as);
      fw_cfg_add_i16(fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);

@@ -771,7 +774,7 @@ static FWCfgState *bochs_bios_init(AddressSpace *as, PCMachineState *pcms)
       * So for compatibility reasons with old BIOSes we are stuck with
       * "etc/max-cpus" actually being apic_id_limit
       */
-    fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)pcms->apic_id_limit);
+    fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)conf->apic_id_limit);
      fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
      fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES,
                       acpi_tables, acpi_tables_len);

@@ -787,20 +790,20 @@ static FWCfgState *bochs_bios_init(AddressSpace *as, PCMachineState *pcms)
       * of nodes, one word for each VCPU->node and one word for each node to
       * hold the amount of memory.
       */
-    numa_fw_cfg = g_new0(uint64_t, 1 + pcms->apic_id_limit + nb_numa_nodes);
+    numa_fw_cfg = g_new0(uint64_t, 1 + conf->apic_id_limit + nb_numa_nodes);
      numa_fw_cfg[0] = cpu_to_le64(nb_numa_nodes);
      cpus = mc->possible_cpu_arch_ids(MACHINE(pcms));
      for (i = 0; i < cpus->len; i++) {
          unsigned int apic_id = cpus->cpus[i].arch_id;
-        assert(apic_id < pcms->apic_id_limit);
+        assert(apic_id < conf->apic_id_limit);
          numa_fw_cfg[apic_id + 1] = cpu_to_le64(cpus->cpus[i].props.node_id);
      }
      for (i = 0; i < nb_numa_nodes; i++) {
-        numa_fw_cfg[pcms->apic_id_limit + 1 + i] =
+        numa_fw_cfg[conf->apic_id_limit + 1 + i] =
              cpu_to_le64(numa_info[i].node_mem);
      }
      fw_cfg_add_bytes(fw_cfg, FW_CFG_NUMA, numa_fw_cfg,
-                     (1 + pcms->apic_id_limit + nb_numa_nodes) *
+                     (1 + conf->apic_id_limit + nb_numa_nodes) *
                       sizeof(*numa_fw_cfg));
 
      return fw_cfg;

@@ -848,6 +851,7 @@ static void load_linux(PCMachineState *pcms,
      char *vmode;
      MachineState *machine = MACHINE(pcms);
      PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      struct setup_data *setup_data;
      const char *kernel_filename = machine->kernel_filename;
      const char *initrd_filename = machine->initrd_filename;

@@ -917,8 +921,8 @@ static void load_linux(PCMachineState *pcms,
          initrd_max = 0x37ffffff;
      }
 
-    if (initrd_max >= pcms->below_4g_mem_size - pcmc->acpi_data_size) {
-        initrd_max = pcms->below_4g_mem_size - pcmc->acpi_data_size - 1;
+    if (initrd_max >= conf->below_4g_mem_size - pcmc->acpi_data_size) {
+        initrd_max = conf->below_4g_mem_size - pcmc->acpi_data_size - 1;
      }
 
      fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_ADDR, cmdline_addr);

@@ -1154,7 +1158,8 @@ void pc_cpus_init(PCMachineState *pcms)
       *
       * This is used for FW_CFG_MAX_CPUS. See comments on bochs_bios_init().
       */
-    pcms->apic_id_limit = x86_cpu_apic_id_from_index(max_cpus - 1) + 1;
+    pcms->acpi_configuration.apic_id_limit =
+        x86_cpu_apic_id_from_index(max_cpus - 1) + 1;
      possible_cpus = mc->possible_cpu_arch_ids(ms);
      for (i = 0; i < smp_cpus; i++) {
          pc_new_cpu(possible_cpus->cpus[i].type, possible_cpus->cpus[i].arch_id,

@@ -1188,7 +1193,8 @@ static void pc_build_feature_control_file(PCMachineState *pcms)
 
      val = g_malloc(sizeof(*val));
      *val = cpu_to_le64(feature_control_bits | FEATURE_CONTROL_LOCKED);
-    fw_cfg_add_file(pcms->fw_cfg, "etc/msr_feature_control", val, sizeof(*val));
+    fw_cfg_add_file(pcms->acpi_configuration.fw_cfg,
+                    "etc/msr_feature_control", val, sizeof(*val));
  }
 
  static void rtc_set_cpus_count(ISADevice *rtc, uint16_t cpus_count)

@@ -1204,11 +1210,26 @@ static void rtc_set_cpus_count(ISADevice *rtc, uint16_t cpus_count)
      }
  }
 
+static void acpi_conf_pc_init(PCMachineState *pcms)
+{
+    PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
+
+    /* Machine class settings */
+    conf->legacy_acpi_table_size = pcmc->legacy_acpi_table_size;
+    conf->legacy_cpu_hotplug = pcmc->legacy_cpu_hotplug;
+    conf->rsdp_in_ram = pcmc->rsdp_in_ram;
+
+    /* ACPI build state */
+    conf->build_state = NULL;
+}
+
  static
  void pc_machine_done(Notifier *notifier, void *data)
  {
      PCMachineState *pcms = container_of(notifier,
                                          PCMachineState, machine_done);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      PCIBus *bus = pcms->bus;
 
      /* set the number of CPUs */

@@ -1223,23 +1244,27 @@ void pc_machine_done(Notifier *notifier, void *data)
                  extra_hosts++;
              }
          }
-        if (extra_hosts && pcms->fw_cfg) {
+        if (extra_hosts && conf->fw_cfg) {
              uint64_t *val = g_malloc(sizeof(*val));
              *val = cpu_to_le64(extra_hosts);
-            fw_cfg_add_file(pcms->fw_cfg,
+            fw_cfg_add_file(conf->fw_cfg,
                      "etc/extra-pci-roots", val, sizeof(*val));
          }
      }
 
-    acpi_setup();
-    if (pcms->fw_cfg) {
+    if (pcms->acpi_build_enabled) {
+        acpi_conf_pc_init(pcms);
+        acpi_setup(MACHINE(pcms), conf);
+    }
+
+    if (conf->fw_cfg) {
          pc_build_smbios(pcms);
          pc_build_feature_control_file(pcms);
          /* update FW_CFG_NB_CPUS to account for -device added CPUs */
-        fw_cfg_modify_i16(pcms->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
+        fw_cfg_modify_i16(conf->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
      }
 
-    if (pcms->apic_id_limit > 255 && !xen_enabled()) {
+    if (conf->apic_id_limit > 255 && !xen_enabled()) {
          IntelIOMMUState *iommu = INTEL_IOMMU_DEVICE(x86_iommu_get_default());
 
          if (!iommu || !iommu->x86_iommu.intr_supported ||

@@ -1256,13 +1281,14 @@ void pc_machine_done(Notifier *notifier, void *data)
  void pc_guest_info_init(PCMachineState *pcms)
  {
      int i;
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    pcms->apic_xrupt_override = kvm_allows_irq0_override();
-    pcms->numa_nodes = nb_numa_nodes;
-    pcms->node_mem = g_malloc0(pcms->numa_nodes *
-                                    sizeof *pcms->node_mem);
+    conf->apic_xrupt_override = kvm_allows_irq0_override();
+    conf->numa_nodes = nb_numa_nodes;
+    conf->node_mem = g_malloc0(conf->numa_nodes *
+                                    sizeof *conf->node_mem);
      for (i = 0; i < nb_numa_nodes; i++) {
-        pcms->node_mem[i] = numa_info[i].node_mem;
+        conf->node_mem[i] = numa_info[i].node_mem;
      }
 
      pcms->machine_done.notify = pc_machine_done;

@@ -1323,7 +1349,7 @@ void xen_load_linux(PCMachineState *pcms)
                 !strcmp(option_rom[i].name, "multiboot.bin"));
          rom_add_option(option_rom[i].name, option_rom[i].bootindex);
      }
-    pcms->fw_cfg = fw_cfg;
+    pcms->acpi_configuration.fw_cfg = fw_cfg;
  }
 
  void pc_memory_init(PCMachineState *pcms,

@@ -1337,9 +1363,10 @@ void pc_memory_init(PCMachineState *pcms,
      FWCfgState *fw_cfg;
      MachineState *machine = MACHINE(pcms);
      PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    assert(machine->ram_size == pcms->below_4g_mem_size +
-                                pcms->above_4g_mem_size);
+    assert(machine->ram_size == conf->below_4g_mem_size +
+                                conf->above_4g_mem_size);
 
      linux_boot = (machine->kernel_filename != NULL);
 

@@ -1353,17 +1380,17 @@ void pc_memory_init(PCMachineState *pcms,
      *ram_memory = ram;
      ram_below_4g = g_malloc(sizeof(*ram_below_4g));
      memory_region_init_alias(ram_below_4g, NULL, "ram-below-4g", ram,
-                             0, pcms->below_4g_mem_size);
+                             0, conf->below_4g_mem_size);
      memory_region_add_subregion(system_memory, 0, ram_below_4g);
-    e820_add_entry(0, pcms->below_4g_mem_size, E820_RAM);
-    if (pcms->above_4g_mem_size > 0) {
+    e820_add_entry(0, conf->below_4g_mem_size, E820_RAM);
+    if (conf->above_4g_mem_size > 0) {
          ram_above_4g = g_malloc(sizeof(*ram_above_4g));
          memory_region_init_alias(ram_above_4g, NULL, "ram-above-4g", ram,
-                                 pcms->below_4g_mem_size,
-                                 pcms->above_4g_mem_size);
+                                 conf->below_4g_mem_size,
+                                 conf->above_4g_mem_size);
          memory_region_add_subregion(system_memory, 0x100000000ULL,
                                      ram_above_4g);
-        e820_add_entry(0x100000000ULL, pcms->above_4g_mem_size, E820_RAM);
+        e820_add_entry(0x100000000ULL, conf->above_4g_mem_size, E820_RAM);
      }
 
      if (!pcmc->has_reserved_memory &&

@@ -1398,7 +1425,7 @@ void pc_memory_init(PCMachineState *pcms,
          }
 
          machine->device_memory->base =
-            ROUND_UP(0x100000000ULL + pcms->above_4g_mem_size, 1 * GiB);
+            ROUND_UP(0x100000000ULL + conf->above_4g_mem_size, 1 * GiB);
 
          if (pcmc->enforce_aligned_dimm) {
              /* size device region assuming 1G page max alignment per slot */

@@ -1455,7 +1482,7 @@ void pc_memory_init(PCMachineState *pcms,
      for (i = 0; i < nb_option_roms; i++) {
          rom_add_option(option_rom[i].name, option_rom[i].bootindex);
      }
-    pcms->fw_cfg = fw_cfg;
+    conf->fw_cfg = fw_cfg;
 
      /* Init default IOAPIC address space */
      pcms->ioapic_as = &address_space_memory;

@@ -1478,7 +1505,8 @@ uint64_t pc_pci_hole64_start(void)
              hole64_start += memory_region_size(&ms->device_memory->mr);
          }
      } else {
-        hole64_start = 0x100000000ULL + pcms->above_4g_mem_size;
+        hole64_start =
+            0x100000000ULL + pcms->acpi_configuration.above_4g_mem_size;
      }
 
      return ROUND_UP(hole64_start, 1 * GiB);

@@ -1685,21 +1713,22 @@ static void pc_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
  {
      const PCMachineState *pcms = PC_MACHINE(hotplug_dev);
      const PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    const AcpiConfiguration *conf = &pcms->acpi_configuration;
      const bool is_nvdimm = object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM);
      const uint64_t legacy_align = TARGET_PAGE_SIZE;
 
      /*
       * When -no-acpi is used with Q35 machine type, no ACPI is built,
-     * but pcms->acpi_dev is still created. Check !acpi_enabled in
+     * but acpi_dev is still created. Check !acpi_enabled in
       * addition to cover this case.
       */
-    if (!pcms->acpi_dev || !acpi_enabled) {
+    if (!conf->acpi_dev || !acpi_enabled) {
          error_setg(errp,
                     "memory hotplug is not enabled: missing acpi device or acpi disabled");
          return;
      }
 
-    if (is_nvdimm && !pcms->acpi_nvdimm_state.is_enabled) {
+    if (is_nvdimm && !conf->acpi_nvdimm_state.is_enabled) {
          error_setg(errp, "nvdimm is not enabled: missing 'nvdimm' in '-M'");
          return;
      }

@@ -1715,6 +1744,7 @@ static void pc_memory_plug(HotplugHandler *hotplug_dev,
      Error *local_err = NULL;
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
      bool is_nvdimm = object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
      pc_dimm_plug(PC_DIMM(dev), MACHINE(pcms), &local_err);
      if (local_err) {

@@ -1722,11 +1752,11 @@ static void pc_memory_plug(HotplugHandler *hotplug_dev,
      }
 
      if (is_nvdimm) {
-        nvdimm_plug(&pcms->acpi_nvdimm_state);
+        nvdimm_plug(&conf->acpi_nvdimm_state);
      }
 
-    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-    hhc->plug(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &error_abort);
+    hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+    hhc->plug(HOTPLUG_HANDLER(conf->acpi_dev), dev, &error_abort);
  out:
      error_propagate(errp, local_err);
  }

@@ -1737,13 +1767,14 @@ static void pc_memory_unplug_request(HotplugHandler *hotplug_dev,
      HotplugHandlerClass *hhc;
      Error *local_err = NULL;
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
      /*
       * When -no-acpi is used with Q35 machine type, no ACPI is built,
-     * but pcms->acpi_dev is still created. Check !acpi_enabled in
+     * but acpi_dev is still created. Check !acpi_enabled in
       * addition to cover this case.
       */
-    if (!pcms->acpi_dev || !acpi_enabled) {
+    if (!conf->acpi_dev || !acpi_enabled) {
          error_setg(&local_err,
                     "memory hotplug is not enabled: missing acpi device or acpi disabled");
          goto out;

@@ -1755,8 +1786,8 @@ static void pc_memory_unplug_request(HotplugHandler *hotplug_dev,
          goto out;
      }
 
-    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-    hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
+    hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+    hhc->unplug_request(HOTPLUG_HANDLER(conf->acpi_dev), dev, &local_err);
 
  out:
      error_propagate(errp, local_err);

@@ -1766,11 +1797,12 @@ static void pc_memory_unplug(HotplugHandler *hotplug_dev,
                               DeviceState *dev, Error **errp)
  {
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      HotplugHandlerClass *hhc;
      Error *local_err = NULL;
 
-    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-    hhc->unplug(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
+    hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+    hhc->unplug(HOTPLUG_HANDLER(conf->acpi_dev), dev, &local_err);
 
      if (local_err) {
          goto out;

@@ -1817,10 +1849,11 @@ static void pc_cpu_plug(HotplugHandler *hotplug_dev,
      Error *local_err = NULL;
      X86CPU *cpu = X86_CPU(dev);
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    if (pcms->acpi_dev) {
-        hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-        hhc->plug(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
+    if (conf->acpi_dev) {
+        hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+        hhc->plug(HOTPLUG_HANDLER(conf->acpi_dev), dev, &local_err);
          if (local_err) {
              goto out;
          }

@@ -1831,8 +1864,8 @@ static void pc_cpu_plug(HotplugHandler *hotplug_dev,
      if (pcms->rtc) {
          rtc_set_cpus_count(pcms->rtc, pcms->boot_cpus);
      }
-    if (pcms->fw_cfg) {
-        fw_cfg_modify_i16(pcms->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
+    if (conf->fw_cfg) {
+        fw_cfg_modify_i16(conf->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
      }
 
      found_cpu = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, NULL);

@@ -1848,8 +1881,9 @@ static void pc_cpu_unplug_request_cb(HotplugHandler *hotplug_dev,
      Error *local_err = NULL;
      X86CPU *cpu = X86_CPU(dev);
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    if (!pcms->acpi_dev) {
+    if (!conf->acpi_dev) {
          error_setg(&local_err, "CPU hot unplug not supported without ACPI");
          goto out;
      }

@@ -1861,8 +1895,8 @@ static void pc_cpu_unplug_request_cb(HotplugHandler *hotplug_dev,
          goto out;
      }
 
-    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-    hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
+    hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+    hhc->unplug_request(HOTPLUG_HANDLER(conf->acpi_dev), dev, &local_err);
 
      if (local_err) {
          goto out;

@@ -1881,9 +1915,10 @@ static void pc_cpu_unplug_cb(HotplugHandler *hotplug_dev,
      Error *local_err = NULL;
      X86CPU *cpu = X86_CPU(dev);
      PCMachineState *pcms = PC_MACHINE(hotplug_dev);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
-    hhc->unplug(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
+    hhc = HOTPLUG_HANDLER_GET_CLASS(conf->acpi_dev);
+    hhc->unplug(HOTPLUG_HANDLER(conf->acpi_dev), dev, &local_err);
 
      if (local_err) {
          goto out;

@@ -1897,7 +1932,7 @@ static void pc_cpu_unplug_cb(HotplugHandler *hotplug_dev,
      pcms->boot_cpus--;
      /* Update the number of CPUs in CMOS */
      rtc_set_cpus_count(pcms->rtc, pcms->boot_cpus);
-    fw_cfg_modify_i16(pcms->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
+    fw_cfg_modify_i16(conf->fw_cfg, FW_CFG_NB_CPUS, pcms->boot_cpus);
   out:
      error_propagate(errp, local_err);
  }

@@ -2181,28 +2216,30 @@ static bool pc_machine_get_nvdimm(Object *obj, Error **errp)
  {
      PCMachineState *pcms = PC_MACHINE(obj);
 
-    return pcms->acpi_nvdimm_state.is_enabled;
+    return pcms->acpi_configuration.acpi_nvdimm_state.is_enabled;
  }
 
  static void pc_machine_set_nvdimm(Object *obj, bool value, Error **errp)
  {
      PCMachineState *pcms = PC_MACHINE(obj);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    pcms->acpi_nvdimm_state.is_enabled = value;
+    conf->acpi_nvdimm_state.is_enabled = value;
  }
 
  static char *pc_machine_get_nvdimm_persistence(Object *obj, Error **errp)
  {
      PCMachineState *pcms = PC_MACHINE(obj);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
 
-    return g_strdup(pcms->acpi_nvdimm_state.persistence_string);
+    return g_strdup(conf->acpi_nvdimm_state.persistence_string);
  }
 
  static void pc_machine_set_nvdimm_persistence(Object *obj, const char *value,
                                                 Error **errp)
  {
      PCMachineState *pcms = PC_MACHINE(obj);
-    AcpiNVDIMMState *nvdimm_state = &pcms->acpi_nvdimm_state;
+    AcpiNVDIMMState *nvdimm_state = &pcms->acpi_configuration.acpi_nvdimm_state;
 
      if (strcmp(value, "cpu") == 0)
          nvdimm_state->persistence = 3;

@@ -2268,7 +2305,7 @@ static void pc_machine_initfn(Object *obj)
      pcms->smm = ON_OFF_AUTO_AUTO;
      pcms->vmport = ON_OFF_AUTO_AUTO;
      /* nvdimm is disabled on default. */
-    pcms->acpi_nvdimm_state.is_enabled = false;
+    pcms->acpi_configuration.acpi_nvdimm_state.is_enabled = false;
      /* acpi build is enabled by default if machine supports it */
      pcms->acpi_build_enabled = PC_MACHINE_GET_CLASS(pcms)->has_acpi_build;
      pcms->smbus = true;

hw/i386/pc_piix.c +11 -10

index dc09466b3e..1d10374dfa 100644
@@ -71,6 +71,7 @@ static void pc_init1(MachineState *machine,
  {
      PCMachineState *pcms = PC_MACHINE(machine);
      PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      MemoryRegion *system_memory = get_system_memory();
      MemoryRegion *system_io = get_system_io();
      int i;

@@ -142,11 +143,11 @@ static void pc_init1(MachineState *machine,
          }
 
          if (machine->ram_size >= lowmem) {
-            pcms->above_4g_mem_size = machine->ram_size - lowmem;
-            pcms->below_4g_mem_size = lowmem;
+            conf->above_4g_mem_size = machine->ram_size - lowmem;
+            conf->below_4g_mem_size = lowmem;
          } else {
-            pcms->above_4g_mem_size = 0;
-            pcms->below_4g_mem_size = machine->ram_size;
+            conf->above_4g_mem_size = 0;
+            conf->below_4g_mem_size = machine->ram_size;
          }
      }
 

@@ -199,8 +200,8 @@ static void pc_init1(MachineState *machine,
                                pci_type,
                                &i440fx_state, &piix3_devfn, &isa_bus, pcms->gsi,
                                system_memory, system_io, machine->ram_size,
-                              pcms->below_4g_mem_size,
-                              pcms->above_4g_mem_size,
+                              conf->below_4g_mem_size,
+                              conf->above_4g_mem_size,
                                pci_memory, ram_memory);
          pcms->bus = pci_bus;
      } else {

@@ -289,16 +290,16 @@ static void pc_init1(MachineState *machine,
 
          object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
                                   TYPE_HOTPLUG_HANDLER,
-                                 (Object **)&pcms->acpi_dev,
+                                 (Object **)&conf->acpi_dev,
                                   object_property_allow_set_link,
                                   OBJ_PROP_LINK_STRONG, &error_abort);
          object_property_set_link(OBJECT(machine), OBJECT(piix4_pm),
                                   PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
      }
 
-    if (pcms->acpi_nvdimm_state.is_enabled) {
-        nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,
-                               pcms->fw_cfg, OBJECT(pcms));
+    if (conf->acpi_nvdimm_state.is_enabled) {
+        nvdimm_init_acpi_state(&conf->acpi_nvdimm_state, system_io,
+                               conf->fw_cfg, OBJECT(pcms));
      }
  }
 

hw/i386/pc_q35.c +11 -10

index 532241e3f8..fb5c89bf7c 100644
@@ -63,6 +63,7 @@ static void pc_q35_init(MachineState *machine)
  {
      PCMachineState *pcms = PC_MACHINE(machine);
      PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      Q35PCIHost *q35_host;
      PCIHostState *phb;
      PCIBus *host_bus;

@@ -116,11 +117,11 @@ static void pc_q35_init(MachineState *machine)
      }
 
      if (machine->ram_size >= lowmem) {
-        pcms->above_4g_mem_size = machine->ram_size - lowmem;
-        pcms->below_4g_mem_size = lowmem;
+        conf->above_4g_mem_size = machine->ram_size - lowmem;
+        conf->below_4g_mem_size = lowmem;
      } else {
-        pcms->above_4g_mem_size = 0;
-        pcms->below_4g_mem_size = machine->ram_size;
+        conf->above_4g_mem_size = 0;
+        conf->below_4g_mem_size = machine->ram_size;
      }
 
      if (xen_enabled()) {

@@ -179,9 +180,9 @@ static void pc_q35_init(MachineState *machine)
                               MCH_HOST_PROP_SYSTEM_MEM, NULL);
      object_property_set_link(OBJECT(q35_host), OBJECT(system_io),
                               MCH_HOST_PROP_IO_MEM, NULL);
-    object_property_set_int(OBJECT(q35_host), pcms->below_4g_mem_size,
+    object_property_set_int(OBJECT(q35_host), conf->below_4g_mem_size,
                              PCI_HOST_BELOW_4G_MEM_SIZE, NULL);
-    object_property_set_int(OBJECT(q35_host), pcms->above_4g_mem_size,
+    object_property_set_int(OBJECT(q35_host), conf->above_4g_mem_size,
                              PCI_HOST_ABOVE_4G_MEM_SIZE, NULL);
      /* pci */
      qdev_init_nofail(DEVICE(q35_host));

@@ -194,7 +195,7 @@ static void pc_q35_init(MachineState *machine)
 
      object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
                               TYPE_HOTPLUG_HANDLER,
-                             (Object **)&pcms->acpi_dev,
+                             (Object **)&conf->acpi_dev,
                               object_property_allow_set_link,
                               OBJ_PROP_LINK_STRONG, &error_abort);
      object_property_set_link(OBJECT(machine), OBJECT(lpc),

@@ -276,9 +277,9 @@ static void pc_q35_init(MachineState *machine)
      pc_vga_init(isa_bus, host_bus);
      pc_nic_init(pcmc, isa_bus, host_bus);
 
-    if (pcms->acpi_nvdimm_state.is_enabled) {
-        nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,
-                               pcms->fw_cfg, OBJECT(pcms));
+    if (conf->acpi_nvdimm_state.is_enabled) {
+        nvdimm_init_acpi_state(&conf->acpi_nvdimm_state, system_io,
+                               conf->fw_cfg, OBJECT(pcms));
      }
  }
 

hw/i386/xen/xen-hvm.c +10 -9

index 935a3676c8..4ad5b10d64 100644
@@ -190,6 +190,7 @@ qemu_irq *xen_interrupt_controller_init(void)
  static void xen_ram_init(PCMachineState *pcms,
                           ram_addr_t ram_size, MemoryRegion **ram_memory_p)
  {
+    AcpiConfiguration *conf = &pcms->acpi_configuration;
      MemoryRegion *sysmem = get_system_memory();
      ram_addr_t block_len;
      uint64_t user_lowmem = object_property_get_uint(qdev_get_machine(),

@@ -207,20 +208,20 @@ static void xen_ram_init(PCMachineState *pcms,
      }
 
      if (ram_size >= user_lowmem) {
-        pcms->above_4g_mem_size = ram_size - user_lowmem;
-        pcms->below_4g_mem_size = user_lowmem;
+        conf->above_4g_mem_size = ram_size - user_lowmem;
+        conf->below_4g_mem_size = user_lowmem;
      } else {
-        pcms->above_4g_mem_size = 0;
-        pcms->below_4g_mem_size = ram_size;
+        conf->above_4g_mem_size = 0;
+        conf->below_4g_mem_size = ram_size;
      }
-    if (!pcms->above_4g_mem_size) {
+    if (!conf->above_4g_mem_size) {
          block_len = ram_size;
      } else {
          /*
           * Xen does not allocate the memory continuously, it keeps a
           * hole of the size computed above or passed in.
           */
-        block_len = (1ULL << 32) + pcms->above_4g_mem_size;
+        block_len = (1ULL << 32) + conf->above_4g_mem_size;
      }
      memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len,
                             &error_fatal);

@@ -237,12 +238,12 @@ static void xen_ram_init(PCMachineState *pcms,
       */
      memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo",
                               &ram_memory, 0xc0000,
-                             pcms->below_4g_mem_size - 0xc0000);
+                             conf->below_4g_mem_size - 0xc0000);
      memory_region_add_subregion(sysmem, 0xc0000, &ram_lo);
-    if (pcms->above_4g_mem_size > 0) {
+    if (conf->above_4g_mem_size > 0) {
          memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi",
                                   &ram_memory, 0x100000000ULL,
-                                 pcms->above_4g_mem_size);
+                                 conf->above_4g_mem_size);
          memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi);
      }
  }

include/hw/acpi/acpi.h +43 -0

index c20ace0d0b..6a94452928 100644
@@ -24,6 +24,8 @@
  #include "exec/memory.h"
  #include "hw/irq.h"
  #include "hw/acpi/acpi_dev_interface.h"
+#include "hw/hotplug.h"
+#include "hw/mem/nvdimm.h"
 
  /*
   * current device naming scheme supports up to 256 memory devices

@@ -186,6 +188,47 @@ extern int acpi_enabled;
  extern char unsigned *acpi_tables;
  extern size_t acpi_tables_len;
 
+typedef
+struct AcpiBuildState {
+    /* Copy of table in RAM (for patching). */
+    MemoryRegion *table_mr;
+    /* Is table patched? */
+    bool patched;
+    void *rsdp;
+    MemoryRegion *rsdp_mr;
+    MemoryRegion *linker_mr;
+} AcpiBuildState;
+
+typedef
+struct AcpiConfiguration {
+    /* Machine class ACPI settings */
+    int legacy_acpi_table_size;
+    bool rsdp_in_ram;
+    unsigned acpi_data_size;
+
+    /* Machine state ACPI settings */
+    HotplugHandler *acpi_dev;
+    AcpiNVDIMMState acpi_nvdimm_state;
+
+    /*
+     * The fields below are machine settings that
+     * are not ACPI specific. However they are needed
+     * for building ACPI tables and as such should be
+     * carried through the ACPI configuration structure.
+     */
+    bool legacy_cpu_hotplug;
+    bool linuxboot_dma_enabled;
+    FWCfgState *fw_cfg;
+    ram_addr_t below_4g_mem_size, above_4g_mem_size;;
+    uint64_t numa_nodes;
+    uint64_t *node_mem;
+    bool apic_xrupt_override;
+    unsigned apic_id_limit;
+
+    /* Build state */
+    AcpiBuildState *build_state;
+} AcpiConfiguration;
+
  uint8_t *acpi_table_first(void);
  uint8_t *acpi_table_next(uint8_t *current);
  unsigned acpi_table_len(void *current);

include/hw/i386/pc.h +2 -10

index dfe6746692..da0bd39741 100644
@@ -12,6 +12,7 @@
  #include "qemu/range.h"
  #include "qemu/bitmap.h"
  #include "sysemu/sysemu.h"
+#include "hw/acpi/acpi.h"
  #include "hw/pci/pci.h"
  #include "hw/compat.h"
  #include "hw/mem/pc-dimm.h"

@@ -35,10 +36,8 @@ struct PCMachineState {
      Notifier machine_done;
 
      /* Pointers to devices and objects: */
-    HotplugHandler *acpi_dev;
      ISADevice *rtc;
      PCIBus *bus;
-    FWCfgState *fw_cfg;
      qemu_irq *gsi;
 
      /* Configuration options: */

@@ -46,28 +45,20 @@ struct PCMachineState {
      OnOffAuto vmport;
      OnOffAuto smm;
 
-    AcpiNVDIMMState acpi_nvdimm_state;
-
      bool acpi_build_enabled;
      bool smbus;
      bool sata;
      bool pit;
 
-    /* RAM information (sizes, addresses, configuration): */
-    ram_addr_t below_4g_mem_size, above_4g_mem_size;
-
-    /* CPU and apic information: */
-    bool apic_xrupt_override;
-    unsigned apic_id_limit;
+    /* CPU information */
      uint16_t boot_cpus;
 

This is going to be needed by the Hardware-reduced ACPI routines.

Signed-off-by Samuel Ortiz <[email protected]>

---
  hw/acpi/aml-build.c         | 8 ++++++++
  hw/i386/acpi-build.c        | 8 --------
  include/hw/acpi/aml-build.h | 2 ++
  3 files changed, 10 insertions(+), 8 deletions(-)

hw/acpi/aml-build.c +8 -0

index 1e43cd736d..51b608432f 100644
@@ -1565,6 +1565,14 @@ unsigned acpi_data_len(GArray *table)
      return table->len;
  }
 
+void acpi_align_size(GArray *blob, unsigned align)
+{
+    /* Align size to multiple of given size. This reduces the chance
+     * we need to change size in the future (breaking cross version migration).
+     */
+    g_array_set_size(blob, ROUND_UP(acpi_data_len(blob), align));
+}
+
  void acpi_add_table(GArray *table_offsets, GArray *table_data)
  {
      uint32_t offset = table_data->len;

hw/i386/acpi-build.c +0 -8

index c8545238c4..1bf02b6a93 100644
@@ -282,14 +282,6 @@ static void acpi_get_pci_holes(Range *hole, Range *hole64)
                                                 NULL));
  }
 
-static void acpi_align_size(GArray *blob, unsigned align)
-{
-    /* Align size to multiple of given size. This reduces the chance
-     * we need to change size in the future (breaking cross version migration).
-     */
-    g_array_set_size(blob, ROUND_UP(acpi_data_len(blob), align));
-}
-
  /* FACS */
  static void
  build_facs(GArray *table_data, BIOSLinker *linker)

include/hw/acpi/aml-build.h +0 -0

index 6c36903c0a..813f51317c 100644

include/hw/acpi/aml-build.h +1 -0

+void acpi_align_size(GArray *blob, unsigned align);
  void acpi_add_table(GArray *table_offsets, GArray *table_data);
  void acpi_build_tables_init(AcpiBuildTables *tables);
  void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre);

The hardware-reduced API will need to build RSDP as well, so we should export this routine. While doing so, we also slightly change the function prototype. Since no caller needs it, and to make it more consistent with the rest of the AML build API, the function no longer returns its RSDP table.

Signed-off-by Samuel Ortiz <[email protected]>

---
  hw/acpi/aml-build.c         | 24 ++++++++++++++++++++++++
  hw/i386/acpi-build.c        | 26 --------------------------
  include/hw/acpi/aml-build.h |  3 +++
  3 files changed, 27 insertions(+), 26 deletions(-)

hw/acpi/aml-build.c +24 -0

index 51b608432f..2d6f538f9d 100644
@@ -1651,6 +1651,30 @@ build_xsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
                   (void *)xsdt, "XSDT", xsdt_len, 1, oem_id, oem_table_id);
  }
 
+void
+build_rsdp(GArray *rsdp_table, BIOSLinker *linker, unsigned rsdt_tbl_offset)
+{
+    AcpiRsdpDescriptor *rsdp = acpi_data_push(rsdp_table, sizeof *rsdp);
+    unsigned rsdt_pa_size = sizeof(rsdp->rsdt_physical_address);
+    unsigned rsdt_pa_offset =
+        (char *)&rsdp->rsdt_physical_address - rsdp_table->data;
+
+    bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, rsdp_table, 16,
+                             true /* fseg memory */);
+
+    memcpy(&rsdp->signature, "RSD PTR ", 8);
+    memcpy(rsdp->oem_id, ACPI_BUILD_APPNAME6, 6);
+    /* Address to be filled by Guest linker */
+    bios_linker_loader_add_pointer(linker,
+        ACPI_BUILD_RSDP_FILE, rsdt_pa_offset, rsdt_pa_size,
+        ACPI_BUILD_TABLE_FILE, rsdt_tbl_offset);
+
+    /* Checksum to be filled by Guest linker */
+    bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE,
+        (char *)rsdp - rsdp_table->data, sizeof *rsdp,
+        (char *)&rsdp->checksum - rsdp_table->data);
+}
+
  void build_srat_memory(AcpiSratMemoryAffinity *numamem, uint64_t base,
                         uint64_t len, int node, MemoryAffinityFlags flags)
  {

hw/i386/acpi-build.c +0 -26

index 1bf02b6a93..9f1c9f4cf5 100644
@@ -2512,32 +2512,6 @@ build_amd_iommu(GArray *table_data, BIOSLinker *linker)
                   "IVRS", table_data->len - iommu_start, 1, NULL, NULL);
  }
 
-static GArray *
-build_rsdp(GArray *rsdp_table, BIOSLinker *linker, unsigned rsdt_tbl_offset)
-{
-    AcpiRsdpDescriptor *rsdp = acpi_data_push(rsdp_table, sizeof *rsdp);
-    unsigned rsdt_pa_size = sizeof(rsdp->rsdt_physical_address);
-    unsigned rsdt_pa_offset =
-        (char *)&rsdp->rsdt_physical_address - rsdp_table->data;
-
-    bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, rsdp_table, 16,
-                             true /* fseg memory */);
-
-    memcpy(&rsdp->signature, "RSD PTR ", 8);
-    memcpy(rsdp->oem_id, ACPI_BUILD_APPNAME6, 6);
-    /* Address to be filled by Guest linker */
-    bios_linker_loader_add_pointer(linker,
-        ACPI_BUILD_RSDP_FILE, rsdt_pa_offset, rsdt_pa_size,
-        ACPI_BUILD_TABLE_FILE, rsdt_tbl_offset);
-
-    /* Checksum to be filled by Guest linker */
-    bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE,
-        (char *)rsdp - rsdp_table->data, sizeof *rsdp,
-        (char *)&rsdp->checksum - rsdp_table->data);
-
-    return rsdp_table;
-}
-
  static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg)
  {
      Object *pci_host;

include/hw/acpi/aml-build.h +0 -0

index 813f51317c..865f5d23f5 100644

include/hw/acpi/aml-build.h +1 -0

+void
  build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
             const char *oem_id, const char *oem_table_id);
  void

hw/i386/acpi-build.c +3 -513

@@ -86,11 +86,6 @@
  /* Default IOAPIC ID */
  #define ACPI_BUILD_IOAPIC_ID 0x0
 
-typedef struct AcpiMcfgInfo {
-    uint64_t mcfg_base;
-    uint32_t mcfg_size;
-} AcpiMcfgInfo;
-
  typedef struct AcpiPmInfo {
      bool s3_disabled;
      bool s4_disabled;

@@ -567,403 +562,6 @@ static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus,
      qobject_unref(bsel);
  }
 
-/**
- * build_prt_entry:
- * @link_name: link name for PCI route entry
- *
- * build AML package containing a PCI route entry for @link_name
- */
-static Aml *build_prt_entry(const char *link_name)
-{
-    Aml *a_zero = aml_int(0);
-    Aml *pkg = aml_package(4);
-    aml_append(pkg, a_zero);
-    aml_append(pkg, a_zero);
-    aml_append(pkg, aml_name("%s", link_name));
-    aml_append(pkg, a_zero);
-    return pkg;
-}
-
-/*
- * initialize_route - Initialize the interrupt routing rule
- * through a specific LINK:
- *  if (lnk_idx == idx)
- *      route using link 'link_name'
- */
-static Aml *initialize_route(Aml *route, const char *link_name,
-                             Aml *lnk_idx, int idx)
-{
-    Aml *if_ctx = aml_if(aml_equal(lnk_idx, aml_int(idx)));
-    Aml *pkg = build_prt_entry(link_name);
-
-    aml_append(if_ctx, aml_store(pkg, route));
-
-    return if_ctx;
-}
-
-/*
- * build_prt - Define interrupt rounting rules
- *
- * Returns an array of 128 routes, one for each device,
- * based on device location.
- * The main goal is to equaly distribute the interrupts
- * over the 4 existing ACPI links (works only for i440fx).
- * The hash function is  (slot + pin) & 3 -> "LNK[D|A|B|C]".
- *
- */
-static Aml *build_prt(bool is_pci0_prt)
-{
-    Aml *method, *while_ctx, *pin, *res;
-
-    method = aml_method("_PRT", 0, AML_NOTSERIALIZED);
-    res = aml_local(0);
-    pin = aml_local(1);
-    aml_append(method, aml_store(aml_package(128), res));
-    aml_append(method, aml_store(aml_int(0), pin));
-
-    /* while (pin < 128) */
-    while_ctx = aml_while(aml_lless(pin, aml_int(128)));
-    {
-        Aml *slot = aml_local(2);
-        Aml *lnk_idx = aml_local(3);
-        Aml *route = aml_local(4);
-
-        /* slot = pin >> 2 */
-        aml_append(while_ctx,
-                   aml_store(aml_shiftright(pin, aml_int(2), NULL), slot));
-        /* lnk_idx = (slot + pin) & 3 */
-        aml_append(while_ctx,
-            aml_store(aml_and(aml_add(pin, slot, NULL), aml_int(3), NULL),
-                      lnk_idx));
-
-        /* route[2] = "LNK[D|A|B|C]", selection based on pin % 3  */
-        aml_append(while_ctx, initialize_route(route, "LNKD", lnk_idx, 0));
-        if (is_pci0_prt) {
-            Aml *if_device_1, *if_pin_4, *else_pin_4;
-
-            /* device 1 is the power-management device, needs SCI */
-            if_device_1 = aml_if(aml_equal(lnk_idx, aml_int(1)));
-            {
-                if_pin_4 = aml_if(aml_equal(pin, aml_int(4)));
-                {
-                    aml_append(if_pin_4,
-                        aml_store(build_prt_entry("LNKS"), route));
-                }
-                aml_append(if_device_1, if_pin_4);
-                else_pin_4 = aml_else();
-                {
-                    aml_append(else_pin_4,
-                        aml_store(build_prt_entry("LNKA"), route));
-                }
-                aml_append(if_device_1, else_pin_4);
-            }
-            aml_append(while_ctx, if_device_1);
-        } else {
-            aml_append(while_ctx, initialize_route(route, "LNKA", lnk_idx, 1));
-        }
-        aml_append(while_ctx, initialize_route(route, "LNKB", lnk_idx, 2));
-        aml_append(while_ctx, initialize_route(route, "LNKC", lnk_idx, 3));
-
-        /* route[0] = 0x[slot]FFFF */
-        aml_append(while_ctx,
-            aml_store(aml_or(aml_shiftleft(slot, aml_int(16)), aml_int(0xFFFF),
-                             NULL),
-                      aml_index(route, aml_int(0))));
-        /* route[1] = pin & 3 */
-        aml_append(while_ctx,
-            aml_store(aml_and(pin, aml_int(3), NULL),
-                      aml_index(route, aml_int(1))));
-        /* res[pin] = route */
-        aml_append(while_ctx, aml_store(route, aml_index(res, pin)));
-        /* pin++ */
-        aml_append(while_ctx, aml_increment(pin));
-    }
-    aml_append(method, while_ctx);
-    /* return res*/
-    aml_append(method, aml_return(res));
-
-    return method;
-}
-
-typedef struct CrsRangeEntry {
-    uint64_t base;
-    uint64_t limit;
-} CrsRangeEntry;
-
-static void crs_range_insert(GPtrArray *ranges, uint64_t base, uint64_t limit)
-{
-    CrsRangeEntry *entry;
-
-    entry = g_malloc(sizeof(*entry));
-    entry->base = base;
-    entry->limit = limit;
-
-    g_ptr_array_add(ranges, entry);
-}
-
-static void crs_range_free(gpointer data)
-{
-    CrsRangeEntry *entry = (CrsRangeEntry *)data;
-    g_free(entry);
-}
-
-typedef struct CrsRangeSet {
-    GPtrArray *io_ranges;
-    GPtrArray *mem_ranges;
-    GPtrArray *mem_64bit_ranges;
- } CrsRangeSet;
-
-static void crs_range_set_init(CrsRangeSet *range_set)
-{
-    range_set->io_ranges = g_ptr_array_new_with_free_func(crs_range_free);
-    range_set->mem_ranges = g_ptr_array_new_with_free_func(crs_range_free);
-    range_set->mem_64bit_ranges =
-            g_ptr_array_new_with_free_func(crs_range_free);
-}
-
-static void crs_range_set_free(CrsRangeSet *range_set)
-{
-    g_ptr_array_free(range_set->io_ranges, true);
-    g_ptr_array_free(range_set->mem_ranges, true);
-    g_ptr_array_free(range_set->mem_64bit_ranges, true);
-}
-
-static gint crs_range_compare(gconstpointer a, gconstpointer b)
-{
-     CrsRangeEntry *entry_a = *(CrsRangeEntry **)a;
-     CrsRangeEntry *entry_b = *(CrsRangeEntry **)b;
-
-     return (int64_t)entry_a->base - (int64_t)entry_b->base;
-}
-
-/*
- * crs_replace_with_free_ranges - given the 'used' ranges within [start - end]
- * interval, computes the 'free' ranges from the same interval.
- * Example: If the input array is { [a1 - a2],[b1 - b2] }, the function
- * will return { [base - a1], [a2 - b1], [b2 - limit] }.
- */
-static void crs_replace_with_free_ranges(GPtrArray *ranges,
-                                         uint64_t start, uint64_t end)
-{
-    GPtrArray *free_ranges = g_ptr_array_new();
-    uint64_t free_base = start;
-    int i;
-
-    g_ptr_array_sort(ranges, crs_range_compare);
-    for (i = 0; i < ranges->len; i++) {
-        CrsRangeEntry *used = g_ptr_array_index(ranges, i);
-
-        if (free_base < used->base) {
-            crs_range_insert(free_ranges, free_base, used->base - 1);
-        }
-
-        free_base = used->limit + 1;
-    }
-
-    if (free_base < end) {
-        crs_range_insert(free_ranges, free_base, end);
-    }
-
-    g_ptr_array_set_size(ranges, 0);
-    for (i = 0; i < free_ranges->len; i++) {
-        g_ptr_array_add(ranges, g_ptr_array_index(free_ranges, i));
-    }
-
-    g_ptr_array_free(free_ranges, true);
-}
-
-/*
- * crs_range_merge - merges adjacent ranges in the given array.
- * Array elements are deleted and replaced with the merged ranges.
- */
-static void crs_range_merge(GPtrArray *range)
-{
-    GPtrArray *tmp =  g_ptr_array_new_with_free_func(crs_range_free);
-    CrsRangeEntry *entry;
-    uint64_t range_base, range_limit;
-    int i;
-
-    if (!range->len) {
-        return;
-    }
-
-    g_ptr_array_sort(range, crs_range_compare);
-
-    entry = g_ptr_array_index(range, 0);
-    range_base = entry->base;
-    range_limit = entry->limit;
-    for (i = 1; i < range->len; i++) {
-        entry = g_ptr_array_index(range, i);
-        if (entry->base - 1 == range_limit) {
-            range_limit = entry->limit;
-        } else {
-            crs_range_insert(tmp, range_base, range_limit);
-            range_base = entry->base;
-            range_limit = entry->limit;
-        }
-    }
-    crs_range_insert(tmp, range_base, range_limit);
-
-    g_ptr_array_set_size(range, 0);
-    for (i = 0; i < tmp->len; i++) {
-        entry = g_ptr_array_index(tmp, i);
-        crs_range_insert(range, entry->base, entry->limit);
-    }
-    g_ptr_array_free(tmp, true);
-}
-
-static Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set)
-{
-    Aml *crs = aml_resource_template();
-    CrsRangeSet temp_range_set;
-    CrsRangeEntry *entry;
-    uint8_t max_bus = pci_bus_num(host->bus);
-    uint8_t type;
-    int devfn;
-    int i;
-
-    crs_range_set_init(&temp_range_set);
-    for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) {
-        uint64_t range_base, range_limit;
-        PCIDevice *dev = host->bus->devices[devfn];
-
-        if (!dev) {
-            continue;
-        }
-
-        for (i = 0; i < PCI_NUM_REGIONS; i++) {
-            PCIIORegion *r = &dev->io_regions[i];
-
-            range_base = r->addr;
-            range_limit = r->addr + r->size - 1;
-
-            /*
-             * Work-around for old bioses
-             * that do not support multiple root buses
-             */
-            if (!range_base || range_base > range_limit) {
-                continue;
-            }
-
-            if (r->type & PCI_BASE_ADDRESS_SPACE_IO) {
-                crs_range_insert(temp_range_set.io_ranges,
-                                 range_base, range_limit);
-            } else { /* "memory" */
-                crs_range_insert(temp_range_set.mem_ranges,
-                                 range_base, range_limit);
-            }
-        }
-
-        type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION;
-        if (type == PCI_HEADER_TYPE_BRIDGE) {
-            uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS];
-            if (subordinate > max_bus) {
-                max_bus = subordinate;
-            }
-
-            range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO);
-            range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO);
-
-            /*
-             * Work-around for old bioses
-             * that do not support multiple root buses
-             */
-            if (range_base && range_base <= range_limit) {
-                crs_range_insert(temp_range_set.io_ranges,
-                                 range_base, range_limit);
-            }
-
-            range_base =
-                pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY);
-            range_limit =
-                pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY);
-
-            /*
-             * Work-around for old bioses
-             * that do not support multiple root buses
-             */
-            if (range_base && range_base <= range_limit) {
-                uint64_t length = range_limit - range_base + 1;
-                if (range_limit <= UINT32_MAX && length <= UINT32_MAX) {
-                    crs_range_insert(temp_range_set.mem_ranges,
-                                     range_base, range_limit);
-                } else {
-                    crs_range_insert(temp_range_set.mem_64bit_ranges,
-                                     range_base, range_limit);
-                }
-            }
-
-            range_base =
-                pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH);
-            range_limit =
-                pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH);
-
-            /*
-             * Work-around for old bioses
-             * that do not support multiple root buses
-             */
-            if (range_base && range_base <= range_limit) {
-                uint64_t length = range_limit - range_base + 1;
-                if (range_limit <= UINT32_MAX && length <= UINT32_MAX) {
-                    crs_range_insert(temp_range_set.mem_ranges,
-                                     range_base, range_limit);
-                } else {
-                    crs_range_insert(temp_range_set.mem_64bit_ranges,
-                                     range_base, range_limit);
-                }
-            }
-        }
-    }
-
-    crs_range_merge(temp_range_set.io_ranges);
-    for (i = 0; i < temp_range_set.io_ranges->len; i++) {
-        entry = g_ptr_array_index(temp_range_set.io_ranges, i);
-        aml_append(crs,
-                   aml_word_io(AML_MIN_FIXED, AML_MAX_FIXED,
-                               AML_POS_DECODE, AML_ENTIRE_RANGE,
-                               0, entry->base, entry->limit, 0,
-                               entry->limit - entry->base + 1));
-        crs_range_insert(range_set->io_ranges, entry->base, entry->limit);
-    }
-
-    crs_range_merge(temp_range_set.mem_ranges);
-    for (i = 0; i < temp_range_set.mem_ranges->len; i++) {
-        entry = g_ptr_array_index(temp_range_set.mem_ranges, i);
-        aml_append(crs,
-                   aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED,
-                                    AML_MAX_FIXED, AML_NON_CACHEABLE,
-                                    AML_READ_WRITE,
-                                    0, entry->base, entry->limit, 0,
-                                    entry->limit - entry->base + 1));
-        crs_range_insert(range_set->mem_ranges, entry->base, entry->limit);
-    }
-
-    crs_range_merge(temp_range_set.mem_64bit_ranges);
-    for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) {
-        entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i);
-        aml_append(crs,
-                   aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED,
-                                    AML_MAX_FIXED, AML_NON_CACHEABLE,
-                                    AML_READ_WRITE,
-                                    0, entry->base, entry->limit, 0,
-                                    entry->limit - entry->base + 1));
-        crs_range_insert(range_set->mem_64bit_ranges,
-                         entry->base, entry->limit);
-    }
-
-    crs_range_set_free(&temp_range_set);
-
-    aml_append(crs,
-        aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE,
-                            0,
-                            pci_bus_num(host->bus),
-                            max_bus,
-                            0,
-                            max_bus - pci_bus_num(host->bus) + 1));
-
-    return crs;
-}
-
  static void build_hpet_aml(Aml *table)
  {
      Aml *crs;

@@ -1334,37 +932,6 @@ static Aml *build_link_dev(const char *name, uint8_t uid, Aml *reg)
      return dev;
   }
 
-static Aml *build_gsi_link_dev(const char *name, uint8_t uid, uint8_t gsi)
-{
-    Aml *dev;
-    Aml *crs;
-    Aml *method;
-    uint32_t irqs;
-
-    dev = aml_device("%s", name);
-    aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0C0F")));
-    aml_append(dev, aml_name_decl("_UID", aml_int(uid)));
-
-    crs = aml_resource_template();
-    irqs = gsi;
-    aml_append(crs, aml_interrupt(AML_CONSUMER, AML_LEVEL, AML_ACTIVE_HIGH,
-                                  AML_SHARED, &irqs, 1));
-    aml_append(dev, aml_name_decl("_PRS", crs));
-
-    aml_append(dev, aml_name_decl("_CRS", crs));
-
-    /*
-     * _DIS can be no-op because the interrupt cannot be disabled.
-     */
-    method = aml_method("_DIS", 0, AML_NOTSERIALIZED);
-    aml_append(dev, method);
-
-    method = aml_method("_SRS", 1, AML_NOTSERIALIZED);
-    aml_append(dev, method);
-
-    return dev;
-}
-
  /* _CRS method - get current settings */
  static Aml *build_iqcr_method(bool is_piix4)
  {

@@ -1728,54 +1295,6 @@ static void build_piix4_pci_hotplug(Aml *table)
      aml_append(table, scope);
  }
 
-static Aml *build_q35_osc_method(void)
-{
-    Aml *if_ctx;
-    Aml *if_ctx2;
-    Aml *else_ctx;
-    Aml *method;
-    Aml *a_cwd1 = aml_name("CDW1");
-    Aml *a_ctrl = aml_local(0);
-
-    method = aml_method("_OSC", 4, AML_NOTSERIALIZED);
-    aml_append(method, aml_create_dword_field(aml_arg(3), aml_int(0), "CDW1"));
-
-    if_ctx = aml_if(aml_equal(
-        aml_arg(0), aml_touuid("33DB4D5B-1FF7-401C-9657-7441C03DD766")));
-    aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(4), "CDW2"));
-    aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(8), "CDW3"));
-
-    aml_append(if_ctx, aml_store(aml_name("CDW3"), a_ctrl));
-
-    /*
-     * Always allow native PME, AER (no dependencies)
-     * Allow SHPC (PCI bridges can have SHPC controller)
-     */
-    aml_append(if_ctx, aml_and(a_ctrl, aml_int(0x1F), a_ctrl));
-
-    if_ctx2 = aml_if(aml_lnot(aml_equal(aml_arg(1), aml_int(1))));
-    /* Unknown revision */
-    aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x08), a_cwd1));
-    aml_append(if_ctx, if_ctx2);
-
-    if_ctx2 = aml_if(aml_lnot(aml_equal(aml_name("CDW3"), a_ctrl)));
-    /* Capabilities bits were masked */
-    aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x10), a_cwd1));
-    aml_append(if_ctx, if_ctx2);
-
-    /* Update DWORD3 in the buffer */
-    aml_append(if_ctx, aml_store(a_ctrl, aml_name("CDW3")));
-    aml_append(method, if_ctx);
-
-    else_ctx = aml_else();
-    /* Unrecognized UUID */
-    aml_append(else_ctx, aml_or(a_cwd1, aml_int(4), a_cwd1));
-    aml_append(method, else_ctx);
-
-    aml_append(method, aml_return(aml_arg(3)));
-    return method;
-}
-
  static void
  build_dsdt(GArray *table_data, BIOSLinker *linker,
             AcpiPmInfo *pm, AcpiMiscInfo *misc,

@@ -1818,7 +1337,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker,
          aml_append(dev, aml_name_decl("_CID", aml_eisaid("PNP0A03")));
          aml_append(dev, aml_name_decl("_ADR", aml_int(0)));
          aml_append(dev, aml_name_decl("_UID", aml_int(1)));
-        aml_append(dev, build_q35_osc_method());
+        aml_append(dev, build_osc_method());
          aml_append(sb_scope, dev);
          aml_append(dsdt, sb_scope);
 

@@ -1883,7 +1402,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker,
              aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0A03")));
              aml_append(dev, aml_name_decl("_BBN", aml_int(bus_num)));
              if (pci_bus_is_express(bus)) {
-                aml_append(dev, build_q35_osc_method());
+                aml_append(dev, build_osc_method());
              }
 
              if (numa_node != NUMA_NODE_UNASSIGNED) {

@@ -2369,35 +1888,6 @@ build_srat(GArray *table_data, BIOSLinker *linker,
                   table_data->len - srat_start, 1, NULL, NULL);
  }
 
-static void
-build_mcfg_q35(GArray *table_data, BIOSLinker *linker, AcpiMcfgInfo *info)
-{
-    AcpiTableMcfg *mcfg;
-    const char *sig;
-    int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]);
-
-    mcfg = acpi_data_push(table_data, len);
-    mcfg->allocation[0].address = cpu_to_le64(info->mcfg_base);
-    /* Only a single allocation so no need to play with segments */
-    mcfg->allocation[0].pci_segment = cpu_to_le16(0);
-    mcfg->allocation[0].start_bus_number = 0;
-    mcfg->allocation[0].end_bus_number = PCIE_MMCFG_BUS(info->mcfg_size - 1);
-
-    /* MCFG is used for ECAM which can be enabled or disabled by guest.
-     * To avoid table size changes (which create migration issues),
-     * always create the table even if there are no allocations,
-     * but set the signature to a reserved value in this case.
-     * ACPI spec requires OSPMs to ignore such tables.
-     */
-    if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) {
-        /* Reserved signature: ignored by OSPM */
-        sig = "QEMU";
-    } else {
-        sig = "MCFG";
-    }
-    build_header(linker, table_data, (void *)mcfg, sig, len, 1, NULL, NULL);
-}
-
  /*
   * VT-d spec 8.1 DMA Remapping Reporting Structure
   * (version Oct. 2014 or later)

@@ -2625,7 +2115,7 @@ void acpi_build(AcpiBuildTables *tables,
      }
      if (acpi_get_mcfg(&mcfg)) {
          acpi_add_table(table_offsets, tables_blob);
-        build_mcfg_q35(tables_blob, tables->linker, &mcfg);
+        build_mcfg(tables_blob, tables->linker, &mcfg);
      }
      if (x86_iommu_get_default()) {
          IommuType IOMMUType = x86_iommu_get_type();

include/hw/acpi/aml-build.h +25 -0

index 8d1063a40b..cd744e9472 100644
@@ -3,6 +3,7 @@
 
  #include "hw/acpi/acpi-defs.h"
  #include "hw/acpi/bios-linker-loader.h"
+#include "hw/pci/pcie_host.h"
 
  /* Reserve RAM space for tables: add another order of magnitude. */
  #define ACPI_BUILD_TABLE_MAX_SIZE         0x200000

@@ -224,6 +225,21 @@ struct AcpiBuildTables {
      BIOSLinker *linker;
  } AcpiBuildTables;
 
+typedef struct AcpiMcfgInfo {
+    uint64_t mcfg_base;
+    uint32_t mcfg_size;
+} AcpiMcfgInfo;
+
+typedef struct CrsRangeEntry {
+    uint64_t base;
+    uint64_t limit;
+} CrsRangeEntry;
+
+typedef struct CrsRangeSet {
+    GPtrArray *io_ranges;
+    GPtrArray *mem_ranges;
+    GPtrArray *mem_64bit_ranges;
+} CrsRangeSet;
  /**
   * init_aml_allocator:
   *

@@ -389,6 +405,15 @@ void acpi_align_size(GArray *blob, unsigned align);
  void acpi_add_table(GArray *table_offsets, GArray *table_data);
  void acpi_build_tables_init(AcpiBuildTables *tables);
  void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre);
+Aml *build_osc_method(void);
+void build_mcfg(GArray *table_data, BIOSLinker *linker, AcpiMcfgInfo *info);
+Aml *build_gsi_link_dev(const char *name, uint8_t uid, uint8_t gsi);
+Aml *build_prt(bool is_pci0_prt);
+void crs_range_set_init(CrsRangeSet *range_set);
+Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set);
+void crs_replace_with_free_ranges(GPtrArray *ranges,
+                                  uint64_t start, uint64_t end);
+void crs_range_set_free(CrsRangeSet *range_set);
  void
  build_rsdp_rsdt(GArray *table_data,
                  BIOSLinker *linker, unsigned rsdt_tbl_offset);