amd-debug-tools 0.2.5__py3-none-any.whl → 0.2.12__py3-none-any.whl

amd_debug/prerequisites.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 """
@@ -21,7 +20,7 @@ import pyudev
 
 from amd_debug.wake import WakeIRQ
 from amd_debug.display import Display
-from amd_debug.kernel import get_kernel_log, SystemdLogger, DmesgLogger
+from amd_debug.kernel import get_kernel_log, SystemdLogger, CySystemdLogger, DmesgLogger
 from amd_debug.common import (
     apply_prefix_wrapper,
     BIT,
@@ -55,12 +54,15 @@ from amd_debug.failures import (
     I2CHidBug,
     KernelRingBufferWrapped,
     LimitedCores,
+    MissingAmdCaptureModule,
     MissingAmdgpu,
     MissingAmdgpuFirmware,
     MissingAmdPmc,
+    MissingGpu,
     MissingDriver,
     MissingIommuACPI,
     MissingIommuPolicy,
+    MissingIsp4PlatformDriver,
     MissingThunderbolt,
     MissingXhciHcd,
     MSRFailure,
@@ -128,13 +130,35 @@ class PrerequisiteValidator(AmdTool):
         if not self.db.get_last_prereq_ts():
             self.run()
 
+    def capture_nvidia(self):
+        """Capture the NVIDIA GPU state"""
+        p = os.path.join("/", "proc", "driver", "nvidia", "version")
+        if not os.path.exists(p):
+            return True
+        try:
+            self.db.record_debug_file(p)
+        except PermissionError:
+            self.db.record_prereq("NVIDIA GPU version not readable", "👀")
+            return True
+        p = os.path.join("/", "proc", "driver", "nvidia", "gpus")
+        if not os.path.exists(p):
+            return True
+        for root, _dirs, files in os.walk(p, topdown=False):
+            for f in files:
+                try:
+                    self.db.record_debug(f"NVIDIA {f}")
+                    self.db.record_debug_file(os.path.join(root, f))
+                except PermissionError:
+                    self.db.record_prereq("NVIDIA GPU {f} not readable", "👀")
+        return True
+
     def capture_edid(self):
         """Capture and decode the EDID data"""
         edids = self.display.get_edid()
         if len(edids) == 0:
             self.db.record_debug("No EDID data found")
             return True
-        for name, p in edids.items():
+        for p in edids:
             output = None
             for tool in ["di-edid-decode", "edid-decode"]:
                 try:
@@ -145,16 +169,17 @@ class PrerequisiteValidator(AmdTool):
                     break
                 except FileNotFoundError:
                     self.db.record_debug(f"{cmd} not installed")
-                except subprocess.CalledProcessError as e:
+                except subprocess.CalledProcessError as _e:
                     pass
             if not output:
                 self.db.record_prereq("Failed to capture EDID table", "👀")
             else:
-                self.db.record_debug(apply_prefix_wrapper(f"EDID for {name}:", output))
+                self.db.record_debug(apply_prefix_wrapper(f"EDID for {p}:", output))
         return True
 
     def check_amdgpu(self):
         """Check for the AMDGPU driver"""
+        count = 0
         for device in self.pyudev.list_devices(subsystem="pci"):
             klass = device.properties.get("PCI_CLASS")
             if klass not in ["30000", "38000"]:
@@ -162,6 +187,7 @@ class PrerequisiteValidator(AmdTool):
             pci_id = device.properties.get("PCI_ID")
             if not pci_id.startswith("1002"):
                 continue
+            count += 1
             if device.properties.get("DRIVER") != "amdgpu":
                 self.db.record_prereq("GPU driver `amdgpu` not loaded", "❌")
                 self.failures += [MissingAmdgpu()]
@@ -169,6 +195,10 @@ class PrerequisiteValidator(AmdTool):
             slot = device.properties.get("PCI_SLOT_NAME")
 
             self.db.record_prereq(f"GPU driver `amdgpu` bound to {slot}", "✅")
+        if count == 0:
+            self.db.record_prereq("Integrated GPU not found", "❌")
+            self.failures += [MissingGpu()]
+            return False
         return True
 
     def check_amdgpu_parameters(self):
@@ -650,7 +680,9 @@ class PrerequisiteValidator(AmdTool):
         """Check the source for kernel logs"""
         if isinstance(self.kernel_log, SystemdLogger):
             self.db.record_prereq("Logs are provided via systemd", "✅")
-        if isinstance(self.kernel_log, DmesgLogger):
+        elif isinstance(self.kernel_log, CySystemdLogger):
+            self.db.record_prereq("Logs are provided via cysystemd", "✅")
+        elif isinstance(self.kernel_log, DmesgLogger):
             self.db.record_prereq(
                 "Logs are provided via dmesg, timestamps may not be accurate over multiple cycles",
                 "🚦",
@@ -718,6 +750,9 @@ class PrerequisiteValidator(AmdTool):
             p = os.path.join("/", "sys", "kernel", "debug", "gpio")
             try:
                 contents = read_file(p)
+            except FileNotFoundError:
+                self.db.record_prereq("GPIO debugfs not available", "👀")
+                contents = None
             except PermissionError:
                 self.db.record_debug(f"Unable to capture {p}")
                 contents = None
@@ -754,7 +789,7 @@ class PrerequisiteValidator(AmdTool):
                     "utf-8"
                 )
             except FileNotFoundError:
-                self.db.record_prereq(f"ethtool is missing", "👀")
+                self.db.record_prereq("ethtool is missing", "👀")
                 return True
             for line in output.split("\n"):
                 if "Supports Wake-on" in line:
@@ -946,6 +981,44 @@ class PrerequisiteValidator(AmdTool):
         if debug_str:
             self.db.record_debug(debug_str)
 
+    def check_isp4(self):
+        """Check if camera supported by ISP is present and set up properly"""
+        devices = []
+        for dev in self.pyudev.list_devices(subsystem="acpi"):
+            # look for ACPI device for camera (OMNI5C10:00 is seen today)
+            if not dev.sys_name.startswith("OMNI5C10"):
+                continue
+            p = os.path.join(dev.sys_path, "path")
+            if not os.path.exists(p):
+                continue
+            devices.append(dev)
+        for dev in devices:
+            p = os.path.join(dev.sys_path, "physical_node", "driver")
+            if os.path.exists(p):
+                driver = os.path.basename(os.readlink(p))
+            else:
+                driver = None
+            if driver != "amd-isp4":
+                self.db.record_prereq(
+                    f"ISP4 platform camera driver 'amd-isp4' not bound to {dev.sys_name}",
+                    "❌",
+                )
+                self.failures += [MissingIsp4PlatformDriver()]
+                return False
+            self.db.record_prereq(
+                f"ISP4 platform camera driver 'amd-isp4' bound to {dev.sys_name}", "✅"
+            )
+            # check if `amd_capture` module is loaded
+            p = os.path.join("/", "sys", "module", "amd_capture")
+            if not os.path.exists(p):
+                self.db.record_prereq(
+                    "Camera driver module 'amd_capture' not loaded", "❌"
+                )
+                self.failures += [MissingAmdCaptureModule()]
+                return False
+            self.db.record_prereq("Camera driver module 'amd_capture' loaded", "✅")
+        return True
+
     def map_acpi_path(self):
         """Map of ACPI devices to ACPI paths"""
         devices = []
@@ -1007,6 +1080,21 @@ class PrerequisiteValidator(AmdTool):
                     shutil.rmtree(tmpd)
         return True
 
+    def capture_cstates(self):
+        """Capture ACPI C state information for the first CPU (assumes the same for all CPUs)"""
+        base = os.path.join("/", "sys", "bus", "cpu", "devices", "cpu0", "cpuidle")
+        paths = {}
+        for root, _dirs, files in os.walk(base, topdown=False):
+            for fname in files:
+                target = os.path.join(root, fname)
+                with open(target, "rb") as f:
+                    paths[target] = f.read()
+        debug_str = "ACPI C-state information\n"
+        for path, data in paths.items():
+            prefix = "│ " if path != list(paths.keys())[-1] else "└─"
+            debug_str += f"{prefix}{path}: {data.decode('utf-8', 'ignore')}"
+        self.db.record_debug(debug_str)
+
     def capture_battery(self):
         """Capture battery information"""
         obj = Batteries()
@@ -1065,11 +1153,22 @@ class PrerequisiteValidator(AmdTool):
         # check for artificially limited CPUs
         p = os.path.join("/", "sys", "devices", "system", "cpu", "kernel_max")
         max_cpus = int(read_file(p)) + 1  # 0 indexed
-        # https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/24594.pdf
-        # Extended Topology Enumeration (NumLogCores)
-        # CPUID 0x80000026 subleaf 1
+        # https://docs.amd.com/v/u/en-US/40332-PUB_4.08
+        # E.4.24 Function 8000_0026—Extended CPU Topology
         try:
-            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, 1)
+            # Need to discover the socket level to look at all CCDs in the socket
+            for level in range(0, 5):
+                _, _, ecx, _ = read_cpuid(0, 0x80000026, level)
+                level_type = (ecx >> 8) & 0xFF
+                if level_type == 0:
+                    self.db.record_prereq(
+                        "Unable to discover CPU topology, didn't find socket level",
+                        "🚦",
+                    )
+                    return True
+                if level_type == 4:
+                    break
+            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, level)
             if cpu_count > max_cpus:
                 self.db.record_prereq(
                     f"The kernel has been limited to {max_cpus} CPU cores, "
@@ -1140,7 +1239,6 @@ class PrerequisiteValidator(AmdTool):
         if self.cpu_family == 0x1A and self.cpu_model in affected_1a:
             found_iommu = False
             found_acpi = False
-            found_dmar = False
             for dev in self.pyudev.list_devices(subsystem="iommu"):
                 found_iommu = True
                 debug_str += f"Found IOMMU {dev.sys_path}\n"
@@ -1227,9 +1325,8 @@ class PrerequisiteValidator(AmdTool):
         # ignore kernel warnings
         taint &= ~BIT(9)
         if taint != 0:
-            self.db.record_prereq(f"Kernel is tainted: {taint}", "❌")
+            self.db.record_prereq(f"Kernel is tainted: {taint}", "🚦")
             self.failures += [TaintedKernel()]
-            return False
         return True
 
     def run(self):
@@ -1244,6 +1341,8 @@ class PrerequisiteValidator(AmdTool):
             self.capture_logind,
             self.capture_pci_acpi,
             self.capture_edid,
+            self.capture_nvidia,
+            self.capture_cstates,
         ]
         checks = []
 
@@ -1273,6 +1372,7 @@ class PrerequisiteValidator(AmdTool):
                 self.check_iommu,
                 self.check_asus_rog_ally,
                 self.check_dpia_pg_dmcub,
+                self.check_isp4,
             ]
 
         checks += [
@@ -1296,7 +1396,7 @@ class PrerequisiteValidator(AmdTool):
             if not check():
                 result = False
         if not result:
-            self.db.record_prereq(Headers.BrokenPrerequisites, "💯")
+            self.db.record_prereq(Headers.BrokenPrerequisites, "🚫")
         self.db.sync()
         clear_temporary_message(len(msg))
         return result
@@ -1315,7 +1415,7 @@ class PrerequisiteValidator(AmdTool):
                     logging.debug(line)
 
         if len(self.failures) == 0:
-            return True
+            return
         print_color(Headers.ExplanationReport, "🗣️")
         for item in self.failures:
             item.get_failure()

amd_debug/pstate.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 """CPPC triage script for AMD systems"""
 
@@ -293,18 +292,20 @@ def parse_args():
         action="store_true",
         help="Enable tool debug logging",
     )
-    subparsers.add_parser("version", help="Show version information")
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
     if len(sys.argv) == 1:
         parser.print_help(sys.stderr)
         sys.exit(1)
     return parser.parse_args()
 
 
-def main() -> None|int:
+def main() -> None | int:
     """Main function"""
     args = parse_args()
     ret = False
-    if args.command == "version":
+    if args.version:
         print(version())
         return
     elif args.command == "triage":

amd_debug/s2idle.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 """s2idle analysis tool"""
 import argparse
@@ -11,6 +10,7 @@ from datetime import date, timedelta, datetime
 from amd_debug.common import (
     convert_string_to_bool,
     colorize_choices,
+    fatal_error,
     is_root,
     relaunch_sudo,
     show_log_info,
@@ -61,21 +61,22 @@ def display_report_file(fname, fmt) -> None:
         return
     user = os.environ.get("SUDO_USER")
     if user:
-        # ensure that xdg tools will know how to display the file
-        # (user may need to call tool with sudo -E)
-        if os.environ.get("XDG_SESSION_TYPE"):
-            subprocess.call(["sudo", "-E", "-u", user, "xdg-open", fname])
-        else:
-            print(
-                "To display report automatically in browser launch tool "
-                f"with '-E' argument (Example: sudo -E {sys.argv[0]})"
-            )
+        cmd = [
+            "systemd-run",
+            "--user",
+            f"--machine={user}@.host",
+            "xdg-open",
+            os.path.abspath(fname),
+        ]
+        ret = subprocess.call(cmd)
+        if ret:
+            fatal_error(f"Failed to open report: {ret}")
 
 
 def get_report_file(report_file, extension) -> str:
     """Prompt user for report file"""
     if extension == "stdout":
-        return None
+        return ""
     if not report_file:
         return f"amd-s2idle-report-{date.today()}.{extension}"
     return report_file
@@ -88,7 +89,7 @@ def get_report_format() -> str:
     return "html"
 
 
-def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
+def prompt_report_arguments(since, until, fname, fmt, report_debug) -> list:
     """Prompt user for report configuration"""
     if not since:
         default = Defaults.since
@@ -213,8 +214,10 @@ def run_test_cycle(
 
     try:
         duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
+        total_seconds = (duration + wait) * count
+        until_time = datetime.now() + timedelta(seconds=total_seconds)
         since, until, fname, fmt, report_debug = prompt_report_arguments(
-            datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
+            datetime.now().isoformat(), until_time.isoformat(), fname, fmt, True
         )
     except KeyboardInterrupt:
         sys.exit("\nTest cancelled")
@@ -237,6 +240,7 @@ def run_test_cycle(
             rand=rand,
             logind=logind,
         )
+        until = datetime.now()
     else:
         since = None
         until = None
@@ -385,7 +389,9 @@ def parse_args():
             help="Enable tool debug logging",
         )
 
-    subparsers.add_parser("version", help="Show version information")
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
 
     if len(sys.argv) == 1:
         parser.print_help(sys.stderr)
@@ -394,7 +400,7 @@ def parse_args():
     return parser.parse_args()
 
 
-def main() -> None|int:
+def main() -> None | int:
     """Main function"""
     args = parse_args()
     ret = False
@@ -427,7 +433,7 @@ def main() -> None|int:
             args.logind,
             args.bios_debug,
         )
-    elif args.action == "version":
+    elif args.version:
         print(version())
         return
     else:

amd_debug/sleep_report.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 import os
@@ -488,7 +487,7 @@ class SleepReport(AmdTool):
             text = line.strip()
             if not text:
                 continue
-            for group in ["🗣️", "❌", "🚦", "🦟", "💯", "○"]:
+            for group in ["🗣️", "❌", "🚦", "🦟", "🚫", "○"]:
                 if line.startswith(group):
                     text = line.split(group)[-1]
                     color = get_group_color(group)

amd_debug/ttm.py

@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: MIT
+"""TTM configuration tool"""
+
+import asyncio
+import os
+import argparse
+from amd_debug.common import (
+    AmdTool,
+    bytes_to_gb,
+    gb_to_pages,
+    get_system_mem,
+    relaunch_sudo,
+    print_color,
+    reboot,
+    version,
+)
+
+TTM_PARAM_PATH = "/sys/module/ttm/parameters/pages_limit"
+MODPROBE_CONF_PATH = "/etc/modprobe.d/ttm.conf"
+# Maximum percentage of total system memory to allow for TTM
+MAX_MEMORY_PERCENTAGE = 90
+
+
+def maybe_reboot() -> bool:
+    """Prompt to reboot system"""
+    response = input("Would you like to reboot the system now? (y/n): ").strip().lower()
+    if response in ("y", "yes"):
+        return reboot()
+    return True
+
+
+class AmdTtmTool(AmdTool):
+    """Class for handling TTM page configuration"""
+
+    def __init__(self, logging):
+        log_prefix = "ttm" if logging else None
+        super().__init__(log_prefix)
+
+    def get(self) -> bool:
+        """Read current page limit"""
+        try:
+            with open(TTM_PARAM_PATH, "r", encoding="utf-8") as f:
+                pages = int(f.read().strip())
+                gb_value = bytes_to_gb(pages)
+                print_color(
+                    f"Current TTM pages limit: {pages} pages ({gb_value:.2f} GB)", "💻"
+                )
+        except FileNotFoundError:
+            print_color(f"Error: Could not find {TTM_PARAM_PATH}", "❌")
+            return False
+
+        total = get_system_mem()
+        if total > 0:
+            print_color(f"Total system memory: {total:.2f} GB", "💻")
+
+        return True
+
+    def set(self, gb_value) -> bool:
+        """Set a new page limit"""
+        relaunch_sudo()
+
+        # Check against system memory
+        total = get_system_mem()
+        if total > 0:
+            max_recommended_gb = total * MAX_MEMORY_PERCENTAGE / 100
+
+            if gb_value > total:
+                print_color(
+                    f"{gb_value:.2f} GB is greater than total system memory ({total:.2f} GB)",
+                    "❌",
+                )
+                return False
+
+            if gb_value > max_recommended_gb:
+                print_color(
+                    f"Warning: The requested value ({gb_value:.2f} GB) exceeds {MAX_MEMORY_PERCENTAGE}% of your system memory ({max_recommended_gb:.2f} GB).",
+                    "🚦",
+                )
+                response = (
+                    input(
+                        "This could cause system instability. Continue anyway? (y/n): "
+                    )
+                    .strip()
+                    .lower()
+                )
+                if response not in ("y", "yes"):
+                    print_color("Operation cancelled.", "🚦")
+                    return False
+
+        pages = gb_to_pages(gb_value)
+
+        with open(MODPROBE_CONF_PATH, "w", encoding="utf-8") as f:
+            f.write(f"options ttm pages_limit={pages}\n")
+        print_color(
+            f"Successfully set TTM pages limit to {pages} pages ({gb_value:.2f} GB)",
+            "🐧",
+        )
+        print_color(f"Configuration written to {MODPROBE_CONF_PATH}", "🐧")
+        print_color("NOTE: You need to reboot for changes to take effect.", "○")
+
+        return maybe_reboot()
+
+    def clear(self) -> bool:
+        """Clears the page limit"""
+        if not os.path.exists(MODPROBE_CONF_PATH):
+            print_color(f"{MODPROBE_CONF_PATH} doesn't exist", "❌")
+            return False
+
+        relaunch_sudo()
+
+        os.remove(MODPROBE_CONF_PATH)
+        print_color(f"Configuration {MODPROBE_CONF_PATH} removed", "🐧")
+
+        return maybe_reboot()
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Manage TTM pages limit")
+    parser.add_argument("--set", type=float, help="Set pages limit in GB")
+    parser.add_argument(
+        "--clear", action="store_true", help="Clear a previously set page limit"
+    )
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
+    parser.add_argument(
+        "--tool-debug",
+        action="store_true",
+        help="Enable tool debug logging",
+    )
+
+    return parser.parse_args()
+
+
+def main() -> None | int:
+    """Main function"""
+
+    args = parse_args()
+    tool = AmdTtmTool(args.tool_debug)
+    ret = False
+
+    if args.version:
+        print(version())
+        return
+    elif args.set is not None:
+        if args.set <= 0:
+            print("Error: GB value must be greater than 0")
+            return 1
+        ret = tool.set(args.set)
+    elif args.clear:
+        ret = tool.clear()
+    else:
+        ret = tool.get()
+    if ret is False:
+        return 1
+    return