Enable propolis to generate ACPI tables

.gitignore

@@ -4,3 +4,8 @@
 debug.out
 core
 out/
+
+# Ignore all binary and decompiled ACPI files except the ones used for tests.
+*.dat
+*.dsl
+!phd-tests/tests/testdata/acpi/**/*.dat

Cargo.toml

@@ -100,6 +100,7 @@ dice-verifier = { git = "https://github.com/oxidecomputer/dice-util", rev = "d74
 vm-attest = { git = "https://github.com/oxidecomputer/vm-attest", rev = "deaf0203ecfa8cbe8c0c28c9bd16645d5d7be4e8", default-features = false }
 
 # External dependencies
+acpi_tables = "0.2.0"
 anyhow = "1.0"
 async-trait = "0.1.88"
 atty = "0.2.14"
@@ -192,6 +193,8 @@ usdt = { version = "0.6", default-features = false }
 uuid = "1.3.2"
 zerocopy = "0.8.25"
 
+[patch.crates-io]
+acpi_tables = { git = 'https://github.com/oxidecomputer/acpi_tables.git', tag = "v0.2.1-oxide.1" }
 
 #
 # It's common during development to use a local copy of various complex

bin/propolis-server/Cargo.toml

@@ -84,6 +84,7 @@ proptest.workspace = true
 
 [features]
 default = []
+acpi-debug = ["propolis/acpi-debug"]
 
 # When building to be packaged for inclusion in the production ramdisk
 # (nominally an Omicron package), certain code is compiled in or out.

bin/propolis-server/src/lib/initializer.rs

@@ -29,10 +29,10 @@ use propolis::attestation::server::AttestationServerConfig;
 use propolis::attestation::server::AttestationSock;
 use propolis::block;
 use propolis::chardev::{self, BlockingSource, Source};
-use propolis::common::{Lifecycle, GB, MB, PAGE_SIZE};
+use propolis::common::{DeviceMetadataMap, Lifecycle, GB, MB, PAGE_SIZE};
 use propolis::cpuid::TopoKind;
 use propolis::enlightenment::Enlightenment;
-use propolis::firmware::smbios;
+use propolis::firmware::{acpi, smbios};
 use propolis::hw::bhyve::BhyveHpet;
 use propolis::hw::chipset::{i440fx, Chipset};
 use propolis::hw::ibmpc;
@@ -45,7 +45,7 @@ use propolis::hw::qemu::{
     fwcfg::{self, Entry},
     ramfb,
 };
-use propolis::hw::uart::LpcUart;
+use propolis::hw::uart::{LpcUart, LpcUartMetadata};
 use propolis::hw::{nvme, virtio};
 use propolis::intr_pins;
 use propolis::vmm::{self, Builder, Machine};
@@ -107,6 +107,9 @@ pub enum MachineInitError {
     #[error("boot entry {0:?} refers to a device on non-zero PCI bus {1}")]
     BootDeviceOnDownstreamPciBus(SpecKey, u8),
 
+    #[error("failed to generate ACPI tables: {0}")]
+    AcpiTableError(#[from] fwcfg::formats::AcpiTablesError),
+
     #[error("failed to insert {0} fwcfg entry")]
     FwcfgInsertFailed(&'static str, #[source] fwcfg::InsertError),
 
@@ -124,6 +127,15 @@ pub enum MachineInitError {
 /// Arbitrary ROM limit for now
 const MAX_ROM_SIZE: usize = 0x20_0000;
 
+/// End address of the 32-bit PCI MMIO window.
+///
+// Value inherited from the original EDK2 static tables.
+// https://github.com/oxidecomputer/edk2/blob/f33871f488bfbbc080e0f7e3881e04d0db0b6367/OvmfPkg/PlatformPei/Platform.c#L180-L192
+//
+// It should be updated to match the actual memory regions registered in the
+// instance.
+const PCI_MMIO32_END: usize = 0xfeef_ffff;
+
 fn get_spec_guest_ram_limits(spec: &Spec) -> (usize, usize) {
     let memsize = spec.board.memory_mb as usize * MB;
     let lowmem = memsize.min(3 * GB);
@@ -204,6 +216,7 @@ pub struct MachineInitializer<'a> {
     pub(crate) log: slog::Logger,
     pub(crate) machine: &'a Machine,
     pub(crate) devices: DeviceMap,
+    pub(crate) device_metadata: DeviceMetadataMap,
     pub(crate) block_backends: BlockBackendMap,
     pub(crate) crucible_backends: CrucibleBackendMap,
     pub(crate) spec: &'a Spec,
@@ -406,17 +419,28 @@ impl MachineInitializer<'_> {
                 continue;
             }
 
-            let (irq, port) = match desc.num {
-                SerialPortNumber::Com1 => (ibmpc::IRQ_COM1, ibmpc::PORT_COM1),
-                SerialPortNumber::Com2 => (ibmpc::IRQ_COM2, ibmpc::PORT_COM2),
-                SerialPortNumber::Com3 => (ibmpc::IRQ_COM3, ibmpc::PORT_COM3),
-                SerialPortNumber::Com4 => (ibmpc::IRQ_COM4, ibmpc::PORT_COM4),
+            let (num, irq, port) = match desc.num {
+                SerialPortNumber::Com1 => {
+                    (1, ibmpc::IRQ_COM1, ibmpc::PORT_COM1)
+                }
+                SerialPortNumber::Com2 => {
+                    (2, ibmpc::IRQ_COM2, ibmpc::PORT_COM2)
+                }
+                SerialPortNumber::Com3 => {
+                    (3, ibmpc::IRQ_COM3, ibmpc::PORT_COM3)
+                }
+                SerialPortNumber::Com4 => {
+                    (4, ibmpc::IRQ_COM4, ibmpc::PORT_COM4)
+                }
             };
 
             let dev = LpcUart::new(chipset.irq_pin(irq).unwrap());
             dev.set_autodiscard(true);
             LpcUart::attach(&dev, &self.machine.bus_pio, port);
             self.devices.insert(name.to_owned(), dev.clone());
+            self.device_metadata
+                .insert(&dev, Box::new(LpcUartMetadata::new(num, port, irq)));
+
             if desc.num == SerialPortNumber::Com1 {
                 assert!(com1.is_none());
                 com1 = Some(dev);
@@ -1110,9 +1134,17 @@ impl MachineInitializer<'_> {
         // NOTE: SoftNpu squats on com4.
         let uart = LpcUart::new(chipset.irq_pin(ibmpc::IRQ_COM4).unwrap());
         uart.set_autodiscard(true);
-        LpcUart::attach(&uart, &self.machine.bus_pio, ibmpc::PORT_COM4);
+        uart.attach(&self.machine.bus_pio, ibmpc::PORT_COM4);
         self.devices
             .insert(SpecKey::Name("softnpu-uart".to_string()), uart.clone());
+        self.device_metadata.insert(
+            &uart,
+            Box::new(LpcUartMetadata::new(
+                4,
+                ibmpc::PORT_COM4,
+                ibmpc::IRQ_COM4,
+            )),
+        );
 
         // Start with no pipeline. The guest must load the initial P4 program.
         let pipeline = Arc::new(std::sync::Mutex::new(None));
@@ -1433,14 +1465,52 @@ impl MachineInitializer<'_> {
         Ok(Some(order.finish()))
     }
 
+    fn generate_acpi_tables(
+        &self,
+        acpi_variant: acpi::AcpiVariant,
+        cpus: u8,
+    ) -> Result<fwcfg::formats::AcpiTables, MachineInitError> {
+        let (lowmem, _) = get_spec_guest_ram_limits(self.spec);
+        let generators: Vec<_> = self
+            .devices
+            .values()
+            .filter_map(|dev| dev.as_dsdt_generator())
+            .collect();
+
+        // The values for pci_window_32 and pci_window_64 are set based on the
+        // original EDK2 ACPI tables, and currently don't exactly match the
+        // ranges defined in build_instance().
+        //
+        // Propolis doesn't verify if an MMIO operation happens in an address
+        // reserved for MMIO, so this doesn't cause problems for now, but the
+        // PCI windows should be updated to match what's reserved in
+        // build_instance().
+        let pci_window_32 = fwcfg::formats::PciWindow::new(
+            lowmem as u64,
+            PCI_MMIO32_END as u64,
+        )?;
+
+        let config = &fwcfg::formats::AcpiConfig {
+            acpi_variant,
+            num_cpus: cpus,
+            pci_window_32,
+            pci_window_64: fwcfg::formats::PciWindow::empty(),
+            dsdt_generators: &generators,
+            device_metadata: &self.device_metadata,
+        };
+        let acpi_tables = fwcfg::formats::AcpiTablesBuilder::new(config);
+        Ok(acpi_tables.build())
+    }
+
     /// Initialize qemu `fw_cfg` device, and populate it with data including CPU
-    /// count, SMBIOS tables, and attached RAM-FB device.
+    /// count, SMBIOS and ACPI tables, and attached RAM-FB device.
     ///
     /// Should not be called before [`Self::initialize_rom()`].
     pub fn initialize_fwcfg(
         &mut self,
         cpus: u8,
         bootrom_version: &Option<String>,
+        acpi_variant: acpi::AcpiVariant,
     ) -> Result<Arc<ramfb::RamFb>, MachineInitError> {
         let fwcfg = fwcfg::FwCfg::new();
         fwcfg
@@ -1479,6 +1549,19 @@ impl MachineInitializer<'_> {
             .insert_named("etc/e820", e820_entry)
             .map_err(|e| MachineInitError::FwcfgInsertFailed("e820", e))?;
 
+        let acpi_entries = self.generate_acpi_tables(acpi_variant, cpus)?;
+        fwcfg.insert_named("etc/acpi/tables", acpi_entries.tables).map_err(
+            |e| MachineInitError::FwcfgInsertFailed("acpi/tables", e),
+        )?;
+        fwcfg
+            .insert_named("etc/acpi/rsdp", acpi_entries.rsdp)
+            .map_err(|e| MachineInitError::FwcfgInsertFailed("acpi/rsdp", e))?;
+        fwcfg
+            .insert_named("etc/table-loader", acpi_entries.table_loader)
+            .map_err(|e| {
+                MachineInitError::FwcfgInsertFailed("table-loader", e)
+            })?;
+
         let ramfb = ramfb::RamFb::create(
             self.log.new(slog::o!("component" => "ramfb")),
         );

bin/propolis-server/src/lib/spec/builder.rs

@@ -100,6 +100,7 @@ impl SpecBuilder {
                     memory_mb: board.memory_mb,
                     chipset: board.chipset,
                     guest_hv_interface: board.guest_hv_interface,
+                    acpi_variant: propolis::firmware::acpi::AcpiVariant::V0,
                 },
                 cpuid,
                 ..Default::default()
@@ -403,6 +404,7 @@ mod test {
             memory_mb: 512,
             chipset: Chipset::I440Fx(I440Fx { enable_pcie: false }),
             guest_hv_interface: GuestHypervisorInterface::Bhyve,
+            acpi_variant: propolis::firmware::acpi::AcpiVariant::V0,
         };
 
         SpecBuilder {

bin/propolis-server/src/lib/spec/mod.rs

@@ -42,6 +42,7 @@ use thiserror::Error;
 #[cfg(feature = "failure-injection")]
 use propolis_api_types::instance_spec::components::devices::MigrationFailureInjector;
 
+use propolis::firmware::acpi::AcpiVariant;
 #[cfg(feature = "falcon")]
 use propolis_api_types::instance_spec::components::{
     backends::DlpiNetworkBackend,
@@ -160,6 +161,9 @@ pub(crate) struct Board {
     pub memory_mb: u64,
     pub chipset: Chipset,
     pub guest_hv_interface: GuestHypervisorInterface,
+
+    // XXX: expose via the API once more variants are implemented.
+    pub acpi_variant: AcpiVariant,
 }
 
 impl Default for Board {
@@ -169,6 +173,7 @@ impl Default for Board {
             memory_mb: 0,
             chipset: Chipset::I440Fx(I440Fx { enable_pcie: false }),
             guest_hv_interface: GuestHypervisorInterface::Bhyve,
+            acpi_variant: AcpiVariant::V0,
         }
     }
 }

bin/propolis-server/src/lib/vm/ensure.rs

@@ -93,6 +93,7 @@ use std::sync::Arc;
 
 use oximeter::types::ProducerRegistry;
 use oximeter_instruments::kstat::KstatSampler;
+use propolis::common::DeviceMetadataMap;
 use propolis::enlightenment::{
     bhyve::BhyveGuestInterface,
     hyperv::{Features as HyperVFeatures, HyperV},
@@ -532,6 +533,7 @@ async fn initialize_vm_objects(
         log: log.clone(),
         machine: &machine,
         devices: Default::default(),
+        device_metadata: DeviceMetadataMap::new(),
         block_backends: Default::default(),
         crucible_backends: Default::default(),
         spec: &spec,
@@ -579,8 +581,11 @@ async fn initialize_vm_objects(
         .initialize_storage_devices(&chipset, options.nexus_client.clone())
         .await?;
 
-    let ramfb =
-        init.initialize_fwcfg(spec.board.cpus, &options.bootrom_version)?;
+    let ramfb = init.initialize_fwcfg(
+        spec.board.cpus,
+        &options.bootrom_version,
+        spec.board.acpi_variant,
+    )?;
 
     // If we have a VM RoT, that RoT needs to be able to collect some
     // information about the guest before it can be actually usable. It will do

bin/propolis-standalone/Cargo.toml

@@ -44,3 +44,4 @@ pbind.workspace = true
 [features]
 default = []
 crucible = ["propolis/crucible-full", "propolis/oximeter", "crucible-client-types"]
+acpi-debug = ["propolis/acpi-debug"]

bin/propolis-standalone/src/config.rs

@@ -18,6 +18,7 @@ use serde::{Deserialize, Serialize};
 
 use cpuid_profile_config::*;
 use propolis::block;
+use propolis::firmware::acpi::AcpiVariant;
 use propolis::hw::pci::Bdf;
 
 use crate::cidata::build_cidata_be;
@@ -71,6 +72,12 @@ pub struct Main {
 
     /// Request bootrom override boot order using the devices specified
     pub boot_order: Option<Vec<String>>,
+
+    /// ACPI table variant to use for the VM
+    ///
+    /// Default: V0
+    #[serde(default)]
+    pub acpi_variant: AcpiVariant,
 }
 
 #[derive(Copy, Clone, Debug, Deserialize, Serialize)]