vmm: std::convert::From<StartMicrovmError> for VmmActionError

Decorate each type of StartMicrovmError with the correct ErrorKind.

Signed-off-by: Adrian Catangiu <[email protected]>

Author: acatangiu

vmm/src/lib.rs

@@ -212,6 +212,49 @@ pub enum VmmActionError {
     VsockConfig(ErrorKind, VsockError),
 }
 
+// It's convenient to turn StartMicrovmErrors into VmmActionErrors directly.
+impl std::convert::From<StartMicrovmError> for VmmActionError {
+    fn from(e: StartMicrovmError) -> Self {
+        let kind = match e {
+            // User errors.
+            #[cfg(feature = "vsock")]
+            StartMicrovmError::CreateVsockDevice(_) => ErrorKind::User,
+            StartMicrovmError::CreateBlockDevice(_)
+            | StartMicrovmError::CreateNetDevice(_)
+            | StartMicrovmError::KernelCmdline(_)
+            | StartMicrovmError::KernelLoader(_)
+            | StartMicrovmError::MicroVMAlreadyRunning
+            | StartMicrovmError::MissingKernelConfig
+            | StartMicrovmError::NetDeviceNotConfigured
+            | StartMicrovmError::OpenBlockDevice(_)
+            | StartMicrovmError::VcpusNotConfigured => ErrorKind::User,
+            // Internal errors.
+            #[cfg(feature = "vsock")]
+            StartMicrovmError::RegisterVsockDevice(_) => ErrorKind::Internal,
+            StartMicrovmError::ConfigureSystem(_)
+            | StartMicrovmError::ConfigureVm(_)
+            | StartMicrovmError::CreateRateLimiter(_)
+            | StartMicrovmError::DeviceManager
+            | StartMicrovmError::EventFd
+            | StartMicrovmError::GuestMemory(_)
+            | StartMicrovmError::LegacyIOBus(_)
+            | StartMicrovmError::RegisterBlockDevice(_)
+            | StartMicrovmError::RegisterEvent
+            | StartMicrovmError::RegisterNetDevice(_)
+            | StartMicrovmError::SeccompFilters(_)
+            | StartMicrovmError::Vcpu(_)
+            | StartMicrovmError::VcpuConfigure(_)
+            | StartMicrovmError::VcpuSpawn(_) => ErrorKind::Internal,
+            // The only user `LoadCommandline` error is `CommandLineOverflow`.
+            StartMicrovmError::LoadCommandline(ref cle) => match cle {
+                kernel_loader::Error::CommandLineOverflow => ErrorKind::User,
+                _ => ErrorKind::Internal,
+            },
+        };
+        VmmActionError::StartMicrovm(kind, e)
+    }
+}
+
 impl VmmActionError {
     /// Returns the error type.
     pub fn get_kind(&self) -> &ErrorKind {
@@ -1175,51 +1218,36 @@ impl Vmm {
     fn start_microvm(&mut self) -> std::result::Result<VmmData, VmmActionError> {
         info!("VMM received instance start command");
         if self.is_instance_initialized() {
-            return Err(VmmActionError::StartMicrovm(
-                ErrorKind::User,
-                StartMicrovmError::MicroVMAlreadyRunning,
-            ));
+            Err(StartMicrovmError::MicroVMAlreadyRunning)?;
         }
         let request_ts = TimestampUs {
             time_us: get_time_us(),
             cputime_us: now_cputime_us(),
         };
 
-        self.check_health()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::User, e))?;
+        self.check_health()?;
         // Use expect() to crash if the other thread poisoned this lock.
         self.shared_info
             .write()
             .expect("Failed to start microVM because shared info couldn't be written due to poisoned lock")
             .state = InstanceState::Starting;
 
-        self.init_guest_memory()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.init_guest_memory()?;
 
-        self.setup_interrupt_controller()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.setup_interrupt_controller()?;
 
-        self.attach_virtio_devices()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
-        self.attach_legacy_devices()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.attach_virtio_devices()?;
+        self.attach_legacy_devices()?;
 
-        let entry_addr = self
-            .load_kernel()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        let entry_addr = self.load_kernel()?;
 
-        self.configure_system()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.configure_system()?;
 
-        self.register_events()
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.register_events()?;
 
-        let vcpus = self
-            .create_vcpus(entry_addr, request_ts)
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        let vcpus = self.create_vcpus(entry_addr, request_ts)?;
 
-        self.start_vcpus(vcpus)
-            .map_err(|e| VmmActionError::StartMicrovm(ErrorKind::Internal, e))?;
+        self.start_vcpus(vcpus)?;
         // Use expect() to crash if the other thread poisoned this lock.
         self.shared_info
             .write()
@@ -1989,7 +2017,6 @@ mod tests {
     use super::*;
 
     use serde_json::Value;
-    use std::env;
     use std::fs::File;
     use std::io::BufRead;
     use std::io::BufReader;

vmm/src/vstate.rs

@@ -76,21 +76,21 @@ pub enum Error {
     /// Cannot configure the IRQ.
     Irq(io::Error),
     /// Cannot spawn a new vCPU thread.
-    VcpuSpawn(std::io::Error),
+    VcpuSpawn(io::Error),
     /// Unexpected KVM_RUN exit reason
     VcpuUnhandledKvmExit,
     #[cfg(target_arch = "aarch64")]
     /// Error setting up the global interrupt controller.
     SetupGIC(arch::aarch64::gic::Error),
+    #[cfg(target_arch = "aarch64")]
+    /// Error getting the Vcpu preferred target on Arm.
+    VcpuArmPreferredTarget(io::Error),
+    #[cfg(target_arch = "aarch64")]
+    /// Error doing Vcpu Init on Arm.
+    VcpuArmInit(io::Error),
 }
 pub type Result<T> = result::Result<T, Error>;
 
-impl ::std::convert::From<io::Error> for Error {
-    fn from(e: io::Error) -> Error {
-        Error::SetUserMemoryRegion(e)
-    }
-}
-
 /// A wrapper around creating and using a VM.
 pub struct Vm {
     fd: VmFd,
@@ -136,24 +136,26 @@ impl Vm {
         if guest_mem.num_regions() > kvm_context.max_memslots() {
             return Err(Error::NotEnoughMemorySlots);
         }
-        guest_mem.with_regions(|index, guest_addr, size, host_addr| {
-            info!("Guest memory starts at {:x?}", host_addr);
-
-            let flags = if LOGGER.flags() & LogOption::LogDirtyPages as usize > 0 {
-                KVM_MEM_LOG_DIRTY_PAGES
-            } else {
-                0
-            };
-
-            let memory_region = kvm_userspace_memory_region {
-                slot: index as u32,
-                guest_phys_addr: guest_addr.offset() as u64,
-                memory_size: size as u64,
-                userspace_addr: host_addr as u64,
-                flags,
-            };
-            self.fd.set_user_memory_region(memory_region)
-        })?;
+        guest_mem
+            .with_regions(|index, guest_addr, size, host_addr| {
+                info!("Guest memory starts at {:x?}", host_addr);
+
+                let flags = if LOGGER.flags() & LogOption::LogDirtyPages as usize > 0 {
+                    KVM_MEM_LOG_DIRTY_PAGES
+                } else {
+                    0
+                };
+
+                let memory_region = kvm_userspace_memory_region {
+                    slot: index as u32,
+                    guest_phys_addr: guest_addr.offset() as u64,
+                    memory_size: size as u64,
+                    userspace_addr: host_addr as u64,
+                    flags,
+                };
+                self.fd.set_user_memory_region(memory_region)
+            })
+            .map_err(Error::SetUserMemoryRegion)?;
         self.guest_mem = Some(guest_mem);
 
         #[cfg(target_arch = "x86_64")]
@@ -330,15 +332,17 @@ impl Vcpu {
         let mut kvi: kvm_bindings::kvm_vcpu_init = kvm_bindings::kvm_vcpu_init::default();
 
         // This reads back the kernel's preferred target type.
-        vm.fd.get_preferred_target(&mut kvi)?;
+        vm.fd
+            .get_preferred_target(&mut kvi)
+            .map_err(Error::VcpuArmPreferredTarget)?;
         // We already checked that the capability is supported.
         kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_PSCI_0_2;
         // Non-boot cpus are powered off initially.
         if self.id > 0 {
             kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_POWER_OFF;
         }
 
-        self.fd.vcpu_init(&kvi)?;
+        self.fd.vcpu_init(&kvi).map_err(Error::VcpuArmInit)?;
         arch::aarch64::regs::setup_regs(&self.fd, self.id, kernel_load_addr.offset(), vm_memory)
             .map_err(Error::REGSConfiguration)?;
         Ok(())