LIBVIRTAT-20967: Add multiple VFIO interfaces in vIOMMU test

libvirt/tests/cfg/sriov/vIOMMU/iommu_device_settings.cfg

@@ -26,7 +26,7 @@
             only q35
             iface_model = 'rtl8139'
             iface_dict = {'type_name': 'network', 'model': '${iface_model}', 'source': {'network': 'default'}}
-        - virtio_muti_devices:
+        - virtio_multi_devices:
             disk_dict = {'target': {'dev': 'vda', 'bus': 'virtio'}, 'device': 'disk', 'driver': ${disk_driver}}
             video_dict = {'primary': 'yes', 'model_heads': '1', 'model_type': 'virtio', 'driver': {'iommu': 'on'}}
             test_devices = ["Eth", "block", "gpu"]
@@ -83,3 +83,33 @@
                     downstream_port = {'type': 'pci', 'model': 'pcie-switch-downstream-port', 'pre_controller': 'pcie-switch-upstream-port'}
                     root_port = {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-expander-bus'}
                     controller_dicts = [{'type': 'pci', 'model': 'pcie-expander-bus', 'target': {'busNr': '250'}, 'pre_controller': 'pcie-root'}, ${root_port}, ${upstream_port}, ${upstream_port}, ${downstream_port}, ${downstream_port}]
+        - multiple_vfio_pcie_root_port:
+            only virtio
+            need_sriov = yes
+            ping_dest = ''
+            test_devices = ["Eth"]
+            # Multiple VFIO interfaces under pcie-root-port
+            # pcie-root <-- pcie-root-port <--- disk with iommu=on
+            #              <-- pcie-root-port <- vfio interface
+            #              <-- pcie-root-port <- vfio interface
+            controller_dicts = [{'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-root'}, {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-root'}, {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-root'}]
+            disk_dict = {'target': {'dev': 'vda', 'bus': 'virtio'}, 'device': 'disk', 'driver': ${disk_driver}}
+            iface_dict = [{'managed': 'yes', 'type_name': 'hostdev', 'hostdev_address': {'type_name': 'pci', 'attrs': vf_pci_addr}}, {'managed': 'yes', 'type_name': 'hostdev', 'hostdev_address': {'type_name': 'pci', 'attrs': vf_pci_addr2}}]
+        - multiple_vfio_pcie_expander_bus:
+            only virtio
+            need_sriov = yes
+            ping_dest = ''
+            test_devices = ["Eth"]
+            # Multiple VFIO interfaces with pcie-expander-bus
+            # pcie-root <--- pcie-expander-bus <-- pcie-root-port <--- virtio interface with iommu=on
+            #                I                 |<----------------- pcie-root-port <--- vfio interface
+            #                |                  |<------------------pcie-root-port <--- vfio interface
+            #                | <----------pcie-root-port < ---virtio disk with iommu=on
+            expander_bus = {'type': 'pci', 'model': 'pcie-expander-bus', 'target': {'busNr': '251'}, 'pre_controller': 'pcie-root'}
+            root_port1 = {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-expander-bus'}
+            root_port2 = {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-expander-bus'}
+            root_port3 = {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': 'pcie-expander-bus'}
+            controller_dicts = [${expander_bus}, ${root_port1}, ${root_port2}, ${root_port3}]
+            disk_dict = {'target': {'dev': 'vda', 'bus': 'virtio'}, 'device': 'disk', 'driver': ${disk_driver}}
+            # Mixed interfaces: one virtio network with iommu=on and two VFIO interfaces
+            iface_dict = [{'type_name': 'network', 'model': 'virtio', 'driver': {'driver_attr': {'iommu': 'on'}}, 'source': {'network': 'default'}}, {'managed': 'yes', 'type_name': 'hostdev', 'hostdev_address': {'type_name': 'pci', 'attrs': vf_pci_addr}}, {'managed': 'yes', 'type_name': 'hostdev', 'hostdev_address': {'type_name': 'pci', 'attrs': vf_pci_addr2}}]

libvirt/tests/src/sriov/vIOMMU/iommu_device_settings.py

@@ -3,6 +3,7 @@
 
 from virttest.libvirt_xml import vm_xml
 from virttest.utils_libvirt import libvirt_vmxml
+from virttest.utils_test import libvirt
 
 from provider.sriov import sriov_base
 from provider.viommu import viommu_base
@@ -39,6 +40,7 @@ def run(test, params, env):
         vm_session = vm.wait_for_serial_login(
             timeout=int(params.get('login_timeout')))
         pre_devices = viommu_base.get_devices_pci(vm_session, test_devices)
+        vm_session.close()
         vm.destroy()
 
         for dev in ["disk", "video"]:
@@ -58,12 +60,24 @@ def run(test, params, env):
         iface_dict = test_obj.parse_iface_dict()
 
         if cleanup_ifaces:
-            libvirt_vmxml.modify_vm_device(
-                    vm_xml.VMXML.new_from_dumpxml(vm.name),
-                    "interface", iface_dict)
+            # Handle both single dict and list of dicts
+            if isinstance(iface_dict, list):
+                libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
+                for single_iface_dict in iface_dict:
+                    dev_obj = libvirt_vmxml.create_vm_device_by_type("interface", single_iface_dict)
+                    test.log.debug(f"XML of interface device is:\n{dev_obj}")
+                    libvirt.add_vm_device(
+                            vm_xml.VMXML.new_from_dumpxml(vm.name),
+                            dev_obj)
+            else:
+                libvirt_vmxml.modify_vm_device(
+                        vm_xml.VMXML.new_from_dumpxml(vm.name),
+                        "interface", iface_dict)
 
         test.log.info("TEST_STEP: Start the VM.")
         vm.start()
+        vm.cleanup_serial_console()
+        vm.create_serial_console()
         vm_session = vm.wait_for_serial_login(
             timeout=int(params.get('login_timeout')))
         test.log.debug(vm_xml.VMXML.new_from_dumpxml(vm.name))
@@ -87,4 +101,8 @@ def run(test, params, env):
             if s:
                 test.fail("Failed to ping %s! status: %s, output: %s." % (ping_dest, s, o))
     finally:
+        if 'vm_session' in locals():
+            test.log.debug("Closing vm_session")
+            vm_session.close()
+        vm.cleanup_serial_console()
         test_obj.teardown_iommu_test()

provider/viommu/viommu_base.py

@@ -108,17 +108,35 @@ def __init__(self, vm, test, params, session=None):
         libvirt_version.is_libvirt_feature_supported(self.params)
         new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(self.vm.name)
         self.orig_config_xml = new_xml.copy()
+        self.test.log.debug("Original VM configuration backed up for restore")
 
     def parse_iface_dict(self):
         """
-        Parse iface_dict from params
+        Parse iface_dict from params, supporting both single dict and list of dicts
 
-        :return: The updated iface_dict
+        :return: The updated iface_dict or list of iface_dicts based on type of input
         """
+        # generate mac address, if it is needed in iface_dict
         mac_addr = utils_net.generate_mac_address_simple()
         iface_dict = eval(self.params.get("iface_dict", "{}"))
 
-        if self.controller_dicts and iface_dict:
+        if isinstance(iface_dict, list):
+            result = []
+            for single_iface_dict in iface_dict:
+                self._update_iface_dict_with_controller_info(single_iface_dict)
+                result.append(single_iface_dict)
+            return result
+        else:
+            self._update_iface_dict_with_controller_info(iface_dict)
+            return iface_dict
+
+    def _update_iface_dict_with_controller_info(self, iface_dict):
+        """
+        Update interface dictionary with controller addressing information
+
+        :param iface_dict: Interface dictionary to update with controller info
+        """
+        if self.controller_dicts and iface_dict and iface_dict.get('type_name') != 'hostdev':
             iface_bus = "%0#4x" % int(self.controller_dicts[-1].get("index"))
             iface_attrs = {"bus": iface_bus}
             if self.controller_dicts[-1].get("model") == "pcie-to-pci-bridge":
@@ -129,7 +147,6 @@ def parse_iface_dict(self):
 
             iface_dict.update({"address": {"attrs": iface_attrs}})
         self.test.log.debug("iface_dict: %s.", iface_dict)
-        return iface_dict
 
     def prepare_controller(self):
         """
@@ -143,17 +160,11 @@ def prepare_controller(self):
             contr_dict = self.controller_dicts[i]
             pre_controller = contr_dict.get("pre_controller")
             if pre_controller:
-                pre_contrs = list(
-                    filter(None, [c.get("index") for c in self.controller_dicts
-                                  if c["type"] == contr_dict["type"] and
-                                  c["model"] == pre_controller]))
-                if pre_contrs:
-                    pre_idx = pre_contrs[0]
-                else:
-                    pre_idx = libvirt_pcicontr.get_max_contr_indexes(
-                        vm_xml.VMXML.new_from_dumpxml(self.vm.name),
-                        contr_dict["type"], pre_controller)[-1]
+                self.test.log.debug(f"Processing controller {i}: {contr_dict}")
+                self.test.log.debug(f"Looking for pre_controller: {pre_controller}")
+                pre_idx = self._find_pre_controller_index(pre_controller, contr_dict)
                 pre_contr_bus = "%0#4x" % int(pre_idx)
+                self.test.log.debug(f"Parent controller index: {pre_idx}, bus: {pre_contr_bus}")
                 contr_attrs = {"bus": pre_contr_bus}
                 contr_slot = libvirt_pcicontr.get_free_pci_slot(
                         vm_xml.VMXML.new_from_dumpxml(self.vm.name),
@@ -178,12 +189,24 @@ def prepare_controller(self):
 
                 contr_dict.update({"address": {"attrs": contr_attrs}})
                 contr_dict.pop("pre_controller")
+            self.test.log.debug(f"Final controller config: {contr_dict}")
             libvirt_vmxml.modify_vm_device(
                 vm_xml.VMXML.new_from_dumpxml(self.vm.name), "controller",
                 contr_dict, 100)
-            contr_dict["index"] = libvirt_pcicontr.get_max_contr_indexes(
-                vm_xml.VMXML.new_from_dumpxml(self.vm.name),
-                contr_dict["type"], contr_dict["model"])[-1]
+            # Only assign index if it wasn't already assigned
+            if "index" not in contr_dict:
+                # Check if target busNr is specified and use it as index
+                if contr_dict.get("target", {}).get("busNr"):
+                    target_bus = int(contr_dict["target"]["busNr"])
+                    contr_dict["index"] = target_bus
+                    self.test.log.debug(f"Using target busNr {target_bus} as index for controller {i}: {contr_dict['model']}")
+                else:
+                    contr_dict["index"] = libvirt_pcicontr.get_max_contr_indexes(
+                        vm_xml.VMXML.new_from_dumpxml(self.vm.name),
+                        contr_dict["type"], contr_dict["model"])[-1]
+                    self.test.log.debug(f"Assigned index {contr_dict['index']} to controller {i}: {contr_dict['model']}")
+            else:
+                self.test.log.debug(f"Index already assigned {contr_dict['index']} for controller {i}: {contr_dict['model']}")
             self.controller_dicts[i] = contr_dict
 
         self.test.log.debug(f"Prepared controllers according to {self.controller_dicts}")
@@ -243,3 +266,97 @@ def teardown_iommu_test(self, **dargs):
         if self.vm.is_alive():
             self.vm.destroy(gracefully=False)
         self.orig_config_xml.sync()
+        self.test.log.debug("VM configuration restored to original state")
+
+    def _find_pre_controller_index(self, pre_controller, contr_dict):
+        """
+        Find the index of the pre_controller using flexible lookup methods.
+
+        :param pre_controller: The pre_controller value to look up
+        :param contr_dict: The current controller dictionary
+        :return: The index of the pre_controller
+        """
+        self.test.log.debug(f"Finding pre_controller: {pre_controller}")
+
+        result = None
+        # Try various dictionary format first (most explicit)
+        if isinstance(pre_controller, dict):
+            result = self._find_by_dict_format(pre_controller)
+
+        # Try direct index (numeric string)
+        if result is None and isinstance(pre_controller, str) and pre_controller.isdigit():
+            result = self._find_by_direct_index(pre_controller)
+
+        # Try model name (backward compatibility)
+        if result is None and isinstance(pre_controller, str):
+            result = self._find_by_model_name(pre_controller, contr_dict)
+
+        # Fallback to existing VM controllers
+        if result is None:
+            self.test.log.debug(f"Fallback: Looking for existing controller with model {pre_controller}")
+            result = libvirt_pcicontr.get_max_contr_indexes(
+                vm_xml.VMXML.new_from_dumpxml(self.vm.name),
+                contr_dict["type"], pre_controller)[-1]
+            self.test.log.debug(f"Using fallback index: {result}")
+
+        return result
+
+    def _controller_exists_by_index(self, index):
+        """Check if a controller with the given index exists in controller_dicts"""
+        for c in self.controller_dicts:
+            if c.get("index") == index:
+                return True
+        return False
+
+    def _find_by_dict_format(self, pre_controller):
+        """
+            Find controller by dictionary format: {'alias': 'name'} or {'index': N}
+            example: {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': {'index': 100,'alias': 'pci.100'}}
+        """
+        if 'index' in pre_controller:
+            pre_idx = int(pre_controller['index'])
+            # Validate that controller exists in our controller_dicts
+            if self._controller_exists_by_index(pre_idx):
+                self.test.log.debug(f"Using explicit index from dict: {pre_idx}")
+                return pre_idx
+        elif 'alias' in pre_controller:
+            alias_name = pre_controller['alias']
+            return self._find_by_alias_name(alias_name)
+        self.test.log.warning(f"Invalid pre_controller dict format: {pre_controller}, or controller not found in controller_dicts. Use {{'index': N}} or {{'alias': 'name'}}, will fall back to other methods")
+        return None
+
+    def _find_by_direct_index(self, pre_controller):
+        """
+            Find controller by direct index (numeric string) direct index passed in configuration
+            example: {'type': 'pci', 'model': 'pcie-root-port', 'pre_controller': '100'}
+        """
+        pre_idx = int(pre_controller)
+        # Validate that controller exists in our controller_dicts
+        if self._controller_exists_by_index(pre_idx):
+            self.test.log.debug(f"Using direct index: {pre_idx}")
+            return pre_idx
+        else:
+            self.test.log.warning(f"Controller with index {pre_idx} not found in controller_dicts, will fall back to other methods")
+        return None
+
+    def _find_by_alias_name(self, alias_name):
+        """Find controller by alias name passed in configuration """
+        for c in self.controller_dicts:
+            if c.get("alias", {}).get("name") == alias_name:
+                pre_idx = int(c.get("index"))
+                self.test.log.debug(f"Found controller by alias {alias_name}: index {pre_idx}")
+                return pre_idx
+        self.test.log.warning(f"Controller with alias '{alias_name}' not found in controller_dicts, will fall back to other methods")
+        return None
+
+    def _find_by_model_name(self, pre_controller, contr_dict):
+        """Find controller by model name (backward compatibility)"""
+        pre_contrs = list(
+            filter(None, [c.get("index") for c in self.controller_dicts
+                          if c["type"] == contr_dict["type"] and
+                          c["model"] == pre_controller]))
+        if pre_contrs:
+            pre_idx = pre_contrs[0]
+            self.test.log.debug(f"Found controller by model {pre_controller}: index {pre_idx}")
+            return pre_idx
+        return None