amd-debug-tools 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

amd_debug/failures.py

@@ -142,7 +142,7 @@ class MissingDriver(S0i3Failure):
         self.description = f"{slot} driver is missing"
         self.explanation = (
             f"No driver has been bound to PCI device {slot} "
-            "Without a driver, the hardware may be able to enter a low power. "
+            "Without a driver, the hardware may be able to enter a low power "
             "state, but there may be spurious wake up events."
         )
 

amd_debug/kernel.py

@@ -19,6 +19,7 @@ def get_kernel_command_line() -> str:
         "apparmor",
         "audit",
         "auto",
+        "bluetooth.disable_ertm",
         "boot",
         "BOOT_IMAGE",
         "console",
@@ -29,6 +30,7 @@ def get_kernel_command_line() -> str:
         "earlycon",
         "earlyprintk",
         "ether",
+        "init",
         "initrd",
         "ip",
         "LANG",
@@ -47,7 +49,9 @@ def get_kernel_command_line() -> str:
         "nfs.nfs4_unique_id",
         "nfsroot",
         "noplymouth",
+        "nowatchdog",
         "ostree",
+        "preempt",
         "quiet",
         "rd.dm.uuid",
         "rd.luks.allow-discards",
@@ -66,12 +70,15 @@ def get_kernel_command_line() -> str:
         "ro",
         "root",
         "rootflags",
+        "rootfstype",
         "roothash",
         "rw",
         "security",
+        "selinux",
         "showopts",
         "splash",
         "swap",
+        "systemd.machine_id",
         "systemd.mask",
         "systemd.show_status",
         "systemd.unit",
@@ -82,6 +89,7 @@ def get_kernel_command_line() -> str:
         "verbose",
         "vt.handoff",
         "zfs",
+        "zswap.enabled",
     ]
     # remove anything that starts with something in filtered from cmdline
     return " ".join([x for x in cmdline.split() if not x.startswith(tuple(filtered))])

amd_debug/prerequisites.py

@@ -134,22 +134,19 @@ class PrerequisiteValidator(AmdTool):
         if len(edids) == 0:
             self.db.record_debug("No EDID data found")
             return True
-
         for name, p in edids.items():
             output = None
-            for cmd in ["di-edid-decode", "edid-decode"]:
+            for tool in ["di-edid-decode", "edid-decode"]:
                 try:
-                    cmd = ["edid-decode", p]
+                    cmd = [tool, p]
                     output = subprocess.check_output(
                         cmd, stderr=subprocess.DEVNULL
-                    ).decode("utf-8")
+                    ).decode("utf-8", errors="ignore")
                     break
                 except FileNotFoundError:
                     self.db.record_debug(f"{cmd} not installed")
                 except subprocess.CalledProcessError as e:
-                    self.db.record_debug(
-                        f"failed to capture edid with {cmd}: {e.output}"
-                    )
+                    pass
             if not output:
                 self.db.record_prereq("Failed to capture EDID table", "👀")
             else:
@@ -245,7 +242,6 @@ class PrerequisiteValidator(AmdTool):
         for dev in self.pyudev.list_devices(subsystem="pci", DRIVER="nvme"):
             # https://git.kernel.org/torvalds/c/e79a10652bbd3
             if minimum_kernel(6, 10):
-                self.db.record_debug("New enough kernel to avoid NVME check")
                 break
             pci_slot_name = dev.properties["PCI_SLOT_NAME"]
             vendor = dev.properties.get("ID_VENDOR_FROM_DATABASE", "")
@@ -319,7 +315,6 @@ class PrerequisiteValidator(AmdTool):
         # not needed to check in newer kernels
         # see https://github.com/torvalds/linux/commit/77f1972bdcf7513293e8bbe376b9fe837310ee9c
         if minimum_kernel(6, 10):
-            self.db.record_debug("New enough kernel to avoid HSMP check")
             return True
         f = os.path.join("/", "boot", f"config-{platform.uname().release}")
         if os.path.exists(f):
@@ -527,7 +522,7 @@ class PrerequisiteValidator(AmdTool):
                 f"{keys['sys_vendor']} {keys['product_name']} ({keys['product_family']})",
                 "💻",
             )
-            debug_str = "DMI data:\n"
+            debug_str = "DMI|value\n"
             for key, value in keys.items():
                 if (
                     "product_name" in key
@@ -535,7 +530,7 @@ class PrerequisiteValidator(AmdTool):
                     or "product_family" in key
                 ):
                     continue
-                debug_str += f"{key}: {value}\n"
+                debug_str += f"{key}| {value}\n"
             self.db.record_debug(debug_str)
         return True
 
