acpi: define x86 devices in ACPI DSDT table

Use AML bytecode in DSDT ACPI table to define VirtIO devices as well as
passing them as kernel command line arguments. Also, pass AML for legacy
devices, as the kernel doesn't pick up the console or i8042 unless we
do.

For the time being, we are keeping the old way of booting, i.e. MPTable
plus VirtIO devices via command line arguments to allow for some sort of
backwards compatibility with kernels that are not built with ACPI
support.

Signed-off-by: Babis Chalios <[email protected]>

Author: bchalios

src/vmm/src/acpi/mod.rs

@@ -9,6 +9,7 @@ use vm_allocator::AllocPolicy;
 use crate::acpi::x86_64::{
     apic_addr, rsdp_addr, setup_arch_dsdt, setup_arch_fadt, setup_interrupt_controllers,
 };
+use crate::device_manager::mmio::MMIODeviceManager;
 use crate::device_manager::resources::ResourceAllocator;
 use crate::vstate::memory::{GuestAddress, GuestMemoryMmap};
 use crate::Vcpu;
@@ -73,9 +74,12 @@ impl<'a> AcpiTableWriter<'a> {
     }
 
     /// Build the DSDT table for the guest
-    fn build_dsdt(&mut self) -> Result<u64, AcpiError> {
+    fn build_dsdt(&mut self, mmio_device_manager: &MMIODeviceManager) -> Result<u64, AcpiError> {
         let mut dsdt_data = Vec::new();
 
+        // Virtio-devices DSDT data
+        dsdt_data.extend_from_slice(&mmio_device_manager.dsdt_data);
+
         // Architecture specific DSDT data
         setup_arch_dsdt(&mut dsdt_data);
 
@@ -150,14 +154,15 @@ impl<'a> AcpiTableWriter<'a> {
 pub(crate) fn create_acpi_tables(
     mem: &GuestMemoryMmap,
     resource_allocator: &mut ResourceAllocator,
+    mmio_device_manager: &MMIODeviceManager,
     vcpus: &[Vcpu],
 ) -> Result<(), AcpiError> {
     let mut writer = AcpiTableWriter {
         mem,
         resource_allocator,
     };
 
-    let dsdt_addr = writer.build_dsdt()?;
+    let dsdt_addr = writer.build_dsdt(mmio_device_manager)?;
     let fadt_addr = writer.build_fadt(dsdt_addr)?;
     let madt_addr = writer.build_madt(vcpus.len().try_into().unwrap())?;
     let xsdt_addr = writer.build_xsdt(fadt_addr, madt_addr)?;

src/vmm/src/acpi/x86_64.rs

@@ -13,6 +13,7 @@ use vm_memory::GuestAddress;
 use zerocopy::AsBytes;
 
 use crate::arch::x86_64::layout;
+use crate::device_manager::legacy::PortIODeviceManager;
 
 #[inline(always)]
 pub(crate) fn setup_interrupt_controllers(nr_vcpus: u8) -> Vec<u8> {
@@ -39,9 +40,10 @@ pub(crate) fn setup_arch_fadt(fadt: &mut Fadt) {
     );
 }
 
-#[allow(clippy::ptr_arg)]
 #[inline(always)]
-pub(crate) fn setup_arch_dsdt(_dsdt_data: &mut Vec<u8>) {}
+pub(crate) fn setup_arch_dsdt(dsdt_data: &mut Vec<u8>) {
+    PortIODeviceManager::append_aml_bytes(dsdt_data)
+}
 
 pub(crate) const fn apic_addr() -> u32 {
     layout::APIC_ADDR

src/vmm/src/builder.rs

@@ -799,7 +799,12 @@ pub fn configure_system_for_boot(
 
         // Create ACPI tables and write them in guest memory
         // For the time being we only support ACPI in x86_64
-        acpi::create_acpi_tables(&vmm.guest_memory, &mut vmm.resource_allocator, vcpus)?;
+        acpi::create_acpi_tables(
+            &vmm.guest_memory,
+            &mut vmm.resource_allocator,
+            &vmm.mmio_device_manager,
+            vcpus,
+        )?;
     }
     #[cfg(target_arch = "aarch64")]
     {

src/vmm/src/device_manager/legacy.rs

@@ -9,6 +9,7 @@
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
+use acpi_tables::{aml, Aml};
 use kvm_ioctls::VmFd;
 use libc::EFD_NONBLOCK;
 use utils::eventfd::EventFd;
@@ -167,6 +168,71 @@ impl PortIODeviceManager {
 
         Ok(())
     }
+
+    pub(crate) fn append_aml_bytes(bytes: &mut Vec<u8>) {
+        // Set up COM devices
+        let gsi = [
+            Self::COM_EVT_1_3_GSI,
+            Self::COM_EVT_2_4_GSI,
+            Self::COM_EVT_1_3_GSI,
+            Self::COM_EVT_2_4_GSI,
+        ];
+        for com in 0u8..4 {
+            // COM1
+            aml::Device::new(
+                format!("_SB_.COM{}", com + 1).as_str().into(),
+                vec![
+                    &aml::Name::new("_HID".into(), &aml::EisaName::new("PNP0501")),
+                    &aml::Name::new("_UID".into(), &com),
+                    &aml::Name::new("_DDN".into(), &format!("COM{}", com + 1)),
+                    &aml::Name::new(
+                        "_CRS".into(),
+                        &aml::ResourceTemplate::new(vec![
+                            &aml::Interrupt::new(true, true, false, false, gsi[com as usize]),
+                            &aml::Io::new(
+                                PortIODeviceManager::SERIAL_PORT_ADDRESSES[com as usize]
+                                    .try_into()
+                                    .unwrap(),
+                                PortIODeviceManager::SERIAL_PORT_ADDRESSES[com as usize]
+                                    .try_into()
+                                    .unwrap(),
+                                1,
+                                PortIODeviceManager::SERIAL_PORT_SIZE.try_into().unwrap(),
+                            ),
+                        ]),
+                    ),
+                ],
+            )
+            .append_aml_bytes(bytes);
+        }
+        // Setup i8042
+        aml::Device::new(
+            "_SB_.PS2_".into(),
+            vec![
+                &aml::Name::new("_HID".into(), &aml::EisaName::new("PNP0303")),
+                &aml::Method::new("_STA".into(), 0, false, vec![&aml::Return::new(&0x0fu8)]),
+                &aml::Name::new(
+                    "_CRS".into(),
+                    &aml::ResourceTemplate::new(vec![
+                        &aml::Io::new(
+                            PortIODeviceManager::I8042_KDB_DATA_REGISTER_ADDRESS
+                                .try_into()
+                                .unwrap(),
+                            PortIODeviceManager::I8042_KDB_DATA_REGISTER_ADDRESS
+                                .try_into()
+                                .unwrap(),
+                            1u8,
+                            1u8,
+                        ),
+                        // Fake a command port so Linux stops complaining
+                        &aml::Io::new(0x0064, 0x0064, 1u8, 1u8),
+                        &aml::Interrupt::new(true, true, false, false, Self::KBD_EVT_GSI),
+                    ]),
+                ),
+            ],
+        )
+        .append_aml_bytes(bytes);
+    }
 }
 
 #[cfg(test)]

src/vmm/src/device_manager/mmio.rs

@@ -9,8 +9,12 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
+#[cfg(target_arch = "x86_64")]
+use acpi_tables::{aml, Aml};
 use kvm_ioctls::{IoEventAddress, VmFd};
 use linux_loader::cmdline as kernel_cmdline;
+#[cfg(target_arch = "x86_64")]
+use log::debug;
 use log::info;
 use serde::{Deserialize, Serialize};
 use vm_allocator::AllocPolicy;
@@ -58,7 +62,8 @@ pub enum MmioError {
     RegisterIrqFd(kvm_ioctls::Error),
 }
 
-/// This represents the size of the mmio device specified to the kernel as a cmdline option
+/// This represents the size of the mmio device specified to the kernel through ACPI and as a
+/// command line option.
 /// It has to be larger than 0x100 (the offset where the configuration space starts from
 /// the beginning of the memory mapped device registers) + the size of the configuration space
 /// Currently hardcoded to 4K.
@@ -75,11 +80,49 @@ pub struct MMIODeviceInfo {
     pub irqs: Vec<u32>,
 }
 
+#[cfg(target_arch = "x86_64")]
+fn add_virtio_aml(dsdt_data: &mut Vec<u8>, addr: u64, len: u64, irq: u32) {
+    let dev_id = irq - crate::arch::IRQ_BASE;
+    debug!(
+        "acpi: Building AML for VirtIO device _SB_.V{:03}. memory range: {:#010x}:{} irq: {}",
+        dev_id, addr, len, irq
+    );
+    aml::Device::new(
+        format!("V{:03}", dev_id).as_str().into(),
+        vec![
+            &aml::Name::new("_HID".into(), &"LNRO0005"),
+            &aml::Name::new("_UID".into(), &dev_id),
+            &aml::Name::new("_CCA".into(), &aml::ONE),
+            &aml::Name::new(
+                "_CRS".into(),
+                &aml::ResourceTemplate::new(vec![
+                    &aml::Memory32Fixed::new(
+                        true,
+                        addr.try_into().unwrap(),
+                        len.try_into().unwrap(),
+                    ),
+                    &aml::Interrupt::new(true, true, false, false, irq),
+                ]),
+            ),
+        ],
+    )
+    .append_aml_bytes(dsdt_data);
+}
+
 /// Manages the complexities of registering a MMIO device.
 #[derive(Debug)]
 pub struct MMIODeviceManager {
     pub(crate) bus: crate::devices::Bus,
     pub(crate) id_to_dev_info: HashMap<(DeviceType, String), MMIODeviceInfo>,
+    // We create the AML byte code for every VirtIO device in the order we build
+    // it, so that we ensure the root block device is appears first in the DSDT.
+    // This is needed, so that the root device appears as `/dev/vda` in the guest
+    // filesystem.
+    // The alternative would be that we iterate the bus to get the data after all
+    // of the devices are build. However, iterating the bus won't give us the
+    // devices in the order they were added.
+    #[cfg(target_arch = "x86_64")]
+    pub(crate) dsdt_data: Vec<u8>,
 }
 
 impl MMIODeviceManager {
@@ -88,6 +131,8 @@ impl MMIODeviceManager {
         MMIODeviceManager {
             bus: crate::devices::Bus::new(),
             id_to_dev_info: HashMap::new(),
+            #[cfg(target_arch = "x86_64")]
+            dsdt_data: vec![],
         }
     }
 
@@ -166,7 +211,7 @@ impl MMIODeviceManager {
         device_info: &MMIODeviceInfo,
     ) -> Result<(), MmioError> {
         // as per doc, [virtio_mmio.]device=<size>@<baseaddr>:<irq> needs to be appended
-        // to kernel commandline for virtio mmio devices to get recognized
+        // to kernel command line for virtio mmio devices to get recongnized
         // the size parameter has to be transformed to KiB, so dividing hexadecimal value in
         // bytes to 1024; further, the '{}' formatting rust construct will automatically
         // transform it to decimal
@@ -193,7 +238,17 @@ impl MMIODeviceManager {
         let device_info = self.allocate_mmio_resources(resource_allocator, 1)?;
         self.register_mmio_virtio(vm, device_id, mmio_device, &device_info)?;
         #[cfg(target_arch = "x86_64")]
-        Self::add_virtio_device_to_cmdline(_cmdline, &device_info)?;
+        {
+            Self::add_virtio_device_to_cmdline(_cmdline, &device_info)?;
+            add_virtio_aml(
+                &mut self.dsdt_data,
+                device_info.addr,
+                device_info.len,
+                // We are sure that `irqs` has at least one element; allocate_mmio_resources makes
+                // sure of it.
+                device_info.irqs[0],
+            );
+        }
         Ok(device_info)
     }