refactor: add top-level device manager

PCIe spec mandates that software can access the configuration space of
PCIe devices both via MMIO and Port IO accesses. As a result, PCIe
devices will need to register to both buses (on x86).

Change the organization of devices, so that MMIO and PIO device managers
do not own the buses. Instead, introduce a DeviceManager object which
holds the buses, the resource allocator and includes also all types of
device managers (at the moment MMIO, PIO and ACPI).

Signed-off-by: Babis Chalios <bchalios@amazon.es>

Author: bchalios

Cargo.lock

@@ -10,8 +10,7 @@ use crate::Vcpu;
 use crate::acpi::x86_64::{
     apic_addr, rsdp_addr, setup_arch_dsdt, setup_arch_fadt, setup_interrupt_controllers,
 };
-use crate::device_manager::acpi::ACPIDeviceManager;
-use crate::device_manager::mmio::MMIODeviceManager;
+use crate::device_manager::DeviceManager;
 use crate::device_manager::resources::ResourceAllocator;
 use crate::vstate::memory::{GuestAddress, GuestMemoryMmap};
 
@@ -45,19 +44,22 @@ pub enum AcpiError {
 /// allocator for allocating space for the tables
 struct AcpiTableWriter<'a> {
     mem: &'a GuestMemoryMmap,
-    resource_allocator: &'a mut ResourceAllocator,
 }
 
 impl AcpiTableWriter<'_> {
     /// Write a table in guest memory
     ///
     /// This will allocate enough space inside guest memory and write the table in the allocated
     /// buffer. It returns the address in which it wrote the table.