@@ -916,7 +911,7 @@ class PrerequisiteValidator(AmdTool):
         devices = []
         for dev in self.pyudev.list_devices(subsystem="pci"):
             devices.append(dev)
-        debug_str = "PCI devices\n"
+        debug_str = "PCI Slot | Vendor | Class | ID | ACPI path\n"
         for dev in devices:
             pci_id = dev.properties["PCI_ID"].lower()
             pci_slot_name = dev.properties["PCI_SLOT_NAME"]
@@ -939,15 +934,12 @@ class PrerequisiteValidator(AmdTool):
             p = os.path.join(dev.sys_path, "firmware_node", "path")
             if os.path.exists(p):
                 acpi = read_file(p)
-                debug_str += (
-                    f"{prefix}{pci_slot_name} : "
-                    f"{database_vendor} {database_class} [{pci_id}] : {acpi}\n"
-                )
             else:
-                debug_str += (
-                    f"{prefix}{pci_slot_name} : "
-                    f"{database_vendor} {database_class} [{pci_id}]\n"
-                )
+                acpi = ""
+            debug_str += (
+                f"{prefix}{pci_slot_name} | "
+                f"{database_vendor} | {database_class} | {pci_id} | {acpi}\n"
+            )
         if debug_str:
             self.db.record_debug(debug_str)
 
@@ -964,12 +956,8 @@ class PrerequisiteValidator(AmdTool):
                 if status == 0:
                     continue
             devices.append(dev)
-        debug_str = "ACPI name: ACPI path [driver]\n"
+        debug_str = "ACPI name | ACPI path | Kernel driver\n"
         for dev in devices:
-            if dev == devices[-1]:
-                prefix = "└─"
-            else:
-                prefix = "│ "
             p = os.path.join(dev.sys_path, "path")
             pth = read_file(p)
             p = os.path.join(dev.sys_path, "physical_node", "driver")
@@ -977,7 +965,7 @@ class PrerequisiteValidator(AmdTool):
                 driver = os.path.basename(os.readlink(p))
             else:
                 driver = None
-            debug_str += f"{prefix}{dev.sys_name}: {pth} [{driver}]\n"
+            debug_str += f"{dev.sys_name} | {pth} | {driver}\n"
         if debug_str:
             self.db.record_debug(debug_str)
         return True
@@ -1157,7 +1145,6 @@ class PrerequisiteValidator(AmdTool):
             if not found_iommu:
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
-            debug_str += "DMA protection:\n"
             p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
             with open(p, "rb") as f:
                 data = f.read()

amd_debug/s2idle.py

