fix: Refactor vmm builder code to simplify logic

remove cfg_attr and extract create_vcpus from create_vmm_and_vcpus

Signed-off-by: tommady <[email protected]>

Author: tommady

src/vmm/src/builder.rs

@@ -148,7 +148,6 @@ impl std::convert::From<linux_loader::cmdline::Error> for StartMicrovmError {
     }
 }
 
-#[cfg_attr(target_arch = "aarch64", allow(unused))]
 fn create_vmm_and_vcpus(
     instance_info: &InstanceInfo,
     event_manager: &mut EventManager,
@@ -179,17 +178,8 @@ fn create_vmm_and_vcpus(
 
     // Instantiate ACPI device manager.
     let acpi_device_manager = ACPIDeviceManager::new();
-
-    // For x86_64 we need to create the interrupt controller before calling `KVM_CREATE_VCPUS`
-    // while on aarch64 we need to do it the other way around.
     #[cfg(target_arch = "x86_64")]
-    let (vcpus, pio_device_manager) = {
-        setup_interrupt_controller(&mut vm)?;
-        let vcpus = create_vcpus(&vm, vm_config.vcpu_count, &vcpus_exit_evt).map_err(Internal)?;
-
-        // Make stdout non blocking.
-        set_stdout_nonblocking();
-
+    let pio_device_manager = {
         // Serial device setup.
         let serial_device =
             setup_serial_device(event_manager, std::io::stdin(), io::stdout()).map_err(Internal)?;
@@ -208,19 +198,10 @@ fn create_vmm_and_vcpus(
             pio_dev_mgr
         };
 
-        (vcpus, pio_device_manager)
+        pio_device_manager
     };
 
-    // On aarch64, the vCPUs need to be created (i.e call KVM_CREATE_VCPU) before setting up the
-    // IRQ chip because the `KVM_CREATE_VCPU` ioctl will return error if the IRQCHIP
-    // was already initialized.
-    // Search for `kvm_arch_vcpu_create` in arch/arm/kvm/arm.c.
-    #[cfg(target_arch = "aarch64")]
-    let vcpus = {
-        let vcpus = create_vcpus(&vm, vcpu_count, &vcpus_exit_evt).map_err(Internal)?;
-        setup_interrupt_controller(&mut vm, vcpu_count)?;
-        vcpus
-    };
+    let vcpus = create_vcpus(&mut vm, vm_config.vcpu_count, &vcpus_exit_evt).map_err(Internal)?;
 
     let vmm = Vmm {
         events_observer: Some(std::io::stdin()),
@@ -659,18 +640,14 @@ where
 
 /// Sets up the irqchip for a x86_64 microVM.
 #[cfg(target_arch = "x86_64")]
-pub fn setup_interrupt_controller(vm: &mut Vm) -> Result<(), StartMicrovmError> {
-    vm.setup_irqchip()
-        .map_err(VmmError::Vm)
-        .map_err(StartMicrovmError::Internal)
+pub fn setup_interrupt_controller(vm: &mut Vm) -> Result<(), VmmError> {
+    vm.setup_irqchip().map_err(VmmError::Vm)
 }
 
 /// Sets up the irqchip for a aarch64 microVM.
 #[cfg(target_arch = "aarch64")]
-pub fn setup_interrupt_controller(vm: &mut Vm, vcpu_count: u8) -> Result<(), StartMicrovmError> {
-    vm.setup_irqchip(vcpu_count)
-        .map_err(VmmError::Vm)
-        .map_err(StartMicrovmError::Internal)
+pub fn setup_interrupt_controller(vm: &mut Vm, vcpu_count: u8) -> Result<(), VmmError> {
+    vm.setup_irqchip(vcpu_count).map_err(VmmError::Vm)
 }
 
 /// Sets up the serial device.
@@ -730,13 +707,39 @@ fn attach_legacy_devices_aarch64(
         .map_err(VmmError::RegisterMMIODevice)
 }
 
-fn create_vcpus(vm: &Vm, vcpu_count: u8, exit_evt: &EventFd) -> Result<Vec<Vcpu>, VmmError> {
+// For x86_64 we need to create the interrupt controller before calling `KVM_CREATE_VCPUS`
+// while on aarch64 we need to do it the other way around.
+#[cfg(target_arch = "x86_64")]
+fn create_vcpus(vm: &mut Vm, vcpu_count: u8, exit_evt: &EventFd) -> Result<Vec<Vcpu>, VmmError> {
+    setup_interrupt_controller(vm)?;
+
+    let mut vcpus = Vec::with_capacity(vcpu_count as usize);
+    for cpu_idx in 0..vcpu_count {
+        let exit_evt = exit_evt.try_clone().map_err(VmmError::EventFd)?;
+        let vcpu = Vcpu::new(cpu_idx, vm, exit_evt).map_err(VmmError::VcpuCreate)?;
+        vcpus.push(vcpu);
+    }
+    // Make stdout non blocking.
+    set_stdout_nonblocking();
+
+    Ok(vcpus)
+}
+
+// On aarch64, the vCPUs need to be created (i.e call KVM_CREATE_VCPU) before setting up the
+// IRQ chip because the `KVM_CREATE_VCPU` ioctl will return error if the IRQCHIP
+// was already initialized.
+// Search for `kvm_arch_vcpu_create` in arch/arm/kvm/arm.c.
+#[cfg(target_arch = "aarch64")]
+fn create_vcpus(vm: &mut Vm, vcpu_count: u8, exit_evt: &EventFd) -> Result<Vec<Vcpu>, VmmError> {
     let mut vcpus = Vec::with_capacity(vcpu_count as usize);
     for cpu_idx in 0..vcpu_count {
         let exit_evt = exit_evt.try_clone().map_err(VmmError::EventFd)?;
         let vcpu = Vcpu::new(cpu_idx, vm, exit_evt).map_err(VmmError::VcpuCreate)?;
         vcpus.push(vcpu);
     }
+
+    setup_interrupt_controller(vm, vcpu_count)?;
+
     Ok(vcpus)
 }
 
@@ -1362,7 +1365,7 @@ pub mod tests {
         #[cfg(target_arch = "x86_64")]
         setup_interrupt_controller(&mut vm).unwrap();
 
-        let vcpu_vec = create_vcpus(&vm, vcpu_count, &evfd).unwrap();
+        let vcpu_vec = create_vcpus(&mut vm, vcpu_count, &evfd).unwrap();
         assert_eq!(vcpu_vec.len(), vcpu_count as usize);
     }