amd-debug-tools 0.2.0__py3-none-any.whl

amd_debug/__init__.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+
+def amd_s2idle():
+    """Launch the amd-s2idle tool."""
+    from . import s2idle  # pylint: disable=import-outside-toplevel
+
+    return s2idle.main()
+
+
+def amd_bios():
+    """Launch the amd-bios tool."""
+    from . import bios  # pylint: disable=import-outside-toplevel
+
+    return bios.main()
+
+
+def amd_pstate():
+    """Launch the amd-pstate tool."""
+    from . import pstate  # pylint: disable=import-outside-toplevel
+
+    return pstate.main()
+
+
+def install_dep_superset():
+    """Install all supserset dependencies."""
+    from . import installer  # pylint: disable=import-outside-toplevel
+
+    return installer.install_dep_superset()
+
+
+def launch_tool(tool_name):
+    """Launch a tool with the given name and arguments."""
+    tools = {
+        "amd_s2idle.py": amd_s2idle,
+        "amd_bios.py": amd_bios,
+        "amd_pstate.py": amd_pstate,
+        "install_deps.py": install_dep_superset,
+    }
+    if tool_name in tools:
+        return tools[tool_name]()
+    else:
+        print(f"\033[91mUnknown exe: {tool_name}\033[0m")
+        return False

amd_debug/acpi.py

@@ -0,0 +1,107 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+import os
+import logging
+from amd_debug.common import BIT, read_file
+
+ACPI_METHOD = "M460"
+
+
+def search_acpi_tables(pattern):
+    """Search for a pattern in ACPI tables"""
+    p = os.path.join("/", "sys", "firmware", "acpi", "tables")
+
+    for fn in os.listdir(p):
+        if not fn.startswith("SSDT") and not fn.startswith("DSDT"):
+            continue
+        fp = os.path.join(p, fn)
+        with open(fp, "rb") as file:
+            content = file.read()
+            if pattern.encode() in content:
+                return True
+    return False
+
+
+class AcpicaTracer:
+    """Class for ACPI tracing"""
+
+    def __init__(self):
+        self.acpi_base = os.path.join("/", "sys", "module", "acpi", "parameters")
+        keys = [
+            "trace_debug_layer",
+            "trace_debug_level",
+            "trace_method_name",
+            "trace_state",
+        ]
+        self.original = {}
+        self.supported = False
+        for key in keys:
+            fname = os.path.join(self.acpi_base, key)
+            if not os.path.exists(fname):
+                logging.debug("ACPI Notify() debugging not available")
+                return
+            v = read_file(fname)
+            if v and v != "(null)":
+                self.original[key] = v
+        self.supported = True
+
+    def _write_expected(self, expected):
+        for key, value in expected.items():
+            p = os.path.join(self.acpi_base, key)
+            if isinstance(value, int):
+                t = str(int(value))
+            else:
+                t = value
+            with open(p, "w", encoding="utf-8") as w:
+                w.write(t)
+
+    def trace_notify(self):
+        """Trace notify events"""
+        if not self.supported:
+            return False
+        expected = {
+            "trace_debug_layer": BIT(2),
+            "trace_debug_level": BIT(2),
+            "trace_state": "enable",
+        }
+        self._write_expected(expected)
+        logging.debug("Enabled ACPI debugging for ACPI_LV_INFO/ACPI_EVENTS")
+        return True
+
+    def trace_bios(self):
+        """Trace BIOS events"""
+        if not self.supported:
+            return False
+        if not search_acpi_tables(ACPI_METHOD):
+            logging.debug(
+                "will not work on this system: ACPI tables do not contain %s",
+                ACPI_METHOD,
+            )
+            return False
+        expected = {
+            "trace_debug_layer": BIT(7),
+            "trace_debug_level": BIT(4),
+            "trace_method_name": f"\\{ACPI_METHOD}",
+            "trace_state": "method",
+        }
+        self._write_expected(expected)
+        logging.debug("Enabled ACPI debugging for BIOS")
+        return True
+
+    def disable(self):
+        """Disable ACPI tracing"""
+        if not self.supported:
+            return False
+        expected = {
+            "trace_state": "disable",
+        }
+        self._write_expected(expected)
+        return True
+
+    def restore(self):
+        """Restore original ACPI tracing settings"""
+        if not self.supported:
+            return False
+        self._write_expected(self.original)
+        return True

amd_debug/bash/amd-s2idle

