vmm: simplify device errors

Merge the device-related errors that DeviceManager might return. This
way, we can avoid adding yet another error type for PCI devices and
reduce some the variants of StartMicrovmError.

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

Author: bchalios

src/vmm/src/builder.rs

@@ -22,12 +22,12 @@ use crate::arch::{ConfigurationError, configure_system_for_boot, load_kernel};
 #[cfg(target_arch = "aarch64")]
 use crate::construct_kvm_mpidrs;
 use crate::cpu_config::templates::{GetCpuTemplate, GetCpuTemplateError, GuestConfigError};
-#[cfg(target_arch = "aarch64")]
-use crate::device_manager::AttachLegacyMmioDeviceError;
+#[cfg(target_arch = "x86_64")]
+use crate::device_manager;
 use crate::device_manager::pci_mngr::PciManagerError;
 use crate::device_manager::{
-    AttachMmioDeviceError, AttachVmgenidError, DeviceManager, DeviceManagerCreateError,
-    DevicePersistError, DeviceRestoreArgs,
+    AttachDeviceError, DeviceManager, DeviceManagerCreateError, DevicePersistError,
+    DeviceRestoreArgs,
 };
 use crate::devices::acpi::vmgenid::VmGenIdError;
 use crate::devices::virtio::balloon::Balloon;
@@ -48,18 +48,15 @@ use crate::vstate::kvm::{Kvm, KvmError};
 use crate::vstate::memory::GuestRegionMmap;
 use crate::vstate::vcpu::VcpuError;
 use crate::vstate::vm::{Vm, VmError};
-use crate::{EventManager, Vmm, VmmError, device_manager};
+use crate::{EventManager, Vmm, VmmError};
 
 /// Errors associated with starting the instance.
 #[derive(Debug, thiserror::Error, displaydoc::Display)]
 pub enum StartMicrovmError {
     /// Unable to attach block device to Vmm: {0}
     AttachBlockDevice(io::Error),
-    /// Unable to attach the VMGenID device: {0}
-    AttachVmgenidDevice(#[from] AttachVmgenidError),
-    #[cfg(target_arch = "aarch64")]
-    /// Unable to attach legacy MMIO devices: {0}
-    AttachLegacyDevices(#[from] AttachLegacyMmioDeviceError),
+    /// Could not attach device: {0}
+    AttachDevice(#[from] AttachDeviceError),
     /// System configuration error: {0}
     ConfigureSystem(#[from] ConfigurationError),
     /// Failed to create device manager: {0}
@@ -104,8 +101,6 @@ pub enum StartMicrovmError {
     NetDeviceNotConfigured,
     /// Cannot open the block device backing file: {0}
     OpenBlockDevice(io::Error),
-    /// Cannot initialize a MMIO Device or add a device to the MMIO Bus or cmdline: {0}
-    RegisterMmioDevice(#[from] device_manager::AttachMmioDeviceError),
     /// Cannot restore microvm state: {0}
     RestoreMicrovmState(MicrovmStateError),
     /// Cannot set vm resources: {0}
@@ -563,7 +558,7 @@ fn attach_entropy_device(
     cmdline: &mut LoaderKernelCmdline,
     entropy_device: &Arc<Mutex<Entropy>>,
     event_manager: &mut EventManager,
-) -> Result<(), AttachMmioDeviceError> {
+) -> Result<(), AttachDeviceError> {
     let id = entropy_device
         .lock()
         .expect("Poisoned lock")
@@ -625,7 +620,7 @@ fn attach_unixsock_vsock_device(
     cmdline: &mut LoaderKernelCmdline,
     unix_vsock: &Arc<Mutex<Vsock<VsockUnixBackend>>>,
     event_manager: &mut EventManager,
-) -> Result<(), AttachMmioDeviceError> {
+) -> Result<(), AttachDeviceError> {
     let id = String::from(unix_vsock.lock().expect("Poisoned lock").id());
     event_manager.add_subscriber(unix_vsock.clone());
     // The device mutex mustn't be locked here otherwise it will deadlock.
@@ -638,7 +633,7 @@ fn attach_balloon_device(
     cmdline: &mut LoaderKernelCmdline,
     balloon: &Arc<Mutex<Balloon>>,
     event_manager: &mut EventManager,
-) -> Result<(), AttachMmioDeviceError> {
+) -> Result<(), AttachDeviceError> {
     let id = String::from(balloon.lock().expect("Poisoned lock").id());
     event_manager.add_subscriber(balloon.clone());
     // The device mutex mustn't be locked here otherwise it will deadlock.

src/vmm/src/device_manager/mod.rs

@@ -64,34 +64,21 @@ pub enum DeviceManagerCreateError {
 
 #[derive(Debug, thiserror::Error, displaydoc::Display)]
 /// Error while attaching a VirtIO device
-pub enum AttachMmioDeviceError {
+pub enum AttachDeviceError {
     /// MMIO transport error: {0}
     MmioTransport(#[from] MmioError),
     /// Error inserting device in bus: {0}
     Bus(#[from] vm_device::BusError),
-}
-
-#[derive(Debug, thiserror::Error, displaydoc::Display)]
-/// Error while attaching the VMGenID device
-pub enum AttachVmgenidError {
     /// Error creating VMGenID device: {0}
     CreateVmGenID(#[from] VmGenIdError),
     /// Error while registering VMGenID with KVM: {0}
     AttachVmGenID(#[from] kvm_ioctls::Error),
-}
-
-#[cfg(target_arch = "aarch64")]
-#[derive(Debug, thiserror::Error, displaydoc::Display)]
-/// Error while attaching the VMGenID device
-pub enum AttachLegacyMmioDeviceError {
+    #[cfg(target_arch = "aarch64")]
     /// Cmdline error
     Cmdline,
+    #[cfg(target_arch = "aarch64")]
     /// Error creating serial device: {0}
     CreateSerial(#[from] std::io::Error),
-    /// Error registering device: {0}
-    RegisterMMIODevice(#[from] MmioError),
-    /// Error inserting device in the Bus: {0}
-    Bus(#[from] vm_device::BusError),
 }
 
 #[derive(Debug)]
@@ -181,7 +168,7 @@ impl DeviceManager {
         device: Arc<Mutex<T>>,
         cmdline: &mut Cmdline,
         is_vhost_user: bool,
-    ) -> Result<(), AttachMmioDeviceError> {
+    ) -> Result<(), AttachDeviceError> {
         let interrupt = Arc::new(IrqTrigger::new());
         // The device mutex mustn't be locked here otherwise it will deadlock.
         let device =
@@ -201,7 +188,7 @@ impl DeviceManager {
     pub(crate) fn attach_boot_timer_device(
         &mut self,
         request_ts: TimestampUs,
-    ) -> Result<(), AttachMmioDeviceError> {
+    ) -> Result<(), AttachDeviceError> {
         let boot_timer = Arc::new(Mutex::new(BootTimer::new(request_ts)));
 
         self.mmio_devices
@@ -214,7 +201,7 @@ impl DeviceManager {
         &mut self,
         mem: &GuestMemoryMmap,
         vm: &Vm,
-    ) -> Result<(), AttachVmgenidError> {
+    ) -> Result<(), AttachDeviceError> {
         let vmgenid = VmGenId::new(mem, &self.resource_allocator)?;
         self.acpi_devices.attach_vmgenid(vmgenid, vm)?;
         Ok(())
@@ -226,13 +213,13 @@ impl DeviceManager {
         vm: &Vm,
         event_manager: &mut EventManager,
         cmdline: &mut Cmdline,
-    ) -> Result<(), AttachLegacyMmioDeviceError> {
+    ) -> Result<(), AttachDeviceError> {
         // Serial device setup.
         let cmdline_contains_console = cmdline
             .as_cstring()
-            .map_err(|_| AttachLegacyMmioDeviceError::Cmdline)?
+            .map_err(|_| AttachDeviceError::Cmdline)?
             .into_string()
-            .map_err(|_| AttachLegacyMmioDeviceError::Cmdline)?
+            .map_err(|_| AttachDeviceError::Cmdline)?
             .contains("console=");
 
         if cmdline_contains_console {