@@ -211,6 +211,14 @@ def run_test_cycle(
         print("Failed to install dependencies")
         return False
 
+    try:
+        duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
+        since, until, fname, fmt, report_debug = prompt_report_arguments(
+            datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
+        )
+    except KeyboardInterrupt:
+        sys.exit("\nTest cancelled")
+
     try:
         app = PrerequisiteValidator(debug)
         run = app.run()
@@ -221,37 +229,32 @@ def run_test_cycle(
 
     if run or force:
         app = SleepValidator(tool_debug=debug, bios_debug=bios_debug)
-        try:
-            duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
-            since, until, fname, fmt, report_debug = prompt_report_arguments(
-                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
-            )
-        except KeyboardInterrupt:
-            sys.exit("\nTest cancelled")
 
-        app.run(
+        run = app.run(
             duration=duration,
             wait=wait,
             count=count,
             rand=rand,
             logind=logind,
         )
+    else:
+        since = None
+        until = None
+
+    app = SleepReport(
+        since=since,
+        until=until,
+        fname=fname,
+        fmt=fmt,
+        tool_debug=debug,
+        report_debug=report_debug,
+    )
+    app.run()
 
-        app = SleepReport(
-            since=since,
-            until=until,
-            fname=fname,
-            fmt=fmt,
-            tool_debug=debug,
-            report_debug=report_debug,
-        )
-        app.run()
-
-        # open report in browser if it's html
-        display_report_file(fname, fmt)
+    # open report in browser if it's html
+    display_report_file(fname, fmt)
 
-        return True
-    return False
+    return True
 
 
 def install(debug) -> None:
@@ -308,10 +311,8 @@ def parse_args():
     test_cmd.add_argument(
         "--random",
         action="store_true",
-        help=(
-            "Run sleep cycles for random durations and wait, using the "
-            "--duration and --wait arguments as an upper bound",
-        ),
+        help="Run sleep cycles for random durations and wait, using the "
+        "--duration and --wait arguments as an upper bound",
     )
     test_cmd.add_argument(
         "--force",

amd_debug/sleep_report.py

@@ -5,6 +5,7 @@ import os
 import re
 import math
 from datetime import datetime, timedelta
+import numpy as np
 from tabulate import tabulate
 from jinja2 import Environment, FileSystemLoader
 import pandas as pd
@@ -73,6 +74,8 @@ def format_percent(val):
 
 def format_timedelta(val):
     """Format seconds as a nicer format"""
+    if math.isnan(val):
+        val = 0
     return str(timedelta(seconds=val))
 
 
@@ -97,8 +100,23 @@ class SleepReport(AmdTool):
         self.debug = report_debug
         self.format = fmt
         self.failures = []
-        self.df = self.db.report_summary_dataframe(self.since, self.until)
-        self.pre_process_dataframe()
+        if since and until:
+            self.df = self.db.report_summary_dataframe(self.since, self.until)
+            self.pre_process_dataframe()
+        else:
+            self.df = pd.DataFrame(
+                columns=[
+                    "t0",
+                    "t1",
+                    "requested",
+                    "hw",
+                    "b0",
+                    "b1",
+                    "full",
+                    "wake_irq",
+                    "gpio",
+                ]
+            )
         self.battery_svg = None
         self.hwsleep_svg = None
 
@@ -136,6 +154,7 @@ class SleepReport(AmdTool):
         self.df["Duration"] = self.df["t1"].apply(format_as_seconds) - self.df[
             "t0"
         ].apply(format_as_seconds)
+        self.df["Duration"] = self.df["Duration"].replace(0, np.nan)
         self.df["Hardware Sleep"] = (self.df["hw"] / self.df["Duration"]).apply(
             parse_hw_sleep
         )
@@ -187,7 +206,8 @@ class SleepReport(AmdTool):
                 format_watts
             )
 
-    def convert_gpio_dataframe(self, content):
+    def convert_table_dataframe(self, content):
+        """Convert a table like dataframe to an HTML table"""
         header = False
         rows = []
         for line in content.split("\n"):
@@ -196,17 +216,25 @@ class SleepReport(AmdTool):
                 if header:
                     continue
                 header = True
+            line = line.strip("│")
+            line = line.replace("├─", "└─")
             if "|" in line:
                 # first column missing '|'
                 rows.append(line.replace("\t", "|"))
         columns = [row.split("|") for row in rows]
         df = pd.DataFrame(columns[1:], columns=columns[0])
-        return df.to_html(index=False, table_id="gpio")
+        return df.to_html(index=False, justify="center", col_space=30)
 
     def get_prereq_data(self):
         """Get the prereq data"""
         prereq = []
         prereq_debug = []
+        tables = [
+            "int|active",
+            "ACPI name",
+            "PCI Slot",
+            "DMI|value",
+        ]
         ts = self.db.get_last_prereq_ts()
         if not ts:
             return [], "", []
@@ -216,23 +244,24 @@ class SleepReport(AmdTool):
         if self.debug:
             for row in self.db.report_debug(t0):
                 content = row[0]
-                if self.format == "html" and "int|active" in content:
-                    content = self.convert_gpio_dataframe(content)
-                prereq_debug.append(
-                    {"data": "{message}".format(message=content.strip())}
-                )
+                if self.format == "html" and [
+                    table for table in tables if table in content
+                ]:
+                    content = self.convert_table_dataframe(content)
+                prereq_debug.append({"data": f"{content.strip()}"})
         return prereq, t0, prereq_debug
 
     def get_cycle_data(self):
         """Get the cycle data"""
         cycles = []
         debug = []
+        tables = ["Wakeup Source"]
         num = 0
         for cycle in self.df["Start Time"]:
             if self.format == "html":
                 data = ""
                 for line in self.db.report_cycle_data(cycle).split("\n"):
-                    data += "<p>{line}</p>".format(line=line)
+                    data += f"<p>{line}</p>"
                 cycles.append({"cycle_num": num, "data": data})
             else:
                 cycles.append([num, self.db.report_cycle_data(cycle)])
@@ -240,7 +269,12 @@ class SleepReport(AmdTool):
                 messages = []
                 priorities = []
                 for row in self.db.report_debug(cycle):
-                    messages.append(row[0])
+                    content = row[0]
+                    if self.format == "html" and [
+                        table for table in tables if table in content
+                    ]:
+                        content = self.convert_table_dataframe(content)
+                    messages.append(content)
                     priorities.append(get_log_priority(row[1]))
                 debug.append(
                     {"cycle_num": num, "messages": messages, "priorities": priorities}
@@ -265,58 +299,69 @@ class SleepReport(AmdTool):
             prereq, prereq_date, prereq_debug = self.get_prereq_data()
 
         # Load the cycle and/or debug data
-        cycles, debug = self.get_cycle_data()
-
-        self.post_process_dataframe()
-        failures = None
-        if self.format == "md":
-            summary = self.df.to_markdown(floatfmt=".02f")
-            cycle_data = tabulate(cycles, headers=["Cycle", "data"], tablefmt="pipe")
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="pipe",
+        if not self.df.empty:
+            cycles, debug = self.get_cycle_data()
+
+            self.post_process_dataframe()
+            failures = None
+            if self.format == "md":
+                summary = self.df.to_markdown(floatfmt=".02f")
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="pipe"
                 )
-        elif self.format == "txt":
-            summary = tabulate(self.df, headers=self.df.columns, tablefmt="fancy_grid")
-            cycle_data = tabulate(
-                cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
-            )
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="fancy_grid",
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="pipe",
+                    )
+            elif self.format == "txt":
+                summary = tabulate(
+                    self.df, headers=self.df.columns, tablefmt="fancy_grid"
+                )
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
                 )
-        elif self.format == "html":
-            summary = ""
-            row = 0
-            # we will use javascript to highlight the high values
-            for line in self.df.to_html(table_id="summary", render_links=True).split(
-                "\n"
-            ):
-                if "<tr>" in line:
-                    line = line.replace(
-                        "<tr>",
-                        '<tr class="row-low" onclick="pick_summary_cycle(%d)">' % row,
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="fancy_grid",
                     )
-                    row = row + 1
-                summary += line
-            cycle_data = cycles
-            failures = self.failures
-        # only show one cycle in stdout output even if we found more
-        else:
-            df = self.df.tail(1)
-            summary = tabulate(
-                df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
-            )
-            if cycles[-1][0] == df.index.start:
-                cycle_data = cycles[-1][-1]
+            elif self.format == "html":
+                summary = ""
+                row = 0
+                # we will use javascript to highlight the high values
+                for line in self.df.to_html(
+                    table_id="summary", render_links=True
+                ).split("\n"):
+                    if "<tr>" in line:
+                        line = line.replace(
+                            "<tr>",
+                            f'<tr class="row-low" onclick="pick_summary_cycle({row})">',
+                        )
+                        row = row + 1
+                    summary += line
+                cycle_data = cycles
+                failures = self.failures
+            # only show one cycle in stdout output even if we found more
             else:
-                cycle_data = None
-            if self.failures and self.failures[-1][0] == df.index.start:
-                failures = self.failures[-1][-1]
+                df = self.df.tail(1)
+                summary = tabulate(
+                    df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
+                )
+                if cycles[-1][0] == df.index.start:
+                    cycle_data = cycles[-1][-1]
+                else:
+                    cycle_data = None
+                if self.failures and self.failures[-1][0] == df.index.start:
+                    failures = self.failures[-1][-1]
+        else:
+            cycles = []
+            debug = []
+            cycle_data = []
+            summary = "No sleep cycles found in the database."
+            failures = None
 
         # let it burn
         context = {
@@ -333,7 +378,7 @@ class SleepReport(AmdTool):
             "failures": failures,
         }
         if self.fname:
-            with open(self.fname, "w") as f:
+            with open(self.fname, "w", encoding="utf-8") as f:
                 f.write(template.render(context))
             if "SUDO_UID" in os.environ:
                 os.chown(
@@ -345,30 +390,30 @@ class SleepReport(AmdTool):
 
     def build_battery_chart(self):
         """Build a battery chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         if "Battery Ave Rate" not in self.df.columns:
             return
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Battery Ave Rate"], color="green", label="Charge/Discharge Rate"
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Battery Delta"],
             color="grey",
             label="Battery Change",
             alpha=0.3,
         )
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Rate (Watts)")
         ax2.set_ylabel("Battery Change (%)")
@@ -385,20 +430,20 @@ class SleepReport(AmdTool):
 
     def build_hw_sleep_chart(self):
         """Build the hardware sleep chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Hardware Sleep"],
             color="red",
             label="Hardware Sleep",
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Duration"] / 60,
             color="grey",
@@ -406,9 +451,9 @@ class SleepReport(AmdTool):
             alpha=0.3,
         )
 
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Percent")
         ax2.set_yscale("log")
@@ -427,15 +472,13 @@ class SleepReport(AmdTool):
     def run(self, inc_prereq=True):
         """Run the report"""
 
-        if self.df.empty:
-            raise ValueError(f"No data found between {self.since} and {self.until}")
-
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html format
-        if len(self.df.index) > 1 and self.format == "html":
-            self.build_battery_chart()
-            self.build_hw_sleep_chart()
+        if not self.df.empty:
+            # Build charts in the page for html format
+            if len(self.df.index) > 1 and self.format == "html":
+                self.build_battery_chart()
+                self.build_hw_sleep_chart()
 
         # Render the template using jinja
         msg = self.build_template(inc_prereq)

amd_debug/templates/html

@@ -42,12 +42,14 @@
         table,
         th,
         td {
-            border-width: 0;
+            border-width: 1;
+            border-collapse: collapse;
             table-layout: fixed;
             font-family: sans-serif;
             letter-spacing: 0.02em;
             color: #000000;
-            margin-bottom: 10px;
+            text-align: left;
+            padding: 3px;
         }
 
         .○ {

amd_debug/validator.py

@@ -290,13 +290,12 @@ class SleepValidator(AmdTool):
                 sys_name = pnp.sys_name
 
             name = name.replace('"', "")
-            devices.append(f"{name} [{sys_name}]: {wake_en}")
+            devices.append(f"{name}|{sys_name}|{wake_en}")
         devices.sort()
-        self.db.record_debug("Possible wakeup sources:")
+        debug_str = "Wakeup Source|Linux Device|Status\n"
         for dev in devices:
-            # set prefix if last device
-            prefix = "│ " if dev != devices[-1] else "└─"
-            self.db.record_debug(f"{prefix}{dev}")
+            debug_str += f"{dev}\n"
+        self.db.record_debug(debug_str)
 
     def capture_lid(self) -> None:
         """Capture lid state"""
@@ -747,16 +746,18 @@ class SleepValidator(AmdTool):
                 return False
         else:
             old = get_wakeup_count()
+            p = os.path.join("/", "sys", "power", "state")
+            fd = os.open(p, os.O_WRONLY | os.O_SYNC)
             try:
-                p = os.path.join("/", "sys", "power", "state")
-                with open(p, "w", encoding="utf-8") as w:
-                    w.write("mem")
+                os.write(fd, b"mem")
             except OSError as e:
                 new = get_wakeup_count()
                 self.db.record_cycle_data(
                     f"Failed to set suspend state ({old} -> {new}): {e}", "❌"
                 )
                 return False
+            finally:
+                os.close(fd)
             return True
 
     def unlock_session(self):
@@ -780,6 +781,7 @@ class SleepValidator(AmdTool):
 
     def run(self, duration, count, wait, rand, logind):
         """Run the suspend test"""
+        min_duration = 4
         if not count:
             return True
 
@@ -787,8 +789,13 @@ class SleepValidator(AmdTool):
             self.logind = True
 
         if rand:
+            if duration <= min_duration:
+                print_color(f"Invalid max duration {duration}", "❌")
+                self.db.sync()
+                self.report_cycle()
+                return False
             print_color(
-                f"Running {count} cycle random test with max duration of {duration}s and a max wait of {wait}s",
+                f"Running {count} cycle random test with min duration of {min_duration}s, max duration of {duration}s and a max wait of {wait}s",
                 "🗣️",
             )
         elif count > 1:
@@ -799,7 +806,7 @@ class SleepValidator(AmdTool):
             )
         for i in range(1, count + 1):
             if rand:
-                self.requested_duration = random.randint(1, duration)
+                self.requested_duration = random.randint(min_duration, duration)
                 requested_wait = random.randint(1, wait)
             else:
                 self.requested_duration = duration

{amd_debug_tools-0.2.2.dist-info → amd_debug_tools-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.2
+Version: 0.2.3
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT

{amd_debug_tools-0.2.2.dist-info → amd_debug_tools-0.2.3.dist-info}/RECORD

@@ -9,11 +9,11 @@ test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
 test_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
 test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
 test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
-test_prerequisites.py,sha256=4Ltxx7vGU91b9MX1AtdPLS8iyWJBCNuEKCuO0nnEb_g,83381
+test_prerequisites.py,sha256=VXN822W-7ZZHXZkJYH5MeKsDVBC-ttUZggYlcoPjVyM,83335
 test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
-test_s2idle.py,sha256=-S3yymjprf3_LIgaPGWgzN9FmnyQG55dNc4xqWAF8Z8,32344
-test_sleep_report.py,sha256=R3cUPPT9r9q4q93xk6NFvi4ySgT5laqidk2SASuTWIo,5878
-test_validator.py,sha256=NeiX8kT5DiHiiB5lRSJkjIpV32UzaIrW5ljKLmFtBMk,30490
+test_s2idle.py,sha256=6NaqGp9VOLr_Tr3KczSvfSo3M882aYEbSvRV9xvUMcA,33534
+test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
+test_validator.py,sha256=-MfrWfhwef_aRqOSD_dJGhH0shsghhtOBgzeijzyLW4,33975
 test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
 amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
 amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
@@ -22,24 +22,24 @@ amd_debug/bios.py,sha256=wmPKDsTZeQqsHjWpv-YHdgRNlCtFdzHQ6jJf0H3hjN8,3971
 amd_debug/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
 amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
 amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
-amd_debug/failures.py,sha256=Otv3YDu7Je4ljSifVmvjObGoOY4OvLIY20pw-v4Dqkw,22911
+amd_debug/failures.py,sha256=z4O4Q-akv3xYGssSZFCqE0cDE4P9F_aw1hxil3McoD4,22910
 amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
-amd_debug/kernel.py,sha256=xzAy-sDY5-sd4jxyU7EaBokS7YsvEjoWRuexaTJNRBc,11851
-amd_debug/prerequisites.py,sha256=bKJA9ztyapB8rxrNEgc-hxazw5Uh-sP5X0S7zplGA0c,50413
+amd_debug/kernel.py,sha256=UAlxlXNuZxtHVtrfCmTp12YombVaUs4mizOxwuXTX2M,12038
+amd_debug/prerequisites.py,sha256=r4_IFTL-1YcPptlt6Nump7iscRx1bBCGF33hqNQB0X0,49867
 amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
 amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
-amd_debug/s2idle.py,sha256=lzxLYZBcQllyqEMZfxYEUvQO3ArgVzwL5FHymzvZvSs,13281
-amd_debug/sleep_report.py,sha256=zgwcmSk7S8GAmPtPZJGP29Mr5bcWUBxwNL8HBubKs6Q,15516
-amd_debug/validator.py,sha256=fgG3D0k6DS9ArgzK1SuPUds1FNGoKf2asPUwWoyCsXE,33205
+amd_debug/s2idle.py,sha256=Ei5ONnJyHz9aQbstRZYnofhJ_sJOAOZQxLgIuWfvcng,13218
+amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
+amd_debug/validator.py,sha256=nZ5UpvvsABw4yTea_pZ8DHaLbSoM5VHz3uvlrdWAb34,33444
 amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
 amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
-amd_debug/templates/html,sha256=tnpqHDZF5FfhC6YNRUfOG6Vn9ZtISFr10kEXSB476Mw,14518
+amd_debug/templates/html,sha256=JfGhpmHIB2C2GItdGI1kuC8uayqEVgrpQvAWAj35eZ4,14580
 amd_debug/templates/md,sha256=r8X2aehnH2gzj0WHYTZ5K9wAqC5y39i_3nkDORSC0uM,787
 amd_debug/templates/stdout,sha256=hyoOJ96K2dJfnWRWhyCuariLKbEHXvs9mstV_g5aMdI,469
 amd_debug/templates/txt,sha256=nNdsvbPFOhGdL7VA-_4k5aN3nB-6ouGQt6AsWst7T3w,649
-amd_debug_tools-0.2.2.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.2.dist-info/METADATA,sha256=oZ5H5dL216bbAqtOF8VmvtqkqctPIf5iPibPCjjc1tQ,6877
-amd_debug_tools-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amd_debug_tools-0.2.2.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.2.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.2.dist-info/RECORD,,
+amd_debug_tools-0.2.3.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.3.dist-info/METADATA,sha256=-DdxkPvWEXMifkgAjfyNIpleo_rHFPIH8nS6v3AWJTk,6877
+amd_debug_tools-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.3.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.3.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.3.dist-info/RECORD,,

test_prerequisites.py

@@ -500,9 +500,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n"
-            "│ device1: mocked_path [driver]\n"
-            "└─device2: mocked_path [driver]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | driver\ndevice2 | mocked_path | driver\n"
         )
 
     @patch("amd_debug.prerequisites.os.path.exists")
@@ -545,7 +543,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n└─device1: mocked_path [None]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | None\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -569,8 +567,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -593,8 +590,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh]\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | \n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -628,9 +624,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "│ 0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n│ 0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | mocked_acpi_path\n"
         )
 
     def test_capture_pci_acpi_no_devices(self):
