vmm: support PCI I/O regions on all architectures

While non-Intel CPU architectures don't have a special concept of IO
address space, support for PCI I/O regions is still needed to be able
to handle PCI devices that use them.

With this change, I'm able to pass through an e1000e device from QEMU
to a cloud-hypervisor VM on aarch64 and use it in the cloud-hypervisor
guest.  Previously, it would hit the unimplemented!().

Signed-off-by: Alyssa Ross <hi@alyssa.is>

vmm/src/device_manager.rs

@@ -536,7 +536,6 @@ impl Console {
 
 pub(crate) struct AddressManager {
     pub(crate) allocator: Arc<Mutex<SystemAllocator>>,
-    #[cfg(target_arch = "x86_64")]
     pub(crate) io_bus: Arc<Bus>,
     pub(crate) mmio_bus: Arc<Bus>,
     pub(crate) vm: Arc<dyn hypervisor::Vm>,
@@ -556,33 +555,24 @@ impl DeviceRelocation for AddressManager {
     ) -> std::result::Result<(), std::io::Error> {
         match region_type {
             PciBarRegionType::IoRegion => {
-                #[cfg(target_arch = "x86_64")]
-                {
-                    // Update system allocator
-                    self.allocator
-                        .lock()
-                        .unwrap()
-                        .free_io_addresses(GuestAddress(old_base), len as GuestUsize);
+                // Update system allocator
+                self.allocator
+                    .lock()
+                    .unwrap()
+                    .free_io_addresses(GuestAddress(old_base), len as GuestUsize);
 
-                    self.allocator
-                        .lock()
-                        .unwrap()
-                        .allocate_io_addresses(
-                            Some(GuestAddress(new_base)),
-                            len as GuestUsize,
-                            None,
-                        )
-                        .ok_or_else(|| {
-                            io::Error::new(io::ErrorKind::Other, "failed allocating new IO range")
-                        })?;
+                self.allocator
+                    .lock()
+                    .unwrap()
+                    .allocate_io_addresses(Some(GuestAddress(new_base)), len as GuestUsize, None)
+                    .ok_or_else(|| {
+                        io::Error::new(io::ErrorKind::Other, "failed allocating new IO range")
+                    })?;
 
-                    // Update PIO bus
-                    self.io_bus
-                        .update_range(old_base, len, new_base, len)
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-                }
-                #[cfg(target_arch = "aarch64")]
-                error!("I/O region is not supported");
+                // Update PIO bus
+                self.io_bus
+                    .update_range(old_base, len, new_base, len)
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
             }
             PciBarRegionType::Memory32BitRegion | PciBarRegionType::Memory64BitRegion => {
                 let allocators = if region_type == PciBarRegionType::Memory32BitRegion {
@@ -992,7 +982,7 @@ fn create_mmio_allocators(
 impl DeviceManager {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        #[cfg(target_arch = "x86_64")] io_bus: Arc<Bus>,
+        io_bus: Arc<Bus>,
         mmio_bus: Arc<Bus>,
         vm: Arc<dyn hypervisor::Vm>,
         config: Arc<Mutex<VmConfig>>,
@@ -1072,7 +1062,6 @@ impl DeviceManager {
 
         let address_manager = Arc::new(AddressManager {
             allocator: memory_manager.lock().unwrap().allocator(),
-            #[cfg(target_arch = "x86_64")]
             io_bus,
             mmio_bus,
             vm: vm.clone(),
@@ -3512,7 +3501,6 @@ impl DeviceManager {
         pci_bus
             .register_mapping(
                 bus_device,
-                #[cfg(target_arch = "x86_64")]
                 self.address_manager.io_bus.as_ref(),
                 self.address_manager.mmio_bus.as_ref(),
                 bars.clone(),

vmm/src/memory_manager.rs

@@ -1159,14 +1159,8 @@ impl MemoryManager {
 
         let allocator = Arc::new(Mutex::new(
             SystemAllocator::new(
-                #[cfg(target_arch = "x86_64")]
-                {
-                    GuestAddress(0)
-                },
-                #[cfg(target_arch = "x86_64")]
-                {
-                    1 << 16
-                },
+                GuestAddress(0),
+                1 << 16,
                 start_of_platform_device_area,
                 PLATFORM_DEVICE_AREA_SIZE,
                 #[cfg(target_arch = "x86_64")]

vmm/src/vm.rs

@@ -531,7 +531,6 @@ impl Vm {
         let stop_on_boot = false;
 
         let memory = memory_manager.lock().unwrap().guest_memory();
-        #[cfg(target_arch = "x86_64")]
         let io_bus = Arc::new(Bus::new());
         let mmio_bus = Arc::new(Bus::new());
 
@@ -622,7 +621,6 @@ impl Vm {
         let dynamic = true;
 
         let device_manager = DeviceManager::new(
-            #[cfg(target_arch = "x86_64")]
             io_bus,
             mmio_bus,
             vm.clone(),