qemu_guest_agent: Add new api support 'guest-get-load'

Add a new guest agent command 'guest-get-load' to
get cpu load average info of Guest.

Signed-off-by: Dehan Meng <[email protected]>

Author: 6-dehan

qemu/tests/cfg/qemu_guest_agent.cfg

@@ -655,6 +655,14 @@
             remove_image_image1 = yes
             cmd_run_debugview = 'start WIN_UTILS:\Debugviewconsole.exe -d C:\debug.dbglog'
             cmd_check_string_VSS = 'type C:\debug.dbglog | findstr /i "QEMU Guest Agent VSS Provider\[[0-9]*\]"'
+        - check_get_load:
+            gagent_check_type = get_load
+            cmd_get_load = "cat /proc/loadavg |awk '{print $1,$2,$3}'"
+            cmd_install_stressng = "dnf -y install stress-ng"
+            cmd_run_stressng = "stress-ng --cpu 8 --cpu-load 80 --timeout 30 --quiet &"
+            Windows:
+                cmd_get_load = "wmic cpu get loadpercentage | findstr /v LoadPercentage"
+                cmd_get_load_2 = "wmic cpu get loadpercentage | findstr /i LoadPercentage"
     variants:
         - virtio_serial:
             gagent_serial_type = virtio

qemu/tests/qemu_guest_agent.py

@@ -1850,6 +1850,130 @@ def ip_addr_check(session, mac_addr, ret_list, if_index, if_name):
         if session_serial:
             session_serial.close()
 
+    @error_context.context_aware
+    def gagent_check_get_load(self, test, params, env):
+        """
+        Test guest-get-load command functionality.
+
+        Steps:
+        1) Get initial load values and verify qga/guest match
+        2) Start stress test and verify load increases
+        3) Stop stress test and verify load decreases
+
+        :param test: kvm test object
+        :param params: Dictionary with test parameters
+        :param env: Dictionary with test environment
+        """
+
+        def _get_load_stats(session, get_guest=True):
+            """
+            Get load statistics from either guest OS or QGA.
+            Returns tuple of (1min, 5min, 15min) load values.
+            """
+            if get_guest:
+                try:
+                    loads = session.cmd_output(params["cmd_get_load"]).strip().split()
+                    return tuple(round(float(x), 2) for x in loads[:3])
+                except (IndexError, ValueError) as e:
+                    test.error(f"Failed to get guest load stats: {e}")
+            else:
+                try:
+                    loads = self.gagent.get_load()
+                    load_keys = ("load1m", "load5m", "load15m")
+                    return tuple(round(float(loads[k]), 2) for k in load_keys)
+                except (KeyError, ValueError) as e:
+                    test.error(f"Failed to get QGA load stats: {e}")
+
+        def _verify_load_values(qga_vals, guest_vals, check_type="match"):
+            """
+            Compare load values between QGA and guest OS.
+            Also verifies if values changed as expected.
+            """
+            errors = []
+            periods = ["1-minute", "5-minute", "15-minute"]
+
+            for period, qga, guest in zip(periods, qga_vals, guest_vals):
+                if abs(qga - guest) > 0.5:
+                    errors.append(
+                        f"{period} load mismatch: guest={guest:.2f}, qga={qga:.2f}"
+                    )
+
+            # Only check load1m for increase/decrease
+            if check_type != "match" and prev_values:
+                qga_1m = qga_vals[0]
+                guest_1m = guest_vals[0]
+                prev_qga_1m = prev_values["qga"][0]
+                prev_guest_1m = prev_values["guest"][0]
+
+                if check_type == "increase":
+                    if qga_1m <= prev_qga_1m or guest_1m <= prev_guest_1m:
+                        errors.append(
+                            "1-minute load did not increase as expected:\n"
+                            f"QGA: {prev_qga_1m:.2f} -> {qga_1m:.2f}\n"
+                            f"Guest: {prev_guest_1m:.2f} -> {guest_1m:.2f}"
+                        )
+                elif check_type == "decrease":
+                    if qga_1m >= prev_qga_1m or guest_1m >= prev_guest_1m:
+                        errors.append(
+                            "1-minute load did not decrease as expected:\n"
+                            f"QGA: {prev_qga_1m:.2f} -> {qga_1m:.2f}\n"
+                            f"Guest: {prev_guest_1m:.2f} -> {guest_1m:.2f}"
+                        )
+
+            return errors
+
+        def _log_load_values(guest_vals, qga_vals, phase):
+            """Log load values in a consistent format"""
+            LOG_JOB.info(
+                "%s load averages:\nGuest OS: %s\nQGA: %s",
+                phase,
+                [f"{x:.2f}" for x in guest_vals],
+                [f"{x:.2f}" for x in qga_vals],
+            )
+
+        session = self._get_session(params, self.vm)
+        self._open_session_list.append(session)
+        prev_values = None
+
+        # Initial load check
+        error_context.context("Check initial load average info", LOG_JOB.info)
+        guest_vals = _get_load_stats(session)
+        qga_vals = _get_load_stats(session, False)
+        prev_values = {"guest": guest_vals, "qga": qga_vals}
+
+        _log_load_values(guest_vals, qga_vals, "Initial")
+
+        if errors := _verify_load_values(qga_vals, guest_vals):
+            test.fail("Initial load check failed:\n" + "\n".join(errors))
+
+        # Stress test
+        error_context.context("Starting CPU stress test", LOG_JOB.info)
+        s, o = session.cmd_status_output(params["cmd_install_stressng"])
+        if s != 0:
+            test.error(f"Failed to install stress-ng: {o}")
+        session.cmd(params["cmd_run_stressng"])
+        time.sleep(25)
+
+        guest_vals = _get_load_stats(session)
+        qga_vals = _get_load_stats(session, False)
+
+        _log_load_values(guest_vals, qga_vals, "Under stress")
+
+        if errors := _verify_load_values(qga_vals, guest_vals, "increase"):
+            test.fail("Stress test load check failed:\n" + "\n".join(errors))
+
+        prev_values = {"guest": guest_vals, "qga": qga_vals}
+
+        # sleep (60) wait for the stress-ng terminated.
+        time.sleep(60)
+        guest_vals = _get_load_stats(session)
+        qga_vals = _get_load_stats(session, False)
+
+        _log_load_values(guest_vals, qga_vals, "After stress")
+
+        if errors := _verify_load_values(qga_vals, guest_vals, "decrease"):
+            test.fail("Post-stress load check failed:\n" + "\n".join(errors))
+
     @error_context.context_aware
     def gagent_check_reboot_shutdown(self, test, params, env):
         """