@@ -638,7 +632,9 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_pyudev.list_devices.return_value = []
 
         self.validator.capture_pci_acpi()
-        self.mock_db.record_debug.assert_called_with("PCI devices\n")
+        self.mock_db.record_debug.assert_called_with(
+            "PCI Slot | Vendor | Class | ID | ACPI path\n"
+        )
 
     @patch("amd_debug.prerequisites.read_file")
     def test_check_aspm_default_policy(self, mock_read_file):
@@ -1006,7 +1002,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "MockVendor MockProduct (MockFamily)", "💻"
         )
         self.mock_db.record_debug.assert_called_with(
-            "DMI data:\nchassis_type: Desktop\n"
+            "DMI|value\nchassis_type| Desktop\n"
         )
 
     @patch("amd_debug.prerequisites.os.walk")
@@ -1034,7 +1030,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_prereq.assert_called_with(
             "MockVendor MockProduct (MockFamily)", "💻"
         )
-        self.mock_db.record_debug.assert_called_with("DMI data:\n")
+        self.mock_db.record_debug.assert_called_with("DMI|value\n")
 
     @patch("amd_debug.prerequisites.os.walk")
     @patch("amd_debug.prerequisites.read_file")
@@ -1710,9 +1706,6 @@ class TestPrerequisiteValidator(unittest.TestCase):
         ]
         result = self.validator.check_storage()
         self.assertTrue(result)
