test: add Rust integration tests for PCI-enabled uVMs

We have some 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);
+    let (vmm, evmgr) = default_vmm(None);
+    check_booted_microvm(vmm, evmgr);
 
-    // 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)
-    );
+    // 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.
@@ -185,11 +208,11 @@ fn test_disallow_dump_cpu_config_without_pausing() {
     vmm.lock().unwrap().stop(FcExitCode::Ok);
 }
 
-fn verify_create_snapshot(is_diff: bool) -> (TempFile, TempFile) {
+fn verify_create_snapshot(is_diff: bool, pci_enabled: bool) -> (TempFile, TempFile) {
     let snapshot_file = TempFile::new().unwrap();
     let memory_file = TempFile::new().unwrap();
 
-    let (vmm, _) = create_vmm(Some(NOISY_KERNEL_IMAGE), is_diff, true);
+    let (vmm, _) = create_vmm(Some(NOISY_KERNEL_IMAGE), is_diff, true, pci_enabled);
     let resources = VmResources {
         machine_config: MachineConfig {
             mem_size_mib: 1,
@@ -296,29 +319,27 @@ fn verify_load_snapshot(snapshot_file: TempFile, memory_file: TempFile) {
 
 #[test]
 fn test_create_and_load_snapshot() {
-    // Create diff snapshot.
-    let (snapshot_file, memory_file) = verify_create_snapshot(true);
-    // Create a new microVm from snapshot. This only tests code-level logic; it verifies
-    // that a microVM can be built with no errors from given snapshot.
-    // It does _not_ verify that the guest is actually restored properly. We're using
-    // python integration tests for that.
-    verify_load_snapshot(snapshot_file, memory_file);
-
-    // Create full snapshot.
-    let (snapshot_file, memory_file) = verify_create_snapshot(false);
-    // Create a new microVm from snapshot. This only tests code-level logic; it verifies
-    // that a microVM can be built with no errors from given snapshot.
-    // It does _not_ verify that the guest is actually restored properly. We're using
-    // python integration tests for that.
-    verify_load_snapshot(snapshot_file, memory_file);
+    for (diff_snap, pci_enabled) in [(false, false), (false, true), (true, false), (true, true)] {
+        // Create snapshot.
+        let (snapshot_file, memory_file) = verify_create_snapshot(diff_snap, pci_enabled);
+        // Create a new microVm from snapshot. This only tests code-level logic; it verifies
+        // that a microVM can be built with no errors from given snapshot.
+        // It does _not_ verify that the guest is actually restored properly. We're using
+        // python integration tests for that.
+        verify_load_snapshot(snapshot_file, memory_file);
+    }
 }
 
 #[test]
 fn test_snapshot_load_sanity_checks() {
-    use vmm::persist::SnapShotStateSanityCheckError;
-
-    let mut microvm_state = get_microvm_state_from_snapshot();
+    let microvm_state = get_microvm_state_from_snapshot(false);
+    check_snapshot(microvm_state);
+    let microvm_state = get_microvm_state_from_snapshot(true);
+    check_snapshot(microvm_state);
+}
 
+fn check_snapshot(mut microvm_state: MicrovmState) {
+    use vmm::persist::SnapShotStateSanityCheckError;
     snapshot_state_sanity_check(&microvm_state).unwrap();
 
     // Remove memory regions.
@@ -331,9 +352,9 @@ fn test_snapshot_load_sanity_checks() {
     );
 }
 
-fn get_microvm_state_from_snapshot() -> MicrovmState {
+fn get_microvm_state_from_snapshot(pci_enabled: bool) -> MicrovmState {
     // Create a diff snapshot
-    let (snapshot_file, _) = verify_create_snapshot(true);
+    let (snapshot_file, _) = verify_create_snapshot(true, pci_enabled);
 
     // Deserialize the microVM state.
     let snapshot_file_metadata = snapshot_file.as_file().metadata().unwrap();
@@ -344,7 +365,7 @@ fn get_microvm_state_from_snapshot() -> MicrovmState {
 }
 
 fn verify_load_snap_disallowed_after_boot_resources(res: VmmAction, res_name: &str) {
-    let (snapshot_file, memory_file) = verify_create_snapshot(false);
+    let (snapshot_file, memory_file) = verify_create_snapshot(false, false);
 
     let mut event_manager = EventManager::new().unwrap();
     let empty_seccomp_filters = get_empty_filters();