@@ -0,0 +1,89 @@
+_cmd_list=(
+	'install'
+	'uninstall'
+	'test'
+	'report'
+	'version'
+)
+
+_general_opts=(
+)
+
+_report_opts=(
+	'--since'
+	'--until'
+	'--report-file'
+	'--format'
+	'--report-debug'
+)
+
+_test_opts=(
+	'--wait'
+	'--count'
+	'--duration'
+	'--report-file'
+	'--format'
+	'--force'
+	'--logind'
+	'--tool-debug'
+	'--report-debug'
+)
+
+_format_opts=(
+	'md'
+	'html'
+	'txt'
+)
+
+_show_test_opts()
+{
+	COMPREPLY+=( $(compgen -W '${_test_opts[@]}' -- "$cur") )
+}
+
+_show_report_opts()
+{
+	COMPREPLY+=( $(compgen -W '${_report_opts[@]}' -- "$cur") )
+}
+
+_show_format_completion()
+{
+	COMPREPLY+=( $(compgen -W '${_format_opts[@]}' -- "$cur") )
+}
+
+_amd_s2idle()
+{
+	local cur prev command arg args
+	COMPREPLY=()
+	_get_comp_words_by_ref cur prev
+	_get_first_arg
+	_count_args
+
+	case $prev in
+	--log|--duration|--count|--wait|--since|--report-file)
+		return 0
+		;;
+	--format)
+		_show_format_completion
+		return 0
+		;;
+	esac
+	case $arg in
+	test)
+		_show_test_opts
+		;;
+	report)
+		_show_report_opts
+		;;
+
+	*)
+		#find first command
+		if [[ "$args" = "1" ]]; then
+			COMPREPLY=( $(compgen -W '${_cmd_list[@]}' -- "$cur") )
+		fi
+		;;
+	esac
+
+	return 0
+}
+
+complete -F _amd_s2idle amd-s2idle

amd_debug/battery.py

@@ -0,0 +1,87 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+from pyudev import Context
+
+
+def _get_property(prop, key, fallback="") -> str:
+    """Get the property from the given key"""
+    try:
+        return prop.get(key, fallback)
+    except UnicodeDecodeError:
+        return ""
+
+
+class Batteries:
+    def __init__(self) -> None:
+        self.pyudev = Context()
+
+    def _get_battery(self, name) -> object:
+        """Get the battery device object for the given name"""
+        for dev in self.pyudev.list_devices(
+            subsystem="power_supply", POWER_SUPPLY_TYPE="Battery"
+        ):
+            if not "PNP0C0A" in dev.device_path:
+                continue
+            desc = _get_property(dev.properties, "POWER_SUPPLY_NAME", "Unknown")
+            if desc != name:
+                continue
+            return dev
+        return None
+
+    def get_batteries(self) -> list:
+        """Get a list of battery names on the system"""
+        names = []
+        for dev in self.pyudev.list_devices(
+            subsystem="power_supply", POWER_SUPPLY_TYPE="Battery"
+        ):
+            if not "PNP0C0A" in dev.device_path:
+                continue
+            names.append(_get_property(dev.properties, "POWER_SUPPLY_NAME", "Unknown"))
+        return names
+
+    def get_energy_unit(self, name) -> str:
+        """Get the energy unit for the given battery name"""
+        dev = self._get_battery(name)
+        if not dev:
+            return ""
+        energy = _get_property(dev.properties, "POWER_SUPPLY_ENERGY_NOW")
+        if energy:
+            return "µWh"
+        return "µAh"
+
+    def get_energy(self, name) -> int:
+        """Get the current energy for the given battery name"""
+        dev = self._get_battery(name)
+        if not dev:
+            return ""
+        energy = _get_property(dev.properties, "POWER_SUPPLY_ENERGY_NOW")
+        if not energy:
+            energy = _get_property(dev.properties, "POWER_SUPPLY_CHARGE_NOW")
+        return energy
+
+    def get_energy_full(self, name) -> int:
+        """Get the energy when full for the given battery name"""
+        dev = self._get_battery(name)
+        if not dev:
+            return ""
+        energy = _get_property(dev.properties, "POWER_SUPPLY_ENERGY_FULL")
+        if not energy:
+            energy = _get_property(dev.properties, "POWER_SUPPLY_CHARGE_FULL")
+        return energy
+
+    def get_description_string(self, name) -> str:
+        """Get a description string for the given battery name"""
+        dev = self._get_battery(name)
+        if not dev:
+            return ""
+        man = _get_property(dev.properties, "POWER_SUPPLY_MANUFACTURER", "")
+        model = _get_property(dev.properties, "POWER_SUPPLY_MODEL_NAME", "")
+        full = self.get_energy_full(name)
+        full_design = _get_property(dev.properties, "POWER_SUPPLY_ENERGY_FULL_DESIGN")
+        if not full_design:
+            full_design = _get_property(
+                dev.properties, "POWER_SUPPLY_CHARGE_FULL_DESIGN"
+            )
+
+        percent = float(full) / int(full_design)
+        return f"Battery {name} ({man} {model}) is operating at {percent:.2%} of design"