-        self.mock_db.record_debug.assert_called_with(
-            "New enough kernel to avoid NVME check"
-        )
 
     def test_check_storage_no_kernel_log(self):
         """Test check_storage when kernel log is unavailable"""

test_s2idle.py

@@ -455,12 +455,18 @@ class TestTestFunction(unittest.TestCase):
 
     @patch("amd_debug.s2idle.Installer")
     @patch("amd_debug.s2idle.PrerequisiteValidator")
-    @patch("amd_debug.prerequisites.SleepDatabase")
-    @patch("amd_debug.validator.SleepDatabase")
+    @patch("amd_debug.s2idle.SleepValidator")
+    @patch("amd_debug.s2idle.SleepReport")
+    @patch("amd_debug.s2idle.prompt_test_arguments")
+    @patch("amd_debug.s2idle.prompt_report_arguments")
+    @patch("amd_debug.s2idle.display_report_file")
     def test_test_prerequisite_failure(
         self,
-        _mock_sleep_db,
-        _mock_sleep_db_prerequisite,
+        mock_display_report_file,
+        mock_prompt_report_arguments,
+        mock_prompt_test_arguments,
+        mock_sleep_report,
+        mock_sleep_validator,
         mock_prerequisite_validator,
         mock_installer,
     ):
@@ -471,6 +477,17 @@ class TestTestFunction(unittest.TestCase):
         mock_prerequisite_instance = mock_prerequisite_validator.return_value
         mock_prerequisite_instance.run.return_value = False
 
