test: add Rust integration tests for PCI-enabled uVMs

We have a couple of Rust integration tests that check building and
booting of microVMs works correctly. Add variants for PCI-enabled
microVMs.

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

Author: bchalios

src/vmm/src/test_utils/mod.rs

@@ -69,6 +69,7 @@ pub fn create_vmm(
     _kernel_image: Option<&str>,
     is_diff: bool,
     boot_microvm: bool,
+    pci_enabled: bool,
 ) -> (Arc<Mutex<Vmm>>, EventManager) {
     let mut event_manager = EventManager::new().unwrap();
     let empty_seccomp_filters = get_empty_filters();
@@ -82,14 +83,16 @@ pub fn create_vmm(
         None => boot_source_cfg.into(),
     };
     let mock_vm_res = MockVmResources::new().with_boot_source(boot_source_cfg);
-    let resources: VmResources = if is_diff {
+    let mut resources: VmResources = if is_diff {
         mock_vm_res
             .with_vm_config(MockVmConfig::new().with_dirty_page_tracking().into())
             .into()
     } else {
         mock_vm_res.into()
     };
 
+    resources.pci_enabled = pci_enabled;
+
     let vmm = build_microvm_for_boot(
         &InstanceInfo::default(),
         &resources,
@@ -106,16 +109,24 @@ pub fn create_vmm(
 }
 
 pub fn default_vmm(kernel_image: Option<&str>) -> (Arc<Mutex<Vmm>>, EventManager) {
-    create_vmm(kernel_image, false, true)
+    create_vmm(kernel_image, false, true, false)
 }
 
 pub fn default_vmm_no_boot(kernel_image: Option<&str>) -> (Arc<Mutex<Vmm>>, EventManager) {
-    create_vmm(kernel_image, false, false)
+    create_vmm(kernel_image, false, false, false)
+}
+
+pub fn default_vmm_pci_no_boot(kernel_image: Option<&str>) -> (Arc<Mutex<Vmm>>, EventManager) {
+    create_vmm(kernel_image, false, false, true)
 }
 
 #[cfg(target_arch = "x86_64")]
 pub fn dirty_tracking_vmm(kernel_image: Option<&str>) -> (Arc<Mutex<Vmm>>, EventManager) {
-    create_vmm(kernel_image, true, true)
+    create_vmm(kernel_image, true, true, false)
+}
+
+pub fn default_vmm_pci(kernel_image: Option<&str>) -> (Arc<Mutex<Vmm>>, EventManager) {
+    create_vmm(kernel_image, false, true, false)
 }
 
 #[allow(clippy::undocumented_unsafe_blocks)]

src/vmm/tests/integration_tests.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::io::{Seek, SeekFrom};
+use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 
@@ -15,7 +16,9 @@ use vmm::rpc_interface::{
 use vmm::seccomp::get_empty_filters;
 use vmm::snapshot::Snapshot;
 use vmm::test_utils::mock_resources::{MockVmResources, NOISY_KERNEL_IMAGE};
-use vmm::test_utils::{create_vmm, default_vmm, default_vmm_no_boot};
+use vmm::test_utils::{
+    create_vmm, default_vmm, default_vmm_no_boot, default_vmm_pci, default_vmm_pci_no_boot,
+};
 use vmm::vmm_config::balloon::BalloonDeviceConfig;
 use vmm::vmm_config::boot_source::BootSourceConfig;
 use vmm::vmm_config::drive::BlockDeviceConfig;
@@ -26,9 +29,23 @@ use vmm::vmm_config::snapshot::{
     CreateSnapshotParams, LoadSnapshotParams, MemBackendConfig, MemBackendType, SnapshotType,
 };
 use vmm::vmm_config::vsock::VsockDeviceConfig;
-use vmm::{DumpCpuConfigError, EventManager, FcExitCode};
+use vmm::{DumpCpuConfigError, EventManager, FcExitCode, Vmm};
 use vmm_sys_util::tempfile::TempFile;
 
+fn check_booted_microvm(vmm: Arc<Mutex<Vmm>>, mut evmgr: EventManager) {
+    // On x86_64, the vmm should exit once its workload completes and signals the exit event.
+    // On aarch64, the test kernel doesn't exit, so the vmm is force-stopped.
+    #[cfg(target_arch = "x86_64")]
+    evmgr.run_with_timeout(500).unwrap();
+    #[cfg(target_arch = "aarch64")]
+    vmm.lock().unwrap().stop(FcExitCode::Ok);
+
+    assert_eq!(
+        vmm.lock().unwrap().shutdown_exit_code(),
+        Some(FcExitCode::Ok)
+    );
+}
+
 #[test]
 fn test_build_and_boot_microvm() {
     // Error case: no boot source configured.
@@ -47,33 +64,24 @@ fn test_build_and_boot_microvm() {
     }
 
     // Success case.
-    let (vmm, mut _evmgr) = default_vmm(None);
-
-    // On x86_64, the vmm should exit once its workload completes and signals the exit event.
-    // On aarch64, the test kernel doesn't exit, so the vmm is force-stopped.
-    #[cfg(target_arch = "x86_64")]
-    _evmgr.run_with_timeout(500).unwrap();
-    #[cfg(target_arch = "aarch64")]
-    vmm.lock().unwrap().stop(FcExitCode::Ok);
+    let (vmm, evmgr) = default_vmm(None);
+    check_booted_microvm(vmm, evmgr);
 
-    assert_eq!(
-        vmm.lock().unwrap().shutdown_exit_code(),
-        Some(FcExitCode::Ok)
-    );
+    // microVM with PCI
+    let (vmm, evmgr) = default_vmm_pci(None);
+    check_booted_microvm(vmm, evmgr);
 }
 
-#[test]
-fn test_build_microvm() {
+fn check_build_microvm(vmm: Arc<Mutex<Vmm>>, mut evmgr: EventManager) {
     // The built microVM should be in the `VmState::Paused` state here.
-    let (vmm, mut _evtmgr) = default_vmm_no_boot(None);
     assert_eq!(vmm.lock().unwrap().instance_info().state, VmState::Paused);
 
     // The microVM should be able to resume and exit successfully.
     // On x86_64, the vmm should exit once its workload completes and signals the exit event.
     // On aarch64, the test kernel doesn't exit, so the vmm is force-stopped.
     vmm.lock().unwrap().resume_vm().unwrap();
     #[cfg(target_arch = "x86_64")]
-    _evtmgr.run_with_timeout(500).unwrap();
+    evmgr.run_with_timeout(500).unwrap();
     #[cfg(target_arch = "aarch64")]
     vmm.lock().unwrap().stop(FcExitCode::Ok);
     assert_eq!(
@@ -83,10 +91,14 @@ fn test_build_microvm() {
 }
 
 #[test]
-fn test_pause_resume_microvm() {
-    // Tests that pausing and resuming a microVM work as expected.
-    let (vmm, _) = default_vmm(None);
+fn test_build_microvm() {
+    let (vmm, evtmgr) = default_vmm_no_boot(None);
+    check_build_microvm(vmm, evtmgr);
+    let (vmm, evtmgr) = default_vmm_pci_no_boot(None);
+    check_build_microvm(vmm, evtmgr);
+}
 
+fn pause_resume_microvm(vmm: Arc<Mutex<Vmm>>) {
     let mut api_controller = RuntimeApiController::new(VmResources::default(), vmm.clone());
 
     // There's a race between this thread and the vcpu thread, but this thread
@@ -100,6 +112,17 @@ fn test_pause_resume_microvm() {
     vmm.lock().unwrap().stop(FcExitCode::Ok);
 }
 
+#[test]
+fn test_pause_resume_microvm() {
+    // Tests that pausing and resuming a microVM work as expected.
+    let (vmm, _) = default_vmm(None);
+
+    pause_resume_microvm(vmm);
+
+    let (vmm, _) = default_vmm_pci(None);
+    pause_resume_microvm(vmm);
+}
+
 #[test]
 fn test_dirty_bitmap_error() {
     // Error case: dirty tracking disabled.