Enable propolis to generate ACPI tables (#999)

Introduce ACPI table generation to Propolis and load them into guests
using QEMU's Firmware Configuration (`fw_cfg`) protocol.

This initial implementation of the tables produce the exact same AML
bytecode as the one provided by EDKII OVMF firmware, that is why it
still contains some elements that do not make sense in Propolis. Future
work will modernize and make these tables more specific to Propolis.

To avoid unexpected changes on reboot, the ACPI tables that are
generated and loaded into guests is versioned using the `AcpiVariant`
enum.

The `acpi` module contains the table generation logic and uses the
`acpi_tables` crate to generate the AML bytecode for the tables. 

Devices can generate their own AML code by implementing the
`DsdtGenerator` trait and returning themselves in the method
`as_dsdt_generator` of the `Lifecyle` trait.

```
impl Lifecycle for ... {
    fn as_dsdt_generator(&self) -> Option<&dyn acpi::DsdtGenerator> {
        Some(self)
    }
    // ...
}
```

The `to_aml_bytes()` method of `DsdtGenerator` provides a metadata
storage that can be populated during VM initialization with information
needed for the AML code. Devices also need to implement the
`DeviceMetadata` trait to store and retrieve metadata from this storage.

Currently only the PS2 controller and UART serial ports generate their
own AML because they are the only ones that can be generated to be
identical to the original EDKII tables. Future ACPI table variants may
be able to generate AML code directly from other devices.

Co-authored-by: Luiz Aoqui <luiz@oxidecomputer.com>
Co-authored-by: iximeow <git@iximeow.net>

Author: 3 people

.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.lock

@@ -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 = { git = 'https://github.com/oxidecomputer/acpi_tables.git', tag = "v0.2.1-oxide.1" }
 anyhow = "1.0"
 async-trait = "0.1.88"
 atty = "0.2.14"

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/Cargo.toml

@@ -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/initializer.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/builder.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/spec/mod.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-server/src/lib/vm/ensure.rs

@@ -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/Cargo.toml

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