+        mock_prompt_test_arguments.return_value = (10, 5, 3)
+        mock_prompt_report_arguments.return_value = (
+            "2023-01-01",
+            "2023-02-01",
+            "report.html",
+            "html",
+            True,
+        )
+        mock_sleep_validator_instance = mock_sleep_validator.return_value
+        mock_sleep_report_instance = mock_sleep_report.return_value
+
         result = run_test_cycle(
             duration=None,
             wait=None,
@@ -492,7 +509,20 @@ class TestTestFunction(unittest.TestCase):
         mock_prerequisite_validator.assert_called_once_with(True)
         mock_prerequisite_instance.run.assert_called_once()
         mock_prerequisite_instance.report.assert_called_once()
-        self.assertFalse(result)
+        mock_prompt_test_arguments.assert_called_once_with(None, None, None, False)
+        mock_prompt_report_arguments.assert_called_once()
+        mock_sleep_validator_instance.assert_not_called()
+        mock_sleep_report.assert_called_once_with(
+            since=None,
+            until=None,
+            fname="report.html",
+            fmt="html",
+            tool_debug=True,
+            report_debug=True,
+        )
+        mock_sleep_report_instance.run.assert_called_once()
+        mock_display_report_file.assert_called_once_with("report.html", "html")
+        self.assertTrue(result)
 
     @patch("amd_debug.s2idle.Installer")
     @patch("amd_debug.s2idle.PrerequisiteValidator")
@@ -533,9 +563,9 @@ class TestTestFunction(unittest.TestCase):
             "iasl", "ethtool", "edid-decode"
         )
         mock_installer_instance.install_dependencies.assert_called_once()
