fixup: run more tests on PCI enabled

This commit allows more test to run with PCI enabled, just in case we
missed something else.

Signed-off-by: Riccardo Mancini <[email protected]>

Author: Manciukic

tests/integration_tests/functional/test_balloon.py

@@ -449,11 +449,11 @@ def test_stats_update(uvm_plain_any):
     assert next_stats["available_memory"] != final_stats["available_memory"]
 
 
-def test_balloon_snapshot(microvm_factory, guest_kernel, rootfs):
+def test_balloon_snapshot(uvm_plain_any, microvm_factory):
     """
     Test that the balloon works after pause/resume.
     """
-    vm = microvm_factory.build(guest_kernel, rootfs)
+    vm = uvm_plain_any
     vm.spawn()
     vm.basic_config(
         vcpu_count=2,
@@ -531,11 +531,11 @@ def test_balloon_snapshot(microvm_factory, guest_kernel, rootfs):
     assert stats_after_snap["available_memory"] > latest_stats["available_memory"]
 
 
-def test_memory_scrub(microvm_factory, guest_kernel, rootfs):
+def test_memory_scrub(uvm_plain_any):
     """
     Test that the memory is zeroed after deflate.
     """
-    microvm = microvm_factory.build(guest_kernel, rootfs)
+    microvm = uvm_plain_any
     microvm.spawn()
     microvm.basic_config(vcpu_count=2, mem_size_mib=256)
     microvm.add_net_iface()

tests/integration_tests/functional/test_concurrency.py

@@ -7,13 +7,13 @@
 NO_OF_MICROVMS = 20
 
 
-def test_run_concurrency(microvm_factory, guest_kernel, rootfs):
+def test_run_concurrency(microvm_factory, guest_kernel, rootfs, pci_enabled):
     """
     Check we can spawn multiple microvms.
     """
 
     def launch1():
-        microvm = microvm_factory.build(guest_kernel, rootfs)
+        microvm = microvm_factory.build(guest_kernel, rootfs, pci=pci_enabled)
         microvm.time_api_requests = False  # is flaky because of parallelism
         microvm.spawn()
         microvm.basic_config(vcpu_count=1, mem_size_mib=128)

tests/integration_tests/functional/test_cpu_template_helper.py

@@ -261,9 +261,7 @@ def get_guest_msrs(microvm, msr_index_list):
     ),
 )
 def test_cpu_config_dump_vs_actual(
-    microvm_factory,
-    guest_kernel,
-    rootfs,
+    uvm_plain_any,
     cpu_template_helper,
     tmp_path,
 ):