-    fn write_acpi_table<S>(&mut self, table: &mut S) -> Result<u64, AcpiError>
+    fn write_acpi_table<S>(
+        &mut self,
+        resource_allocator: &mut ResourceAllocator,
+        table: &mut S,
+    ) -> Result<u64, AcpiError>
     where
         S: Sdt,
     {
-        let addr = self.resource_allocator.allocate_system_memory(
+        let addr = resource_allocator.allocate_system_memory(
             table.len().try_into().unwrap(),
             1,
             AllocPolicy::FirstMatch,
@@ -77,65 +79,76 @@ impl AcpiTableWriter<'_> {
     }
 
     /// Build the DSDT table for the guest
-    fn build_dsdt(
-        &mut self,
-        mmio_device_manager: &MMIODeviceManager,
-        acpi_device_manager: &ACPIDeviceManager,
-    ) -> Result<u64, AcpiError> {
+    fn build_dsdt(&mut self, device_manager: &mut DeviceManager) -> Result<u64, AcpiError> {
         let mut dsdt_data = Vec::new();
 
         // Virtio-devices DSDT data
-        dsdt_data.extend_from_slice(&mmio_device_manager.dsdt_data);
+        dsdt_data.extend_from_slice(&device_manager.mmio_devices.dsdt_data);
 
         // Add GED and VMGenID AML data.
-        acpi_device_manager.append_aml_bytes(&mut dsdt_data)?;
+        device_manager
+            .acpi_devices
+            .append_aml_bytes(&mut dsdt_data)?;
 
         // Architecture specific DSDT data
         setup_arch_dsdt(&mut dsdt_data)?;
 
         let mut dsdt = Dsdt::new(OEM_ID, *b"FCVMDSDT", OEM_REVISION, dsdt_data);
-        self.write_acpi_table(&mut dsdt)
+        self.write_acpi_table(&mut device_manager.resource_allocator, &mut dsdt)
     }
 
     /// Build the FADT table for the guest
     ///
     /// This includes a pointer with the location of the DSDT in guest memory
-    fn build_fadt(&mut self, dsdt_addr: u64) -> Result<u64, AcpiError> {
+    fn build_fadt(
+        &mut self,
+        resource_allocator: &mut ResourceAllocator,
+        dsdt_addr: u64,
+    ) -> Result<u64, AcpiError> {
         let mut fadt = Fadt::new(OEM_ID, *b"FCVMFADT", OEM_REVISION);
         fadt.set_hypervisor_vendor_id(HYPERVISOR_VENDOR_ID);
         fadt.set_x_dsdt(dsdt_addr);
         fadt.set_flags(
             (1 << FADT_F_HW_REDUCED_ACPI) | (1 << FADT_F_PWR_BUTTON) | (1 << FADT_F_SLP_BUTTON),
         );
         setup_arch_fadt(&mut fadt);
-        self.write_acpi_table(&mut fadt)
+        self.write_acpi_table(resource_allocator, &mut fadt)
     }
 
     /// Build the MADT table for the guest
     ///
     /// This includes information about the interrupt controllers supported in the platform
-    fn build_madt(&mut self, nr_vcpus: u8) -> Result<u64, AcpiError> {
+    fn build_madt(
+        &mut self,
+        resource_allocator: &mut ResourceAllocator,
+        nr_vcpus: u8,
+    ) -> Result<u64, AcpiError> {
         let mut madt = Madt::new(
             OEM_ID,
             *b"FCVMMADT",
             OEM_REVISION,
             apic_addr(),
             setup_interrupt_controllers(nr_vcpus),
         );
-        self.write_acpi_table(&mut madt)
+        self.write_acpi_table(resource_allocator, &mut madt)
     }
 
     /// Build the XSDT table for the guest
     ///
     /// Currently, we pass to the guest just FADT and MADT tables.
-    fn build_xsdt(&mut self, fadt_addr: u64, madt_addr: u64) -> Result<u64, AcpiError> {
+    fn build_xsdt(
+        &mut self,
+        resource_allocator: &mut ResourceAllocator,
+        fadt_addr: u64,
+        madt_addr: u64,
+    ) -> Result<u64, AcpiError> {
         let mut xsdt = Xsdt::new(
             OEM_ID,
             *b"FCMVXSDT",
             OEM_REVISION,
             vec![fadt_addr, madt_addr],
         );
-        self.write_acpi_table(&mut xsdt)
+        self.write_acpi_table(resource_allocator, &mut xsdt)
     }
 
     /// Build the RSDP pointer for the guest.
@@ -163,20 +176,19 @@ impl AcpiTableWriter<'_> {
 /// such as interrupt controllers, vCPUs and VirtIO devices.
 pub(crate) fn create_acpi_tables(
     mem: &GuestMemoryMmap,
-    resource_allocator: &mut ResourceAllocator,
-    mmio_device_manager: &MMIODeviceManager,
-    acpi_device_manager: &ACPIDeviceManager,
+    device_manager: &mut DeviceManager,
     vcpus: &[Vcpu],
 ) -> Result<(), AcpiError> {
-    let mut writer = AcpiTableWriter {
-        mem,
-        resource_allocator,
-    };
-
-    let dsdt_addr = writer.build_dsdt(mmio_device_manager, acpi_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)?;
+    let mut writer = AcpiTableWriter { mem };
+
+    let dsdt_addr = writer.build_dsdt(device_manager)?;
+    let fadt_addr = writer.build_fadt(&mut device_manager.resource_allocator, dsdt_addr)?;
+    let madt_addr = writer.build_madt(
+        &mut device_manager.resource_allocator,
+        vcpus.len().try_into().unwrap(),
+    )?;
+    let xsdt_addr =
+        writer.build_xsdt(&mut device_manager.resource_allocator, fadt_addr, madt_addr)?;
     writer.build_rsdp(xsdt_addr)
 }
 
@@ -218,17 +230,20 @@ mod tests {
         let mut vmm = default_vmm();
         let mut writer = AcpiTableWriter {
             mem: vmm.vm.guest_memory(),
-            resource_allocator: &mut vmm.resource_allocator,
         };
 
         // This should succeed
         let mut sdt = MockSdt(vec![0; 4096]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START);
 
         // Let's try to write two 4K pages plus one byte
         let mut sdt = MockSdt(vec![0; usize::try_from(SYSTEM_MEM_SIZE + 1).unwrap()]);
-        let err = writer.write_acpi_table(&mut sdt).unwrap_err();
+        let err = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap_err();
         assert!(
             matches!(
                 err,
@@ -241,19 +256,29 @@ mod tests {
         // We are allocating memory for tables with alignment of 1 byte. All of these should
         // succeed.
         let mut sdt = MockSdt(vec![0; 5]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START + 4096);
         let mut sdt = MockSdt(vec![0; 2]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START + 4101);
         let mut sdt = MockSdt(vec![0; 4]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START + 4103);
         let mut sdt = MockSdt(vec![0; 8]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START + 4107);
         let mut sdt = MockSdt(vec![0; 16]);
-        let addr = writer.write_acpi_table(&mut sdt).unwrap();
+        let addr = writer
+            .write_acpi_table(&mut vmm.device_manager.resource_allocator, &mut sdt)
+            .unwrap();
         assert_eq!(addr, SYSTEM_MEM_START + 4115);
     }
 
@@ -268,11 +293,13 @@ mod tests {
         let (_, vm) = setup_vm_with_memory(u64_to_usize(SYSTEM_MEM_START + SYSTEM_MEM_SIZE - 4096));
         let mut writer = AcpiTableWriter {
             mem: vm.guest_memory(),
-            resource_allocator: &mut ResourceAllocator::new().unwrap(),
         };
+        let mut resource_allocator = ResourceAllocator::new().unwrap();
 
         let mut sdt = MockSdt(vec![0; usize::try_from(SYSTEM_MEM_SIZE).unwrap()]);
-        let err = writer.write_acpi_table(&mut sdt).unwrap_err();
+        let err = writer
+            .write_acpi_table(&mut resource_allocator, &mut sdt)
+            .unwrap_err();
         assert!(
             matches!(
                 err,