acpi: add acpi_variant and constructors

Introduce the concept of ACPI variant, which can be use to version ACPI
tables and standandardize table generation using configuration structs
and `new` constructor methods.

Author: lgfa29

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

@@ -32,7 +32,7 @@ use propolis::chardev::{self, BlockingSource, Source};
 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;
@@ -1467,6 +1467,7 @@ impl MachineInitializer<'_> {
 
     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);
@@ -1490,6 +1491,7 @@ impl MachineInitializer<'_> {
         )?;
 
         let config = &fwcfg::formats::AcpiConfig {
+            acpi_variant,
             num_cpus: cpus,
             pci_window_32,
             pci_window_64: fwcfg::formats::PciWindow::empty(),
@@ -1508,6 +1510,7 @@ impl MachineInitializer<'_> {
         &mut self,
         cpus: u8,
         bootrom_version: &Option<String>,
+        acpi_variant: acpi::AcpiVariant,
     ) -> Result<Arc<ramfb::RamFb>, MachineInitError> {
         let fwcfg = fwcfg::FwCfg::new();
         fwcfg
@@ -1546,7 +1549,7 @@ impl MachineInitializer<'_> {
             .insert_named("etc/e820", e820_entry)
             .map_err(|e| MachineInitError::FwcfgInsertFailed("e820", e))?;
 
-        let acpi_entries = self.generate_acpi_tables(cpus)?;
+        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),
         )?;

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,
+                    ..Default::default()
                 },
                 cpuid,
                 ..Default::default()
@@ -403,6 +404,7 @@ mod test {
             memory_mb: 512,
             chipset: Chipset::I440Fx(I440Fx { enable_pcie: false }),
             guest_hv_interface: GuestHypervisorInterface::Bhyve,
+            ..Default::default()
         };
 
         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

@@ -581,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/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)]

bin/propolis-standalone/src/main.rs

@@ -24,7 +24,7 @@ use tokio::runtime;
 
 use propolis::chardev::{BlockingSource, Sink, Source, UDSock};
 use propolis::common::{DeviceMetadataMap, GB, MB};
-use propolis::firmware::smbios;
+use propolis::firmware::{acpi, smbios};
 use propolis::hw::chipset::{i440fx, Chipset};
 use propolis::hw::ps2::ctrl::PS2Ctrl;
 use propolis::hw::qemu::fwcfg;
@@ -1081,11 +1081,15 @@ fn generate_bootorder(
 }
 
 fn generate_acpi_tables(
-    cpus: u8,
+    acpi_variant: acpi::AcpiVariant,
+    num_cpus: u8,
     lowmem: usize,
     inventory: &Inventory,
     device_metadata: &DeviceMetadataMap,
+    log: &slog::Logger,
 ) -> anyhow::Result<fwcfg::formats::AcpiTables> {
+    slog::info!(log, "Generating ACPI tables with variant {:?}", acpi_variant);
+
     let generators: Vec<_> = inventory
         .devs
         .values()
@@ -1105,7 +1109,8 @@ fn generate_acpi_tables(
             .context("invalid PCI window range")?;
 
     let config = &fwcfg::formats::AcpiConfig {
-        num_cpus: cpus,
+        acpi_variant,
+        num_cpus,
         pci_window_32,
         pci_window_64: fwcfg::formats::PciWindow::empty(),
         dsdt_generators: &generators,
@@ -1487,9 +1492,15 @@ fn setup_instance(
     let e820_entry = generate_e820(machine, log).expect("can build E820 table");
     fwcfg.insert_named("etc/e820", e820_entry).unwrap();
 
-    let acpi_entries =
-        generate_acpi_tables(cpus, lowmem, &guard.inventory, &device_metadata)
-            .expect("can build ACPI tables");
+    let acpi_entries = generate_acpi_tables(
+        config.main.acpi_variant,
+        cpus,
+        lowmem,
+        &guard.inventory,
+        &device_metadata,
+        log,
+    )
+    .expect("can build ACPI tables");
     fwcfg
         .insert_named("etc/acpi/tables", acpi_entries.tables)
         .context("Failed to insert ACPI tables")?;

lib/propolis/src/firmware/acpi/aml.rs

@@ -4,7 +4,22 @@
 
 //! Collection of AML helpers and wrappers.
 
-use acpi_tables::aml;
+use super::AcpiVariant;
+use acpi_tables::{aml, Aml, AmlSink};
+use std::collections::HashSet;
+
+// Flags used to defined ACPI methods concurrency control.
+//
+// See ACPI section 19.6.84 "Method (Declare Control Method)" for authoritative
+// information about these flags.
+
+/// Declare the ASL method marked as "Serialized", meaning it is not safe for
+/// use by multiple concurrent threads.
+pub const SERIALIZED: bool = true;
+
+/// Declare the ASL method marked as "NotSerialized", meaning it is safe for
+/// concurrent access (does not declare objects internally, etc)
+pub const NOT_SERIALIZED: bool = false;
 
 /// Creates an IO port with a fixed port number.
 ///
@@ -22,18 +37,30 @@ pub fn io_port(port: u16, alignment: u8, length: u8) -> aml::IO {
     aml::IO::new(port, port, alignment, length)
 }
 
-// Flags used to defined ACPI methods concurrency control.
-//
-// See ACPI section 19.6.84 "Method (Declare Control Method)" for authoritative
-// information about these flags.
-
-/// Declare the ASL method marked as "Serialized", meaning it is not safe for
-/// use by multiple concurrent threads.
-pub const SERIALIZED: bool = true;
-
-/// Declare the ASL method marked as "NotSerialized", meaning it is safe for
-/// concurrent access (does not declare objects internally, etc)
-pub const NOT_SERIALIZED: bool = false;
+/// Wrapper for an `Aml` that only writes the AML bytecode to the sink if the
+/// target [`AcpiVariant`] is present in the filter.
+pub struct AcpiVariantFilter<'a> {
+    target: AcpiVariant,
+    filter: HashSet<AcpiVariant>,
+    inner: &'a dyn Aml,
+}
+impl<'a> AcpiVariantFilter<'a> {
+    pub fn new(
+        target: AcpiVariant,
+        filter: Vec<AcpiVariant>,
+        inner: &'a dyn Aml,
+    ) -> Self {
+        Self { target, filter: HashSet::from_iter(filter), inner }
+    }
+}
+impl<'a> Aml for AcpiVariantFilter<'a> {
+    fn to_aml_bytes(&self, sink: &mut dyn AmlSink) {
+        if !self.filter.contains(&self.target) {
+            return;
+        }
+        self.inner.to_aml_bytes(sink);
+    }
+}
 
 /// Constructors for ACPI paths defined in the ACPI specification.
 ///