amd_debug/bios.py

@@ -0,0 +1,138 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+"""s2idle analysis tool"""
+import argparse
+import re
+import sys
+from amd_debug.common import (
+    AmdTool,
+    fatal_error,
+    get_log_priority,
+    minimum_kernel,
+    print_color,
+    relaunch_sudo,
+    show_log_info,
+    version,
+)
+from amd_debug.kernel import get_kernel_log, sscanf_bios_args
+from amd_debug.acpi import AcpicaTracer
+
+
+class AmdBios(AmdTool):
+    """
+    AmdBios is a class which fetches the BIOS events from kernel logs.
+    """
+
+    def __init__(self, inf, debug):
+        log_prefix = "bios" if debug else None
+        super().__init__(log_prefix)
+        self.kernel_log = get_kernel_log(inf)
+
+    def set_tracing(self, enable):
+        """Run the action"""
+        relaunch_sudo()
+
+        if not minimum_kernel(6, 16):
+            print_color(
+                "Support for BIOS debug logging was merged in mainline 6.16, "
+                "this tool may not work correctly unless support is manually "
+                "backported",
+                "🚦",
+            )
+
+        tracer = AcpicaTracer()
+        ret = tracer.trace_bios() if enable else tracer.disable()
+        if ret:
+            action = "enabled" if enable else "disabled"
+            print_color(f"Set BIOS tracing to {action}", "✅")
+        else:
+            fatal_error(
+                "BIOS tracing not supported, please check your kernel for CONFIG_ACPI_DEBUG"
+            )
+
+        return True
+
+    def _analyze_kernel_log_line(self, line, priority):
+        """Analyze a line from the kernel log"""
+        bios_args = sscanf_bios_args(line)
+        if bios_args:
+            if isinstance(bios_args, str):
+                print_color(bios_args, "🖴")
+            else:
+                return
+        else:
+            # strip timestamp
+            t = re.sub(r"^\[\s*\d+\.\d+\]", "", line).strip()
+            print_color(t, get_log_priority(priority))
+
+    def run(self):
+        """Exfiltrate from the kernel log"""
+        self.kernel_log.process_callback(self._analyze_kernel_log_line)
+        return True
+
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(
+        description="Parse a combined kernel/BIOS log.",
+    )
+    subparsers = parser.add_subparsers(help="Possible commands", dest="command")
+    parse_cmd = subparsers.add_parser(
+        "parse", help="Parse log for kernel and BIOS messages"
+    )
+    parse_cmd.add_argument(
+        "--input",
+        help="Optional input file to parse",
+    )
+    parse_cmd.add_argument(
+        "--tool-debug",
+        action="store_true",
+        help="Enable tool debug logging",
+    )
+    trace_cmd = subparsers.add_parser("trace", help="Enable or disable tracing")
+    trace_cmd.add_argument(
+        "--enable",
+        action="store_true",
+        help="Enable BIOS AML tracing",
+    )
+    trace_cmd.add_argument(
+        "--disable",
+        action="store_true",
+        help="Disable BIOS AML tracing",
+    )
+    trace_cmd.add_argument(
+        "--tool-debug",
+        action="store_true",
+        help="Enable tool debug logging",
+    )
+    subparsers.add_parser("version", help="Show version information")
+
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    args = parser.parse_args()
+
+    if args.command == "trace":
+        if args.enable and args.disable:
+            sys.exit("can't set both enable and disable")
+        if not args.enable and not args.disable:
+            sys.exit("must set either enable or disable")
+
+    return args
+
+
+def main():
+    """Main function"""
+    args = parse_args()
+    ret = False
+    if args.command == "trace":
+        app = AmdBios(None, args.tool_debug)
+        ret = app.set_tracing(True if args.enable else False)
+    elif args.command == "parse":
+        app = AmdBios(args.input, args.tool_debug)
+        ret = app.run()
+    elif args.command == "version":
+        print(version())
+    show_log_info()
+    return ret