-        mock_prerequisite_validator.assert_called_once_with(True)
-        mock_prerequisite_instance.run.assert_called_once()
-        mock_prerequisite_instance.report.assert_called_once()
+        mock_prerequisite_validator.assert_not_called()
+        mock_prerequisite_instance.run.assert_not_called()
+        mock_prerequisite_instance.report.assert_not_called()
         mock_prompt_test_arguments.assert_called_once_with(None, None, None, False)
 
 

test_sleep_report.py

@@ -5,6 +5,7 @@
 This module contains unit tests for the s2idle tool in the amd-debug-tools package.
 """
 
+import math
 import unittest
 from datetime import datetime
 from unittest.mock import patch
@@ -165,3 +166,31 @@ class TestSleepReport(unittest.TestCase):
         self.report.build_hw_sleep_chart()
         self.assertIsNotNone(self.report.hwsleep_svg)
         mock_savefig.assert_called_once()
+
+    def test_pre_process_dataframe_zero_duration(self):
+        """Test the pre_process_dataframe method when t0 and t1 are the same."""
+        # Mock the dataframe with t0 and t1 being the same
+        self.report.df = pd.DataFrame(
+            {
+                "t0": [datetime(2023, 10, 10, 12, 0, 0).strftime("%Y%m%d%H%M%S")],
+                "t1": [datetime(2023, 10, 10, 12, 0, 0).strftime("%Y%m%d%H%M%S")],
+                "hw": [50],
+                "requested": [1],
+                "gpio": ["1, 2"],
+                "wake_irq": ["1"],
+                "b0": [90],
+                "b1": [85],
+                "full": [100],
+            }
+        )
+
+        # Call the method
+        self.report.pre_process_dataframe()
+
+        # Verify the dataframe was processed correctly
+        self.assertTrue(
+            self.report.df["Duration"].isna().iloc[0]
+        )  # Duration should be NaN
+        self.assertTrue(
+            math.isnan(self.report.df["Hardware Sleep"].iloc[0])
+        )  # Hardware Sleep should be NaN

test_validator.py

@@ -5,8 +5,9 @@
 This module contains unit tests for the validator functions in the amd-debug-tools package.
 """
 
