refactor: use vm_device::Bus for IO bus

Use the vm_device::Bus bus for PortIO devices on x86. PCIe devices will
use this as well.

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

Author: bchalios

src/vmm/src/arch/x86_64/vcpu.rs

@@ -160,7 +160,7 @@ pub struct KvmVcpu {
 #[derive(Default, Debug)]
 pub struct Peripherals {
     /// Pio bus.
-    pub pio_bus: Option<crate::devices::Bus>,
+    pub pio_bus: Option<Arc<vm_device::Bus>>,
     /// Mmio bus.
     pub mmio_bus: Option<Arc<vm_device::Bus>>,
 }
@@ -267,7 +267,7 @@ impl KvmVcpu {
     }
 
     /// Sets a Port Mapped IO bus for this vcpu.
-    pub fn set_pio_bus(&mut self, pio_bus: crate::devices::Bus) {
+    pub fn set_pio_bus(&mut self, pio_bus: Arc<vm_device::Bus>) {
         self.peripherals.pio_bus = Some(pio_bus);
     }
 
@@ -711,15 +711,19 @@ impl Peripherals {
             VcpuExit::IoIn(addr, data) => {
                 if let Some(pio_bus) = &self.pio_bus {
                     let _metric = METRICS.vcpu.exit_io_in_agg.record_latency_metrics();
-                    pio_bus.read(u64::from(addr), data);
+                    if let Err(err) = pio_bus.read(u64::from(addr), data) {
+                        warn!("vcpu: IO read @ {addr:#x}:{:#x} failed: {err}", data.len());
+                    }
                     METRICS.vcpu.exit_io_in.inc();
                 }
                 Ok(VcpuEmulation::Handled)
             }
             VcpuExit::IoOut(addr, data) => {
                 if let Some(pio_bus) = &self.pio_bus {
                     let _metric = METRICS.vcpu.exit_io_out_agg.record_latency_metrics();
-                    pio_bus.write(u64::from(addr), data);
+                    if let Err(err) = pio_bus.write(u64::from(addr), data) {
+                        warn!("vcpu: IO write @ {addr:#x}:{:#x} failed: {err}", data.len());
+                    }
                     METRICS.vcpu.exit_io_out.inc();
                 }
                 Ok(VcpuEmulation::Handled)

src/vmm/src/builder.rs

@@ -13,6 +13,8 @@ use event_manager::{MutEventSubscriber, SubscriberOps};
 use linux_loader::cmdline::Cmdline as LoaderKernelCmdline;
 use userfaultfd::Uffd;
 use utils::time::TimestampUs;
+#[cfg(target_arch = "x86_64")]
+use vmm_sys_util::eventfd::EventFd;
 
 use crate::arch::{ConfigurationError, configure_system_for_boot, load_kernel};
 #[cfg(target_arch = "aarch64")]
@@ -28,8 +30,9 @@ use crate::device_manager::persist::{
     ACPIDeviceManagerConstructorArgs, ACPIDeviceManagerRestoreError, MMIODevManagerConstructorArgs,
 };
 use crate::device_manager::resources::ResourceAllocator;
-use crate::devices::BusDevice;
 use crate::devices::acpi::vmgenid::{VmGenId, VmGenIdError};
+#[cfg(target_arch = "x86_64")]
+use crate::devices::legacy::I8042Device;
 #[cfg(target_arch = "aarch64")]
 use crate::devices::legacy::RTCDevice;
 use crate::devices::legacy::SerialDevice;
@@ -157,10 +160,14 @@ fn create_vmm_and_vcpus(
 
         // x86_64 uses the i8042 reset event as the Vmm exit event.
         let reset_evt = vcpus_exit_evt.try_clone().map_err(VmmError::EventFd)?;
+        let i8042 = Arc::new(Mutex::new(I8042Device::new(
+            reset_evt,
+            EventFd::new(libc::EFD_NONBLOCK).map_err(VmmError::EventFd)?,
+        )));
 
         // create pio dev manager with legacy devices
         let mut pio_dev_mgr =
-            PortIODeviceManager::new(serial_device, reset_evt).map_err(VmmError::LegacyIOBus)?;
+            PortIODeviceManager::new(serial_device, i8042).map_err(VmmError::LegacyIOBus)?;
         pio_dev_mgr
             .register_devices(vm.fd())
             .map_err(VmmError::LegacyIOBus)?;
@@ -527,11 +534,11 @@ pub fn build_microvm_from_snapshot(
 /// Sets up the serial device.
 pub fn setup_serial_device(
     event_manager: &mut EventManager,
-) -> Result<Arc<Mutex<BusDevice>>, VmmError> {
-    let serial = Arc::new(Mutex::new(BusDevice::Serial(
+) -> Result<Arc<Mutex<SerialDevice>>, VmmError> {
+    let serial = Arc::new(Mutex::new(
         SerialDevice::new(Some(std::io::stdin()), SerialOut::Stdout(std::io::stdout()))
             .map_err(VmmError::EventFd)?,
-    )));
+    ));
     event_manager.add_subscriber(serial.clone());
     Ok(serial)
 }
@@ -819,10 +826,13 @@ pub(crate) mod tests {
         let acpi_device_manager = ACPIDeviceManager::new();
         #[cfg(target_arch = "x86_64")]
         let pio_device_manager = PortIODeviceManager::new(
-            Arc::new(Mutex::new(BusDevice::Serial(
+            Arc::new(Mutex::new(
                 SerialDevice::new(None, SerialOut::Sink(std::io::sink())).unwrap(),
+            )),
+            Arc::new(Mutex::new(I8042Device::new(
+                EventFd::new(libc::EFD_NONBLOCK).unwrap(),
+                EventFd::new(libc::EFD_NONBLOCK).unwrap(),
             ))),
-            EventFd::new(libc::EFD_NONBLOCK).unwrap(),
         )
         .unwrap();
 

src/vmm/src/device_manager/legacy.rs

@@ -16,15 +16,14 @@ use libc::EFD_NONBLOCK;
 use vm_superio::Serial;
 use vmm_sys_util::eventfd::EventFd;
 
-use crate::devices::bus::BusDevice;
 use crate::devices::legacy::serial::SerialOut;
-use crate::devices::legacy::{EventFdTrigger, SerialDevice, SerialEventsWrapper};
+use crate::devices::legacy::{EventFdTrigger, I8042Device, SerialDevice, SerialEventsWrapper};
 
 /// Errors corresponding to the `PortIODeviceManager`.
 #[derive(Debug, derive_more::From, thiserror::Error, displaydoc::Display)]
 pub enum LegacyDeviceError {
     /// Failed to add legacy device to Bus: {0}
-    BusError(crate::devices::BusError),
+    BusError(vm_device::BusError),
     /// Failed to create EventFd: {0}
     EventFd(std::io::Error),
 }
@@ -34,11 +33,11 @@ pub enum LegacyDeviceError {
 /// The `LegacyDeviceManger` should be initialized only by using the constructor.
 #[derive(Debug)]
 pub struct PortIODeviceManager {
-    pub io_bus: crate::devices::Bus,
+    pub io_bus: Arc<vm_device::Bus>,
     // BusDevice::Serial
-    pub stdio_serial: Arc<Mutex<BusDevice>>,
+    pub stdio_serial: Arc<Mutex<SerialDevice>>,
     // BusDevice::I8042Device
-    pub i8042: Arc<Mutex<BusDevice>>,
+    pub i8042: Arc<Mutex<I8042Device>>,
 
     // Communication event on ports 1 & 3.
     pub com_evt_1_3: EventFdTrigger,
@@ -73,29 +72,26 @@ impl PortIODeviceManager {
 
     /// Create a new DeviceManager handling legacy devices (uart, i8042).
     pub fn new(
-        serial: Arc<Mutex<BusDevice>>,
-        i8042_reset_evfd: EventFd,
+        stdio_serial: Arc<Mutex<SerialDevice>>,
+        i8042: Arc<Mutex<I8042Device>>,
     ) -> Result<Self, LegacyDeviceError> {
-        debug_assert!(matches!(*serial.lock().unwrap(), BusDevice::Serial(_)));
-        let io_bus = crate::devices::Bus::new();
-        let com_evt_1_3 = serial
+        let io_bus = Arc::new(vm_device::Bus::new());
+        let com_evt_1_3 = stdio_serial
             .lock()
             .expect("Poisoned lock")
-            .serial_mut()
-            .unwrap()
             .serial
             .interrupt_evt()
             .try_clone()?;
         let com_evt_2_4 = EventFdTrigger::new(EventFd::new(EFD_NONBLOCK)?);
-        let kbd_evt = EventFd::new(libc::EFD_NONBLOCK)?;
-
-        let i8042 = Arc::new(Mutex::new(BusDevice::I8042Device(
-            crate::devices::legacy::I8042Device::new(i8042_reset_evfd, kbd_evt.try_clone()?),
-        )));
+        let kbd_evt = i8042
+            .lock()
+            .expect("Poisoned lock")
+            .kbd_interrupt_evt
+            .try_clone()?;
 
         Ok(PortIODeviceManager {
             io_bus,
-            stdio_serial: serial,
+            stdio_serial,
             i8042,
             com_evt_1_3,
             com_evt_2_4,
@@ -105,7 +101,7 @@ impl PortIODeviceManager {
 
     /// Register supported legacy devices.
     pub fn register_devices(&mut self, vm_fd: &VmFd) -> Result<(), LegacyDeviceError> {
-        let serial_2_4 = Arc::new(Mutex::new(BusDevice::Serial(SerialDevice {
+        let serial_2_4 = Arc::new(Mutex::new(SerialDevice {
             serial: Serial::with_events(
                 self.com_evt_2_4.try_clone()?.try_clone()?,
                 SerialEventsWrapper {
@@ -114,8 +110,8 @@ impl PortIODeviceManager {
                 SerialOut::Sink(std::io::sink()),
             ),
             input: None,
-        })));
-        let serial_1_3 = Arc::new(Mutex::new(BusDevice::Serial(SerialDevice {
+        }));
+        let serial_1_3 = Arc::new(Mutex::new(SerialDevice {
             serial: Serial::with_events(
                 self.com_evt_1_3.try_clone()?.try_clone()?,
                 SerialEventsWrapper {
@@ -124,7 +120,7 @@ impl PortIODeviceManager {
                 SerialOut::Sink(std::io::sink()),
             ),
             input: None,
-        })));
+        }));
         self.io_bus.insert(
             self.stdio_serial.clone(),
             Self::SERIAL_PORT_ADDRESSES[0],
@@ -251,7 +247,7 @@ mod tests {
         let (_, vm) = setup_vm_with_memory(0x1000);
         vm.setup_irqchip().unwrap();
         let mut ldm = PortIODeviceManager::new(
-            Arc::new(Mutex::new(BusDevice::Serial(SerialDevice {
+            Arc::new(Mutex::new(SerialDevice {
                 serial: Serial::with_events(
                     EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).unwrap()),
                     SerialEventsWrapper {
@@ -260,8 +256,11 @@ mod tests {
                     SerialOut::Sink(std::io::sink()),
                 ),
                 input: None,
-            }))),
-            EventFd::new(libc::EFD_NONBLOCK).unwrap(),
+            })),
+            Arc::new(Mutex::new(I8042Device::new(
+                EventFd::new(libc::EFD_NONBLOCK).unwrap(),
+                EventFd::new(libc::EFD_NONBLOCK).unwrap(),
+            ))),
         )
         .unwrap();
         ldm.register_devices(vm.fd()).unwrap();