pci: use VirtIO PCI transport when PCI is enabled

bchalios · bchalios · commit 2f7ff8ab9be3 · 2025-06-18T20:46:55.000+02:00
Create VirtIO devices using the PCI transport layer when user launched
microVM with --enable-pci.

Signed-off-by: Babis Chalios &lt;bchalios@amazon.es&gt;
diff --git a/src/vmm/src/builder.rs b/src/vmm/src/builder.rs
@@ -169,6 +169,8 @@ pub fn build_microvm_for_boot(
 
     let mut device_manager = DeviceManager::new(event_manager, &vcpus_exit_evt, &vm)?;
 
+    let vm = Arc::new(vm);
+
     let entry_point = load_kernel(&boot_config.kernel_file, vm.guest_memory())?;
     let initrd = InitrdConfig::from_config(boot_config, vm.guest_memory())?;
 
@@ -271,7 +273,7 @@ pub fn build_microvm_for_boot(
         instance_info: instance_info.clone(),
         shutdown_exit_code: None,
         kvm,
-        vm: Arc::new(vm),
+        vm,
         uffd: None,
         vcpus_handles: Vec::new(),
         vcpus_exit_evt,
@@ -554,7 +556,7 @@ fn setup_pvtime(
 
 fn attach_entropy_device(
     device_manager: &mut DeviceManager,
-    vm: &Vm,
+    vm: &Arc<Vm>,
     cmdline: &mut LoaderKernelCmdline,
     entropy_device: &Arc<Mutex<Entropy>>,
     event_manager: &mut EventManager,
@@ -571,7 +573,7 @@ fn attach_entropy_device(
 
 fn attach_block_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Block>>> + Debug>(
     device_manager: &mut DeviceManager,
-    vm: &Vm,
+    vm: &Arc<Vm>,
     cmdline: &mut LoaderKernelCmdline,
     blocks: I,
     event_manager: &mut EventManager,
@@ -600,7 +602,7 @@ fn attach_block_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Block>>> + Debug>(
 
 fn attach_net_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Net>>> + Debug>(
     device_manager: &mut DeviceManager,
-    vm: &Vm,
+    vm: &Arc<Vm>,
     cmdline: &mut LoaderKernelCmdline,
     net_devices: I,
     event_manager: &mut EventManager,
@@ -616,7 +618,7 @@ fn attach_net_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Net>>> + Debug>(
 
 fn attach_unixsock_vsock_device(
     device_manager: &mut DeviceManager,
-    vm: &Vm,
+    vm: &Arc<Vm>,
     cmdline: &mut LoaderKernelCmdline,
     unix_vsock: &Arc<Mutex<Vsock<VsockUnixBackend>>>,
     event_manager: &mut EventManager,
@@ -629,7 +631,7 @@ fn attach_unixsock_vsock_device(
 
 fn attach_balloon_device(
     device_manager: &mut DeviceManager,
-    vm: &Vm,
+    vm: &Arc<Vm>,
     cmdline: &mut LoaderKernelCmdline,
     balloon: &Arc<Mutex<Balloon>>,
     event_manager: &mut EventManager,
diff --git a/src/vmm/src/device_manager/mod.rs b/src/vmm/src/device_manager/mod.rs
@@ -79,6 +79,8 @@ pub enum AttachDeviceError {
     #[cfg(target_arch = "aarch64")]
     /// Error creating serial device: {0}
     CreateSerial(#[from] std::io::Error),
+    /// Error attach PCI device: {0}
+    PciTransport(#[from] PciManagerError),
 }
 
 #[derive(Debug)]
@@ -160,8 +162,10 @@ impl DeviceManager {
         })
     }
 
-    /// Attaches a VirtioDevice device to the device manager and event manager.
-    pub(crate) fn attach_virtio_device<T: 'static + VirtioDevice + MutEventSubscriber + Debug>(
+    /// Attaches an MMIO VirtioDevice device to the device manager and event manager.
+    pub(crate) fn attach_mmio_virtio_device<
+        T: 'static + VirtioDevice + MutEventSubscriber + Debug,
+    >(
         &mut self,
         vm: &Vm,
         id: String,
@@ -184,6 +188,25 @@ impl DeviceManager {
         Ok(())
     }
 
+    /// Attaches a VirtioDevice device to the device manager and event manager.
+    pub(crate) fn attach_virtio_device<T: 'static + VirtioDevice + MutEventSubscriber + Debug>(
+        &mut self,
+        vm: &Arc<Vm>,
+        id: String,
+        device: Arc<Mutex<T>>,
+        cmdline: &mut Cmdline,
+        is_vhost_user: bool,
+    ) -> Result<(), AttachDeviceError> {
+        if self.pci_devices.pci_segment.is_some() {
+            self.pci_devices
+                .attach_pci_virtio_device(vm, &self.resource_allocator, id, device)?;
+        } else {
+            self.attach_mmio_virtio_device(vm, id, device, cmdline, is_vhost_user)?;
+        }
+
+        Ok(())
+    }
+
     /// Attaches a [`BootTimer`] to the VM
     pub(crate) fn attach_boot_timer_device(
         &mut self,
diff --git a/src/vmm/src/device_manager/pci_mngr.rs b/src/vmm/src/device_manager/pci_mngr.rs
@@ -1,13 +1,22 @@
 // Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::sync::Arc;
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
 
+use event_manager::MutEventSubscriber;
+use kvm_ioctls::{IoEventAddress, NoDatamatch};
+use log::debug;
+use pci::{PciBarRegionType, PciDevice, PciDeviceError, PciRootError};
 use serde::{Deserialize, Serialize};
 use vm_device::BusError;
 
-use super::resources::ResourceAllocator;
+use crate::Vm;
+use crate::device_manager::resources::ResourceAllocator;
 use crate::devices::pci::PciSegment;
+use crate::devices::virtio::device::VirtioDevice;
+use crate::devices::virtio::transport::pci::device::{VirtioPciDevice, VirtioPciDeviceError};
+use crate::vstate::vm::InterruptError;
 
 #[derive(Debug, Default)]
 pub struct PciDevices {
@@ -21,6 +30,16 @@ pub enum PciManagerError {
     ResourceAllocation(#[from] vm_allocator::Error),
     /// Bus error: {0}
     Bus(#[from] BusError),
+    /// PCI root error: {0}
+    PciRoot(#[from] PciRootError),
+    /// MSI error: {0}
+    Msi(#[from] InterruptError),
+    /// VirtIO PCI device error: {0}
+    VirtioPciDevice(#[from] VirtioPciDeviceError),
+    /// PCI device error: {0}
+    PciDeviceError(#[from] PciDeviceError),
+    /// KVM error: {0}
+    Kvm(#[from] vmm_sys_util::errno::Error),
 }
 
 impl PciDevices {
@@ -61,6 +80,106 @@ impl PciDevices {
 
         Ok(())
     }
+
+    pub(crate) fn attach_pci_virtio_device<
+        T: 'static + VirtioDevice + MutEventSubscriber + Debug,
+    >(
+        &mut self,
+        vm: &Arc<Vm>,
+        resource_allocator: &ResourceAllocator,
+        id: String,
+        device: Arc<Mutex<T>>,
+    ) -> Result<(), PciManagerError> {
+        // We should only be reaching this point if PCI is enabled
+        let pci_segment = self.pci_segment.as_ref().unwrap();
+        let pci_device_bdf = pci_segment.next_device_bdf()?;
+        debug!("Allocating BDF: {pci_device_bdf:?} for device");
+        let mem = vm.guest_memory().clone();
+
+        // Allocate one MSI vector per queue, plus one for configuration
+        let msix_num =
+            u16::try_from(device.lock().expect("Poisoned lock").queues().len() + 1).unwrap();
+
+        let msix_vectors = Arc::new(Vm::create_msix_group(
+            vm.clone(),
+            resource_allocator,
+            0,
+            msix_num,
+        )?);
+
+        // Create the transport
+        let mut virtio_device = VirtioPciDevice::new(
+            id.clone(),
+            mem,
+            device,
+            msix_vectors,
+            pci_device_bdf.into(),
+            true,
+            None,
+        )?;
+
+        // Allocate bars
+        let mut mmio32_allocator = resource_allocator
+            .mmio32_memory
+            .lock()
+            .expect("Poisoned lock");
+        let mut mmio64_allocator = resource_allocator
+            .mmio64_memory
+            .lock()
+            .expect("Poisoned lock");
+
+        let bars =
+            virtio_device.allocate_bars(&mut mmio32_allocator, &mut mmio64_allocator, None)?;
+
+        let virtio_device = Arc::new(Mutex::new(virtio_device));
+        pci_segment
+            .pci_bus
+            .lock()
+            .expect("Poisoned lock")
+            .add_device(pci_device_bdf.device() as u32, virtio_device.clone())?;
+
+        for bar in &bars {
+            match bar.region_type() {
+                PciBarRegionType::IoRegion => {
+                    #[cfg(target_arch = "x86_64")]
+                    resource_allocator.pio_bus.insert(
+                        virtio_device.clone(),
+                        bar.addr(),
+                        bar.size(),
+                    )?;
+                    #[cfg(target_arch = "aarch64")]
+                    log::error!("pci: We do not support I/O region allocation")
+                }
+                PciBarRegionType::Memory32BitRegion | PciBarRegionType::Memory64BitRegion => {
+                    resource_allocator.mmio_bus.insert(
+                        virtio_device.clone(),
+                        bar.addr(),
+                        bar.size(),
+                    )?;
+                }
+            }
+        }
+
+        let locked_device = virtio_device.lock().expect("Poisoned lock");
+
+        let bar_addr = locked_device.config_bar_addr();
+        for (i, queue_evt) in locked_device
+            .virtio_device()
+            .lock()
+            .expect("Poisoned lock")
+            .queue_events()
+            .iter()
+            .enumerate()
+        {
+            const NOTIFICATION_BAR_OFFSET: u64 = 0x6000;
+            const NOTIFY_OFF_MULTIPLIER: u64 = 4;
+            let notify_base = bar_addr + NOTIFICATION_BAR_OFFSET;
+            let io_addr = IoEventAddress::Mmio(notify_base + i as u64 * NOTIFY_OFF_MULTIPLIER);
+            vm.fd().register_ioevent(queue_evt, &io_addr, NoDatamatch)?;
+        }
+
+        Ok(())
+    }
 }
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