-from unittest.mock import patch, mock_open
+from unittest.mock import patch, mock_open, Mock
 
+import os
 import logging
 import unittest
 import math
@@ -157,9 +158,8 @@ class TestValidator(unittest.TestCase):
         self.validator.capture_wake_sources()
 
         # Validate debug messages
-        mock_record_debug.assert_any_call("Possible wakeup sources:")
         mock_record_debug.assert_any_call(
-            "└─ [/sys/devices/pci0000:00/0000:00:14.0]: enabled"
+            "Wakeup Source|Linux Device|Status\n|/sys/devices/pci0000:00/0000:00:14.0|enabled\n"
         )
 
         # Stop patches
@@ -694,7 +694,7 @@ class TestValidator(unittest.TestCase):
         # Test case 3: Randomized test
         mock_randint.side_effect = [7, 3]  # Random duration and wait
         self.validator.run(duration=10, count=1, wait=5, rand=True, logind=False)
-        mock_randint.assert_any_call(1, 10)
+        mock_randint.assert_any_call(4, 10)
         mock_randint.assert_any_call(1, 5)
         mock_run_countdown.assert_any_call("Suspending system", math.ceil(3 / 2))
         mock_run_countdown.assert_any_call("Collecting data", math.ceil(3 / 2))
@@ -705,19 +705,128 @@ class TestValidator(unittest.TestCase):
         mock_report_cycle.assert_called()
         mock_unlock_session.assert_called()
 
-        # Test case 4: Multiple cycles
+        # Test case 4: Randomized test, but too short of a duration
+        result = self.validator.run(
+            duration=4, count=1, wait=5, rand=True, logind=False
+        )
+        self.assertFalse(result)
+        mock_report_cycle.assert_called()
+
+        # Test case 5: Multiple cycles
         self.validator.run(duration=10, count=2, wait=5, rand=False, logind=False)
         self.assertEqual(mock_prep.call_count, 4)  # Includes previous calls
         self.assertEqual(mock_program_wakealarm.call_count, 4)
         self.assertEqual(mock_suspend_system.call_count, 4)
         self.assertEqual(mock_post.call_count, 4)
-        self.assertEqual(mock_report_cycle.call_count, 4)
+        self.assertEqual(mock_report_cycle.call_count, 5)
         self.assertEqual(mock_unlock_session.call_count, 3)
 
-        # Test case 5: suspend_system fails
+        # Test case 6: suspend_system fails
         mock_suspend_system.return_value = False
         result = self.validator.run(
             duration=10, count=1, wait=5, rand=False, logind=False
         )
         self.assertFalse(result)
         mock_report_cycle.assert_called()
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open, read_data="3")
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_success(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with success"""
+        # Mock wakeup_count file existence
+        mock_path_exists.side_effect = lambda path: "wakeup_count" in path
+
+        # Mock os.open and os.write
+        mock_os_open.return_value = 3
+        mock_os_write.return_value = None
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned True
+        self.assertTrue(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open, read_data="3")
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_failure(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with failure"""
+        # Mock wakeup_count file existence
+        mock_path_exists.side_effect = lambda path: "wakeup_count" in path
+
+        # Mock os.open to raise OSError
+        mock_os_open.return_value = 3
+        mock_os_write.side_effect = OSError("Failed to write to state")
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned False
+        self.assertFalse(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_no_wakeup_count(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with no wakeup_count file"""
+        # Mock wakeup_count file does not exist
+        mock_path_exists.return_value = False
+
+        # Mock os.open and os.write
+        mock_os_open.return_value = 3
+        mock_os_write.return_value = None
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned True
+        self.assertTrue(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)