@@ -277,7 +275,7 @@ def test_cpu_config_dump_vs_actual(
     dump_cpu_config = build_cpu_config_dict(cpu_config_path)
 
     # Retrieve actual CPU config from guest
-    microvm = microvm_factory.build(guest_kernel, rootfs)
+    microvm = uvm_plain_any
     microvm.spawn()
     microvm.basic_config(vcpu_count=1)
     microvm.add_net_iface()

tests/integration_tests/functional/test_drive_vhost_user.py

@@ -6,11 +6,62 @@
 import shutil
 from pathlib import Path
 
+import pytest
+
 import host_tools.drive as drive_tools
 from framework.utils_drive import partuuid_and_disk_path
 from host_tools.fcmetrics import FcDeviceMetrics
 
 
+@pytest.fixture
+def uvm_vhost_user_plain_any(microvm_factory, guest_kernel, pci_enabled):
+    """Builds a plain VM with no root volume"""
+    return microvm_factory.build(
+        guest_kernel, None, pci=pci_enabled, monitor_memory=False
+    )
+
+
+@pytest.fixture
+def uvm_vhost_user_booted_ro(uvm_vhost_user_plain_any, rootfs):
+    """Returns a VM with a vhost-user rootfs"""
+    vm = uvm_vhost_user_plain_any
+
+    # We need to setup ssh keys manually because we did not specify rootfs
+    # in microvm_factory.build method
+    ssh_key = rootfs.with_suffix(".id_rsa")
+    vm.ssh_key = ssh_key
+    vm.spawn()
+    vm.basic_config(add_root_device=False)
+    vm.add_vhost_user_drive("rootfs", rootfs, is_root_device=True, is_read_only=True)
+    vm.add_net_iface()
+    vm.start()
+
+    return vm
+
+
+@pytest.fixture
+def uvm_vhost_user_booted_rw(uvm_vhost_user_plain_any, rootfs):
+    """Returns a VM with a vhost-user rootfs"""
+    vm = uvm_vhost_user_plain_any
+
+    # We need to setup ssh keys manually because we did not specify rootfs
+    # in microvm_factory.build method
+    ssh_key = rootfs.with_suffix(".id_rsa")
+    vm.ssh_key = ssh_key
+    vm.spawn()
+    vm.basic_config(add_root_device=False)
+    # Create a rw rootfs file that is unique to the microVM
+    rootfs_rw = Path(vm.chroot()) / "rootfs"
+    shutil.copy(rootfs, rootfs_rw)
+    vm.add_vhost_user_drive(
+        "rootfs", rootfs_rw, is_root_device=True, is_read_only=False
+    )
+    vm.add_net_iface()
+    vm.start()
+
+    return vm
+
+
 def _check_block_size(ssh_connection, dev_path, size):
     """
     Checks the size of the block device.
@@ -34,26 +85,16 @@ def _check_drives(test_microvm, assert_dict, keys_array):
         assert blockdev_out_line_cols[col] == assert_dict[key]
 
 
-def test_vhost_user_block(microvm_factory, guest_kernel, rootfs):
+def test_vhost_user_block(uvm_vhost_user_booted_ro):
     """
     This test simply tries to boot a VM with
     vhost-user-block as a root device.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
-
-    # We need to setup ssh keys manually because we did not specify rootfs
-    # in microvm_factory.build method
-    ssh_key = rootfs.with_suffix(".id_rsa")
-    vm.ssh_key = ssh_key
-    vm.spawn()
-    vm.basic_config(add_root_device=False)
-    vm.add_vhost_user_drive("rootfs", rootfs, is_root_device=True, is_read_only=True)
-    vm.add_net_iface()
+    vm = uvm_vhost_user_booted_ro
     vhost_user_block_metrics = FcDeviceMetrics(
         "vhost_user_block", 1, aggr_supported=False
     )
-    vm.start()
 
     # Now check that vhost-user-block with rw is last.
     # 1-0 means line 1, column 0.
@@ -65,29 +106,14 @@ def test_vhost_user_block(microvm_factory, guest_kernel, rootfs):
     vhost_user_block_metrics.validate(vm)
 
 
-def test_vhost_user_block_read_write(microvm_factory, guest_kernel, rootfs):
+def test_vhost_user_block_read_write(uvm_vhost_user_booted_rw):
     """
     This test simply tries to boot a VM with
     vhost-user-block as a root device.
     This test configures vhost-user-block to be read write.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
-
-    # We need to setup ssh keys manually because we did not specify rootfs
-    # in microvm_factory.build method
-    ssh_key = rootfs.with_suffix(".id_rsa")
-    vm.ssh_key = ssh_key
-    vm.spawn()
-    vm.basic_config(add_root_device=False)
-
-    # Create a rw rootfs file that is unique to the microVM
-    rootfs_rw = Path(vm.chroot()) / "rootfs"
-    shutil.copy(rootfs, rootfs_rw)
-
-    vm.add_vhost_user_drive("rootfs", rootfs_rw, is_root_device=True)
-    vm.add_net_iface()
-    vm.start()
+    vm = uvm_vhost_user_booted_rw
 
     # Now check that vhost-user-block with rw is last.
     # 1-0 means line 1, column 0.
@@ -98,22 +124,12 @@ def test_vhost_user_block_read_write(microvm_factory, guest_kernel, rootfs):
     _check_drives(vm, assert_dict, assert_dict.keys())
 
 
-def test_vhost_user_block_disconnect(microvm_factory, guest_kernel, rootfs):
+def test_vhost_user_block_disconnect(uvm_vhost_user_booted_ro):
     """
     Test that even if backend is killed, Firecracker is still responsive.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
-
-    # We need to set up ssh keys manually because we did not specify rootfs
-    # in microvm_factory.build method
-    ssh_key = rootfs.with_suffix(".id_rsa")
-    vm.ssh_key = ssh_key
-    vm.spawn()
-    vm.basic_config(add_root_device=False)
-    vm.add_vhost_user_drive("rootfs", rootfs, is_root_device=True, is_read_only=True)
-    vm.add_net_iface()
-    vm.start()
+    vm = uvm_vhost_user_booted_ro
 
     # Killing the backend
     vm.disks_vhost_user["rootfs"].kill()
@@ -123,15 +139,15 @@ def test_vhost_user_block_disconnect(microvm_factory, guest_kernel, rootfs):
     _config = vm.api.vm_config.get().json()
 
 
-def test_device_ordering(microvm_factory, guest_kernel, rootfs):
+def test_device_ordering(uvm_vhost_user_plain_any, rootfs):
     """
     Verify device ordering.
 
     The root device should correspond to /dev/vda in the guest and
     the order of the other devices should match their configuration order.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
+    vm = uvm_vhost_user_plain_any
 
     # We need to setup ssh keys manually because we did not specify rootfs
     # in microvm_factory.build method
@@ -194,16 +210,12 @@ def test_device_ordering(microvm_factory, guest_kernel, rootfs):
     vhost_user_block_metrics.validate(vm)
 
 
-def test_partuuid_boot(
-    microvm_factory,
-    guest_kernel,
-    rootfs,
-):
+def test_partuuid_boot(uvm_vhost_user_plain_any, rootfs):
     """
     Test the output reported by blockdev when booting with PARTUUID.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
+    vm = uvm_vhost_user_plain_any
 
     # We need to setup ssh keys manually because we did not specify rootfs
     # in microvm_factory.build method
@@ -230,12 +242,12 @@ def test_partuuid_boot(
     _check_drives(vm, assert_dict, assert_dict.keys())
 
 
-def test_partuuid_update(microvm_factory, guest_kernel, rootfs):
+def test_partuuid_update(uvm_vhost_user_plain_any, rootfs):
     """
     Test successful switching from PARTUUID boot to /dev/vda boot.
     """
 
-    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
+    vm = uvm_vhost_user_plain_any
 
     # We need to setup ssh keys manually because we did not specify rootfs
     # in microvm_factory.build method
@@ -272,7 +284,7 @@ def test_partuuid_update(microvm_factory, guest_kernel, rootfs):
     vhost_user_block_metrics.validate(vm)
 
 
-def test_config_change(microvm_factory, guest_kernel, rootfs):
+def test_config_change(uvm_plain_any):
     """
     Verify handling of block device resize.
     We expect that the guest will start reporting the updated size
@@ -283,7 +295,7 @@ def test_config_change(microvm_factory, guest_kernel, rootfs):
     new_sizes = [20, 10, 30]  # MB
     mkfs_mount_cmd = "mkfs.ext4 /dev/vdb && mkdir -p /tmp/tmp && mount /dev/vdb /tmp/tmp && umount /tmp/tmp"
 
-    vm = microvm_factory.build(guest_kernel, rootfs, monitor_memory=False)
+    vm = uvm_plain_any
     vm.spawn(log_level="Info")
     vm.basic_config()
     vm.add_net_iface()

tests/integration_tests/functional/test_feat_parity.py

@@ -28,16 +28,11 @@ def inst_set_cpu_template_fxt(request):
 
 
 @pytest.fixture(name="vm")
-def vm_fxt(
-    microvm_factory,
-    inst_set_cpu_template,
-    guest_kernel,
-    rootfs,
-):
+def vm_fxt(uvm_plain_any, inst_set_cpu_template):
     """
     Create a VM, using the normal CPU templates
     """
-    vm = microvm_factory.build(guest_kernel, rootfs)
+    vm = uvm_plain_any
     vm.spawn()
     vm.basic_config(vcpu_count=1, mem_size_mib=1024, cpu_template=inst_set_cpu_template)
     vm.add_net_iface()

tests/integration_tests/functional/test_snapshot_basic.py

@@ -115,9 +115,8 @@ def test_snapshot_current_version(uvm_nano):
 def test_cycled_snapshot_restore(
     bin_vsock_path,
     tmp_path,
+    uvm_plain_any,
     microvm_factory,
-    guest_kernel,
-    rootfs,
     snapshot_type,
     use_snapshot_editor,
     cpu_template_any,
@@ -133,7 +132,7 @@ def test_cycled_snapshot_restore(
     logger = logging.getLogger("snapshot_sequence")
     diff_snapshots = snapshot_type == SnapshotType.DIFF
 
-    vm = microvm_factory.build(guest_kernel, rootfs)
+    vm = uvm_plain_any
     vm.spawn()
     vm.basic_config(
         vcpu_count=2,
@@ -249,7 +248,7 @@ def test_load_snapshot_failure_handling(uvm_plain):
     vm.mark_killed()
 
 
-def test_cmp_full_and_first_diff_mem(microvm_factory, guest_kernel, rootfs):
+def test_cmp_full_and_first_diff_mem(uvm_plain_any):
     """
     Compare memory of 2 consecutive full and diff snapshots.
 
@@ -260,7 +259,7 @@ def test_cmp_full_and_first_diff_mem(microvm_factory, guest_kernel, rootfs):
     """
     logger = logging.getLogger("snapshot_sequence")
 
-    vm = microvm_factory.build(guest_kernel, rootfs)
+    vm = uvm_plain_any
     vm.spawn()
     vm.basic_config(
         vcpu_count=2,
@@ -430,12 +429,12 @@ def test_create_large_diff_snapshot(uvm_plain):
     # process would have been taken down.
 
 
-def test_diff_snapshot_overlay(guest_kernel, rootfs, microvm_factory):
+def test_diff_snapshot_overlay(uvm_plain_any, microvm_factory):
     """
     Tests that if we take a diff snapshot and direct firecracker to write it on
     top of an existing snapshot file, it will successfully merge them.
     """
-    basevm = microvm_factory.build(guest_kernel, rootfs)
+    basevm = uvm_plain_any
     basevm.spawn()
     basevm.basic_config(track_dirty_pages=True)
     basevm.add_net_iface()
@@ -467,15 +466,15 @@ def test_diff_snapshot_overlay(guest_kernel, rootfs, microvm_factory):
     # Check that the restored VM works
 
 
-def test_snapshot_overwrite_self(guest_kernel, rootfs, microvm_factory):
+def test_snapshot_overwrite_self(uvm_plain_any, microvm_factory):
     """Tests that if we try to take a snapshot that would overwrite the
     very file from which the current VM is stored, nothing happens.
 
     Note that even though we map the file as MAP_PRIVATE, the documentation
     of mmap does not specify what should happen if the file is changed after being
     mmap'd (https://man7.org/linux/man-pages/man2/mmap.2.html). It seems that
     these changes can propagate to the mmap'd memory region."""
-    base_vm = microvm_factory.build(guest_kernel, rootfs)
+    base_vm = uvm_plain_any
     base_vm.spawn()
     base_vm.basic_config()
     base_vm.add_net_iface()
@@ -499,11 +498,13 @@ def test_snapshot_overwrite_self(guest_kernel, rootfs, microvm_factory):
     # restored, with a new snapshot of this vm, does not break the VM
 
 
-def test_vmgenid(guest_kernel_linux_6_1, rootfs, microvm_factory, snapshot_type):
+def test_vmgenid(
+    guest_kernel_linux_6_1, rootfs, microvm_factory, pci_enabled, snapshot_type
+):
     """
     Test VMGenID device upon snapshot resume
     """
-    base_vm = microvm_factory.build(guest_kernel_linux_6_1, rootfs)
+    base_vm = microvm_factory.build(guest_kernel_linux_6_1, rootfs, pci=pci_enabled)
     base_vm.spawn()
     base_vm.basic_config(track_dirty_pages=True)
     base_vm.add_net_iface()