Patch to get the location code of any pci device

virttest/libvirt_vm.py

@@ -31,6 +31,7 @@
     test_setup,
     utils_logfile,
     utils_misc,
+    utils_net,
     utils_package,
     utils_selinux,
     virsh,
@@ -379,6 +380,15 @@ def backup_xml(self, active=False):
             LOG.error("Failed to backup xml file:\n%s", detail)
             return ""
 
+    def _get_address(self, index=0, ip_version="ipv4", session=None, timeout=60.0):
+        try:
+            return super()._get_address(index, ip_version, session, timeout)
+        except virt_vm.VMIPAddressMissingError:
+            mac = self.get_mac_address(index).lower()
+            ipaddr = utils_net.obtain_guest_ip_from_dhcp_leases(mac)
+            self.address_cache[mac] = ipaddr
+            return ipaddr
+
     def clone(
         self,
         name=None,
@@ -987,6 +997,8 @@ def add_kernel(
                     result += "initrd=%s," % initrd_path
                 if has_sub_option("boot", "kernel_args") and kernel_args:
                     result += 'kernel_args="%s",' % kernel_args
+                elif has_sub_option("boot", "cmdline") and kernel_args:
+                    result += 'cmdline="%s",' % kernel_args
             else:
                 result = ""
                 LOG.warning("boot option is not supported")
@@ -1450,6 +1462,8 @@ def add_tpmdevice(help_text, device_path, model=None, type=None):
         kernel = params.get("kernel", None)
         initrd = params.get("initrd", None)
         kernel_args = params.get("kernel_args", None)
+        if not kernel_args:
+            kernel_args = params.get("cmdline", None)
         if (kernel or initrd) and kernel_args:
             virt_install_cmd += add_kernel(
                 help_text, virt_install_cmd, kernel, initrd, kernel_args

virttest/test-providers.d/io-github-autotest-libvirt.ini

@@ -1,5 +1,6 @@
 [provider]
-uri: https://github.com/autotest/tp-libvirt.git
+uri: https://github.com/lop-devops/tp-libvirt.git
+branch: KVMCI
 [libvirt]
 subdir: libvirt/
 [libguestfs]

virttest/utils_misc.py

@@ -4599,3 +4599,28 @@ def _md5(fd):
         if _md5(fd_a) == _md5(fd_b):
             return True
     return False
+
+
+def get_location_code(pci_id):
+    """
+    Retrieves the location code for a PCI device using the `cat` command.
+    :param device : The PCI device address in the format 'xxxx:xx:xx.x'.
+    :return: location code if available, or an error message.
+    """
+    try:
+        # Construct the path
+        pci_id = pci_id.replace(":", "\\:")
+        loc_code_path = "/sys/bus/pci/devices/%s/of_node/ibm,loc-code" % pci_id
+
+        # Execute the cat command and capture the output
+        loc_code = process.run("cat %s" % loc_code_path, shell=True)
+        loc_code = "".join(
+            c for c in loc_code.stdout_text.strip() if 0x20 <= ord(c) <= 0x7E
+        )
+        logging.debug("The location code of the pci device is %s" % loc_code)
+        return loc_code
+
+    except FileNotFoundError:
+        return "Location code file not found for device %s." % pci_id
+    except Exception as e:
+        return "An error occurred: %s" % e

virttest/utils_net.py

@@ -35,6 +35,7 @@
     utils_misc,
     utils_package,
     utils_selinux,
+    virsh,
 )
 from virttest.remote import RemoteRunner
 from virttest.staging import service, utils_memory
@@ -4902,3 +4903,20 @@ def check_class_rules(ifname, rule_id, bandwidth, expect_none=False):
         stacktrace.log_exc_info(sys.exc_info())
         return False
     return True
+
+def obtain_guest_ip_from_dhcp_leases(mac):
+    """
+    Obtaining the guest ip address from virsh-net-dhcp-leases command
+    :param: Mac address of the guest
+    :return: return ip-address if found for given mac in the
+             virsh-net-dhcp-leases default table, else return None
+    """
+    output = virsh.net_dhcp_leases("default")
+    lines = output.stdout.splitlines()
+    for line in lines:
+        if mac in line:
+            parts = line.split()
+            for part in parts:
+                if "/" in part:
+                    return part.split("/")[0]
+    return None

virttest/utils_stress.py

@@ -16,7 +16,7 @@
 
 
 class VMStressEvents:
-    def __init__(self, params, env):
+    def __init__(self, params, env, vms=None):
         """
         :param params: test param
         """
@@ -28,7 +28,10 @@ def __init__(self, params, env):
         self.event_sleep_time = int(params.get("event_sleep_time", 10))
         self.itr_sleep_time = int(params.get("itr_sleep_time", 10))
         self.ignore_status = params.get("ignore_status", "no") == "yes"
-        self.vms = env.get_all_vms()
+        if vms is None:
+            self.vms = env.get_all_vms()
+        else:
+            self.vms = vms
         self.params = params
         self.host_events = params.get("host_stress_events", "")
         if self.host_events:

virttest/utils_test/__init__.py

@@ -371,10 +371,10 @@ def get_time(session, time_command, time_filter_re, time_format):
                 msg += "'%s', output: %s" % (time_command, output)
                 raise exceptions.TestError(msg)
             if re.search("PM|AM", guest_time):
-                hour = re.findall("\d+ (\d+):", guest_time)[0]
+                hour = re.findall(r"\d+ (\d+):", guest_time)[0]
                 fix = 12 if re.search("PM", guest_time) else 0
                 hour = str(int(hour) % 12 + fix)
-                guest_time = re.sub("\s\d+:", " %s:" % hour, guest_time)[:-3]
+                guest_time = re.sub(r"\s\d+:", " %s:" % hour, guest_time)[:-3]
             else:
                 guest_time = guest_time[:-3]
             guest_time = time.mktime(time.strptime(guest_time, time_format))
@@ -764,7 +764,7 @@ def transfer_data(session, host_cmd, guest_cmd, n_time, timeout, md5_check, acti
                         else:
                             LOG.warning(err)
                 else:
-                    md5_re = "md5_sum = (\w{32})"
+                    md5_re = r"md5_sum = (\w{32})"
                     try:
                         md5_guest = re.findall(md5_re, g_output)[0]
                     except Exception:
@@ -784,7 +784,7 @@ def transfer_data(session, host_cmd, guest_cmd, n_time, timeout, md5_check, acti
                             else:
                                 LOG.warning(err)
                     else:
-                        md5_re = "md5_sum = (\w{32})"
+                        md5_re = r"md5_sum = (\w{32})"
                         try:
                             md5_host = re.findall(md5_re, output)[0]
                         except Exception:
@@ -1395,10 +1395,10 @@ def extract(vm, remote_path, dest_dir):
     def get_last_guest_results_index():
         res_index = 0
         for subpath in os.listdir(outputdir):
-            if re.search("guest_autotest_results\d+", subpath):
+            if re.search(r"guest_autotest_results\d+", subpath):
                 res_index = max(
                     res_index,
-                    int(re.search("guest_autotest_results(\d+)", subpath).group(1)),
+                    int(re.search(r"guest_autotest_results(\d+)", subpath).group(1)),
                 )
         return res_index
 
@@ -1954,7 +1954,7 @@ def summary_up_result(result_file, ignore, row_head, column_mark):
             if len(re.findall(column_mark, eachLine)) != 0 and not head_flag:
                 column = 0
                 _, row, eachLine = re.split(row_head, eachLine)
-                for i in re.split("\s+", eachLine):
+                for i in re.split(r"\s+", eachLine):
                     if i:
                         result_dict[i] = {}
                         column_list[column] = i
@@ -1971,7 +1971,7 @@ def summary_up_result(result_file, ignore, row_head, column_mark):
                     row_list.append(row)
                     for i in result_dict:
                         result_dict[i][row] = []
-                for i in re.split("\s+", eachLine):
+                for i in re.split(r"\s+", eachLine):
                     if i:
                         result_dict[column_list[column]][row].append(i)
                         column += 1
@@ -2218,6 +2218,7 @@ def __init__(
         self.stress_wait_for_timeout = int(
             self.params.get("stress_wait_for_timeout", 60)
         )
+        stress_type = stress_type.split('_')[0]
         self.stress_type = stress_type
         stress_cmds = stress_cmds or stress_type
         self.stress_cmds = self.params.get("stress_cmds_%s" % stress_type, stress_cmds)
@@ -2292,6 +2293,45 @@ def load_stress_tool(self):
         ):
             raise exceptions.TestError("Stress app does not " "running as expected")
 
+    @session_handler
+    def load_htxstress_tool(self):
+        """
+        load stress tool in guest
+        """
+        # install htx strss tool
+        remove_old_package = "cd " + self.dst_path + " && rm -rf " + self.base_name
+        get_stress = "cd " + self.dst_path + " && wget " + self.download_url
+        if "rpm" in self.base_name:
+            install_stress = "cd " + self.dst_path + " && rpm -i " + self.base_name
+        elif "deb" in self.base_name:
+            install_stress = "cd " + self.dst_path + " && dpkg -i " + self.base_name
+        else:
+            raise exceptions.TestError("Could not install htx stress tool")
+        LOG.info("Installing htx rpm/deb in the guest")
+        self.cmd(remove_old_package)
+        self.cmd(get_stress)
+        self.cmd(install_stress)
+
+        # start htx stress
+        launch_cmds = "nohup %s %s > /dev/null &" % (self.stress_cmds, self.stress_args)
+        LOG.info("Launch stress with command: %s", launch_cmds)
+        try:
+            self.cmd_launch(launch_cmds)
+            # The background process sometimes does not return to
+            # terminate, if timeout, send a blank line afterward
+        except aexpect.ShellTimeoutError:
+            self.cmd_launch("")
+
+        # wait for stress to start and then check, if not raise TestError
+        if not utils_misc.wait_for(
+            self.app_running,
+            self.stress_wait_for_timeout,
+            first=2.0,
+            text="wait for stress app to start",
+            step=1.0,
+        ):
+            raise exceptions.TestError("Stress app does not " "running as expected")
+
     @session_handler
     def unload_stress(self):
         """
@@ -2672,25 +2712,50 @@ def load_stress(
     :param download_type: currently support "git" or "file" download
     """
     fail_info = []
-    # Add stress/iozone tool in vms
-    if stress_type in ["stress_in_vms", "iozone_in_vms"]:
+    default_stress_type = stress_type
+    if stress_type in ["stress_in_vms", "iozone_in_vms", "htxcmdline_in_vms"]:
         for vm in vms:
-            try:
-                vstress = VMStress(
-                    vm,
-                    stress_type.split("_")[0],
-                    params,
-                    download_url,
-                    make_cmds,
-                    stress_cmds,
-                    stress_args,
-                    work_path,
-                    uninstall_cmds,
-                    download_type=download_type,
-                )
-                vstress.load_stress_tool()
-            except StressError as detail:
-                fail_info.append("Launch stress in %s failed: %s" % (vm.name, detail))
+            stress_type = params.get("stress_type_%s" % vm.name, default_stress_type)
+            if stress_type == "htxcmdline_in_vms":
+                # Add htx stress tool in vms
+                try:
+                    vstress = VMStress(
+                        vm,
+                        stress_type.split("_")[0],
+                        params,
+                        download_url,
+                        make_cmds,
+                        stress_cmds,
+                        stress_args,
+                        work_path,
+                        uninstall_cmds,
+                        download_type=download_type,
+                    )
+                    vstress.load_htxstress_tool()
+                except StressError as detail:
+                    fail_info.append(
+                        "Launch htxstress in %s failed: %s" % (vm.name, detail)
+                    )
+            else:
+                # Add stress/iozone tool in vms
+                try:
+                    vstress = VMStress(
+                        vm,
+                        stress_type.split("_")[0],
+                        params,
+                        download_url,
+                        make_cmds,
+                        stress_cmds,
+                        stress_args,
+                        work_path,
+                        uninstall_cmds,
+                        download_type=download_type,
+                    )
+                    vstress.load_stress_tool()
+                except StressError as detail:
+                    fail_info.append(
+                        "Launch stress in %s failed: %s" % (vm.name, detail)
+                    )
     # Add stress for host
     elif stress_type == "stress_on_host" or stress_type == "stress_on_remote_host":
         try: