test(pci): parametrize uvm_plain* with pci

All tests using uvm_plain or uvm_plain_any will start using PCI as well,
allowing more coverage for the PCI code.
This requires moving the PCI configuration to the VM factory from the
spawn method.

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

Author: Manciukic

tests/conftest.py

@@ -507,9 +507,9 @@ def rootfs_rw():
 
 
 @pytest.fixture
-def uvm_plain(microvm_factory, guest_kernel_linux_5_10, rootfs):
+def uvm_plain(microvm_factory, guest_kernel_linux_5_10, rootfs, pci_enabled):
     """Create a vanilla VM, non-parametrized"""
-    return microvm_factory.build(guest_kernel_linux_5_10, rootfs)
+    return microvm_factory.build(guest_kernel_linux_5_10, rootfs, pci=pci_enabled)
 
 
 @pytest.fixture
@@ -535,12 +535,12 @@ def artifact_dir():
 
 
 @pytest.fixture
-def uvm_plain_any(microvm_factory, guest_kernel, rootfs):
+def uvm_plain_any(microvm_factory, guest_kernel, rootfs, pci_enabled):
     """All guest kernels
     kernel: all
     rootfs: Ubuntu 24.04
     """
-    return microvm_factory.build(guest_kernel, rootfs)
+    return microvm_factory.build(guest_kernel, rootfs, pci=pci_enabled)
 
 
 guest_kernel_6_1_debug = pytest.fixture(
@@ -583,8 +583,8 @@ def uvm_booted(
     mem_size_mib=256,
 ):
     """Return a booted uvm"""
-    uvm = microvm_factory.build(guest_kernel, rootfs)
-    uvm.spawn(pci=pci_enabled)
+    uvm = microvm_factory.build(guest_kernel, rootfs, pci=pci_enabled)
+    uvm.spawn()
     uvm.basic_config(vcpu_count=vcpu_count, mem_size_mib=mem_size_mib)
     uvm.set_cpu_template(cpu_template)
     uvm.add_net_iface()

tests/framework/microvm.py

@@ -191,14 +191,14 @@ def __init__(
         jailer_kwargs: Optional[dict] = None,
         numa_node=None,
         custom_cpu_template: Path = None,
+        pci: bool = False,
     ):
         """Set up microVM attributes, paths, and data structures."""
         # pylint: disable=too-many-statements
         # Unique identifier for this machine.
         assert microvm_id is not None
         self._microvm_id = microvm_id
 
-        self.pci_enabled = False
         self.kernel_file = None
         self.rootfs_file = None
         self.ssh_key = None
@@ -222,6 +222,10 @@ def __init__(
             **jailer_kwargs,
         )
 
+        self.pci_enabled = pci
+        if pci:
+            self.jailer.extra_args["enable-pci"] = None
+
         # Copy the /etc/localtime file in the jailer root
         self.jailer.jailed_path("/etc/localtime", subdir="etc")
 
@@ -612,7 +616,6 @@ def spawn(
         log_show_origin=False,
         metrics_path="fc.ndjson",
         emit_metrics: bool = False,
-        pci: bool = False,
     ):
         """Start a microVM as a daemon or in a screen session."""
         # pylint: disable=subprocess-run-check
@@ -658,10 +661,6 @@ def spawn(
             # Checking the timings requires DEBUG level log messages
             self.time_api_requests = False
 
-        if pci:
-            self.pci_enabled = True
-            self.jailer.extra_args["enable-pci"] = None
-
         cmd = [
             *self._pre_cmd,
             str(self.jailer_binary_path),

tests/integration_tests/functional/test_max_devices.py

@@ -29,12 +29,13 @@ def max_devices(uvm):
             raise ValueError("Unknown platform")
 
 
-def test_attach_maximum_devices(microvm_factory, guest_kernel, rootfs, pci_enabled):
+def test_attach_maximum_devices(uvm_plain_any):
     """
     Test attaching maximum number of devices to the microVM.
     """
-    test_microvm = microvm_factory.build(guest_kernel, rootfs, monitor_memory=False)
-    test_microvm.spawn(pci=pci_enabled)
+    test_microvm = uvm_plain_any
+    test_microvm.memory_monitor = None
+    test_microvm.spawn()
 
     # The default 256mib is not enough for 94 ssh connections on aarch64.
     test_microvm.basic_config(mem_size_mib=512)
@@ -52,12 +53,13 @@ def test_attach_maximum_devices(microvm_factory, guest_kernel, rootfs, pci_enabl
         test_microvm.ssh_iface(i).check_output("sync")
 
 
-def test_attach_too_many_devices(microvm_factory, guest_kernel, rootfs, pci_enabled):
+def test_attach_too_many_devices(uvm_plain):
     """
     Test attaching to a microVM more devices than available IRQs.
     """
-    test_microvm = microvm_factory.build(guest_kernel, rootfs, monitor_memory=False)
-    test_microvm.spawn(pci=pci_enabled)
+    test_microvm = uvm_plain
+    test_microvm.memory_monitor = None
+    test_microvm.spawn()
 
     # Set up a basic microVM.
     test_microvm.basic_config()
@@ -73,7 +75,7 @@ def test_attach_too_many_devices(microvm_factory, guest_kernel, rootfs, pci_enab
     # `MAX_DEVICES_ATTACHED` devices should fail.
     error_str = (
         ("Could not find an available device slot on the PCI bus.")
-        if pci_enabled
+        if test_microvm.pci_enabled
         else (
             "Failed to allocate requested resource: The requested resource"
             " is not available."

tests/integration_tests/functional/test_net_config_space.py

@@ -13,16 +13,14 @@
 PAYLOAD_DATA_SIZE = 20
 
 
-def test_net_change_mac_address(
-    uvm_plain_any, pci_enabled, change_net_config_space_bin
-):
+def test_net_change_mac_address(uvm_plain_any, change_net_config_space_bin):
     """
     Test changing the MAC address of the network device.
     """
 
     test_microvm = uvm_plain_any
     test_microvm.help.enable_console()
-    test_microvm.spawn(pci=pci_enabled)
+    test_microvm.spawn()
     test_microvm.basic_config(boot_args="ipv6.disable=1")
 
     # Data exchange interface ('eth0' in guest).

tests/integration_tests/functional/test_rng.py

@@ -8,12 +8,11 @@
 from host_tools.network import SSHConnection
 
 
-def uvm_with_rng_booted(
-    microvm_factory, guest_kernel, rootfs, rate_limiter, pci_enabled
-):
+def uvm_with_rng_booted(uvm_plain_any, microvm_factory, rate_limiter):
     """Return a booted microvm with virtio-rng configured"""
-    uvm = microvm_factory.build(guest_kernel, rootfs)
-    uvm.spawn(log_level="INFO", pci=pci_enabled)
+    # pylint: disable=unused-argument
+    uvm = uvm_plain_any
+    uvm.spawn(log_level="INFO")
     uvm.basic_config(vcpu_count=2, mem_size_mib=256)
     uvm.add_net_iface()
     uvm.api.entropy.put(rate_limiter=rate_limiter)
@@ -23,13 +22,9 @@ def uvm_with_rng_booted(
     return uvm
 
 
-def uvm_with_rng_restored(
-    microvm_factory, guest_kernel, rootfs, rate_limiter, pci_enabled
-):
+def uvm_with_rng_restored(uvm_plain_any, microvm_factory, rate_limiter):
     """Return a restored uvm with virtio-rng configured"""
-    uvm = uvm_with_rng_booted(
-        microvm_factory, guest_kernel, rootfs, rate_limiter, pci_enabled
-    )
+    uvm = uvm_with_rng_booted(uvm_plain_any, microvm_factory, rate_limiter)
     snapshot = uvm.snapshot_full()
     uvm.kill()
     uvm2 = microvm_factory.build_from_snapshot(snapshot)
@@ -50,9 +45,9 @@ def rate_limiter(request):
 
 
 @pytest.fixture
-def uvm_any(microvm_factory, uvm_ctor, guest_kernel, rootfs, rate_limiter, pci_enabled):
+def uvm_any(microvm_factory, uvm_ctor, uvm_plain_any, rate_limiter):
     """Return booted and restored uvms"""
-    return uvm_ctor(microvm_factory, guest_kernel, rootfs, rate_limiter, pci_enabled)
+    return uvm_ctor(uvm_plain_any, microvm_factory, rate_limiter)
 
 
 def list_rng_available(ssh_connection: SSHConnection) -> list[str]:

tests/integration_tests/functional/test_vsock.py

@@ -37,15 +37,15 @@
 TEST_WORKER_COUNT = 10
 
 
-def test_vsock(uvm_plain_any, pci_enabled, bin_vsock_path, test_fc_session_root_path):
+def test_vsock(uvm_plain_any, bin_vsock_path, test_fc_session_root_path):
     """
     Test guest and host vsock initiated connections.
 
     Check the module docstring for details on the setup.
     """
 
     vm = uvm_plain_any
-    vm.spawn(pci=pci_enabled)
+    vm.spawn()
 
     vm.basic_config()
     vm.add_net_iface()
@@ -102,12 +102,12 @@ def negative_test_host_connections(vm, blob_path, blob_hash):
     validate_fc_metrics(metrics)
 
 
-def test_vsock_epipe(uvm_plain, pci_enabled, bin_vsock_path, test_fc_session_root_path):
+def test_vsock_epipe(uvm_plain_any, bin_vsock_path, test_fc_session_root_path):
     """
     Vsock negative test to validate SIGPIPE/EPIPE handling.
     """
-    vm = uvm_plain
-    vm.spawn(pci=pci_enabled)
+    vm = uvm_plain_any
+    vm.spawn()
     vm.basic_config()
     vm.add_net_iface()
     vm.api.vsock.put(vsock_id="vsock0", guest_cid=3, uds_path=f"/{VSOCK_UDS_PATH}")
@@ -129,7 +129,7 @@ def test_vsock_epipe(uvm_plain, pci_enabled, bin_vsock_path, test_fc_session_roo
 
 
 def test_vsock_transport_reset_h2g(
-    uvm_plain, pci_enabled, microvm_factory, bin_vsock_path, test_fc_session_root_path
+    uvm_plain_any, microvm_factory, bin_vsock_path, test_fc_session_root_path
 ):
     """
     Vsock transport reset test.
@@ -146,8 +146,8 @@ def test_vsock_transport_reset_h2g(
     6. Close VM -> Load VM from Snapshot -> check that vsock
        device is still working.
     """
-    test_vm = uvm_plain
-    test_vm.spawn(pci=pci_enabled)
+    test_vm = uvm_plain_any
+    test_vm.spawn()
     test_vm.basic_config(vcpu_count=2, mem_size_mib=256)
     test_vm.add_net_iface()
     test_vm.api.vsock.put(vsock_id="vsock0", guest_cid=3, uds_path=f"/{VSOCK_UDS_PATH}")
@@ -215,12 +215,12 @@ def test_vsock_transport_reset_h2g(
     validate_fc_metrics(metrics)
 
 
-def test_vsock_transport_reset_g2h(uvm_plain, pci_enabled, microvm_factory):
+def test_vsock_transport_reset_g2h(uvm_plain_any, microvm_factory):
     """
     Vsock transport reset test.
     """
-    test_vm = uvm_plain
-    test_vm.spawn(pci=pci_enabled)
+    test_vm = uvm_plain_any
+    test_vm.spawn()
     test_vm.basic_config(vcpu_count=2, mem_size_mib=256)
     test_vm.add_net_iface()
     test_vm.api.vsock.put(vsock_id="vsock0", guest_cid=3, uds_path=f"/{VSOCK_UDS_PATH}")

tests/integration_tests/performance/test_block.py

@@ -176,8 +176,10 @@ def test_block_performance(
     """
     Execute block device emulation benchmarking scenarios.
     """
-    vm = microvm_factory.build(guest_kernel_acpi, rootfs, monitor_memory=False)
-    vm.spawn(log_level="Info", emit_metrics=True, pci=pci_enabled)
+    vm = microvm_factory.build(
+        guest_kernel_acpi, rootfs, monitor_memory=False, pci=pci_enabled
+    )
+    vm.spawn(log_level="Info", emit_metrics=True)
     vm.basic_config(vcpu_count=vcpus, mem_size_mib=GUEST_MEM_MIB)
     vm.add_net_iface()
     # Add a secondary block device for benchmark tests.

tests/integration_tests/performance/test_boottime.py

@@ -98,9 +98,9 @@ def launch_vm_with_boot_timer(
     microvm_factory, guest_kernel_acpi, rootfs_rw, vcpu_count, mem_size_mib, pci_enabled
 ):
     """Launches a microVM with guest-timer and returns the reported metrics for it"""
-    vm = microvm_factory.build(guest_kernel_acpi, rootfs_rw)
+    vm = microvm_factory.build(guest_kernel_acpi, rootfs_rw, pci=pci_enabled)
     vm.jailer.extra_args.update({"boot-timer": None})
-    vm.spawn(pci=pci_enabled)
+    vm.spawn()
     vm.basic_config(
         vcpu_count=vcpu_count,
         mem_size_mib=mem_size_mib,

tests/integration_tests/performance/test_network.py

@@ -45,8 +45,10 @@ def network_microvm(request, microvm_factory, guest_kernel_acpi, rootfs, pci_ena
     guest_mem_mib = 1024
     guest_vcpus = request.param
 
-    vm = microvm_factory.build(guest_kernel_acpi, rootfs, monitor_memory=False)
-    vm.spawn(log_level="Info", emit_metrics=True, pci=pci_enabled)
+    vm = microvm_factory.build(
+        guest_kernel_acpi, rootfs, monitor_memory=False, pci=pci_enabled
+    )
+    vm.spawn(log_level="Info", emit_metrics=True)
     vm.basic_config(vcpu_count=guest_vcpus, mem_size_mib=guest_mem_mib)
     vm.add_net_iface()
     vm.start()

tests/integration_tests/performance/test_vsock.py

@@ -95,8 +95,10 @@ def test_vsock_throughput(
         pytest.skip("bidrectional test only done with at least 2 vcpus")
 
     mem_size_mib = 1024
-    vm = microvm_factory.build(guest_kernel_acpi, rootfs, monitor_memory=False)
-    vm.spawn(log_level="Info", emit_metrics=True, pci=pci_enabled)
+    vm = microvm_factory.build(
+        guest_kernel_acpi, rootfs, monitor_memory=False, pci=pci_enabled
+    )
+    vm.spawn(log_level="Info", emit_metrics=True)
     vm.basic_config(vcpu_count=vcpus, mem_size_mib=mem_size_mib)
     vm.add_net_iface()
     # Create a vsock device