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

amd_debug/common.py

@@ -0,0 +1,324 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains common utility functions and classes for various amd-debug-tools.
+"""
+
+import importlib.metadata
+import logging
+import os
+import platform
+import time
+import struct
+import subprocess
+import re
+import sys
+from datetime import date, timedelta
+
+
+class Colors:
+    """Colors for the terminal"""
+
+    DEBUG = "\033[90m"
+    HEADER = "\033[95m"
+    OK = "\033[94m"
+    WARNING = "\033[32m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    UNDERLINE = "\033[4m"
+
+
+def read_file(fn) -> str:
+    """Read a file and return the contents"""
+    with open(fn, "r", encoding="utf-8") as r:
+        return r.read().strip()
+
+
+def compare_file(fn, expect) -> bool:
+    """Compare a file to an expected string"""
+    return read_file(fn) == expect
+
+
+def get_group_color(group) -> str:
+    """Get the color for a group"""
+    if group == "🚦":
+        color = Colors.WARNING
+    elif group == "🗣️":
+        color = Colors.HEADER
+    elif group == "💯":
+        color = Colors.UNDERLINE
+    elif any(mk in group for mk in ["🦟", "🖴"]):
+        color = Colors.DEBUG
+    elif any(mk in group for mk in ["❌", "👀"]):
+        color = Colors.FAIL
+    elif any(mk in group for mk in ["✅", "🔋", "🐧", "💻", "○", "💤", "🥱"]):
+        color = Colors.OK
+    else:
+        color = group
+    return color
+
+
+def print_color(message, group) -> None:
+    """Print a message with a color"""
+    prefix = f"{group} "
+    suffix = Colors.ENDC
+    color = get_group_color(group)
+    if color == group:
+        prefix = ""
+    log_txt = f"{prefix}{message}".strip()
+    if any(c in color for c in [Colors.OK, Colors.HEADER, Colors.UNDERLINE]):
+        logging.info(log_txt)
+    elif color == Colors.WARNING:
+        logging.warning(log_txt)
+    elif color == Colors.FAIL:
+        logging.error(log_txt)
+    else:
+        logging.debug(log_txt)
+    if "TERM" in os.environ and os.environ["TERM"] == "dumb":
+        suffix = ""
+        color = ""
+    print(f"{prefix}{color}{message}{suffix}")
+
+
+def fatal_error(message):
+    """Prints a fatal error message and exits"""
+    _configure_log(None)
+    print_color(message, "👀")
+    sys.exit(1)
+
+
+def show_log_info():
+    """Show log information"""
+    logger = logging.getLogger()
+    for handler in logger.handlers:
+        if isinstance(handler, logging.FileHandler):
+            filename = handler.baseFilename
+            if filename != "/dev/null":
+                print(f"Debug logs are saved to: {filename}")
+
+
+def _configure_log(prefix) -> str:
+    """Configure logging for the tool"""
+    if len(logging.root.handlers) > 0:
+        return
+
+    if prefix:
+        user = os.environ.get("SUDO_USER")
+        home = os.path.expanduser(f"~{user if user else ''}")
+        path = os.environ.get("XDG_DATA_HOME") or os.path.join(
+            home, ".local", "share", "amd-debug-tools"
+        )
+        os.makedirs(path, exist_ok=True)
+        log = os.path.join(
+            path,
+            f"{prefix}-{date.today()}.txt",
+        )
+        if not os.path.exists(log):
+            with open(log, "w", encoding="utf-8") as f:
+                f.write("")
+            if "SUDO_UID" in os.environ:
+                os.chown(path, int(os.environ["SUDO_UID"]), int(os.environ["SUDO_GID"]))
+                os.chown(log, int(os.environ["SUDO_UID"]), int(os.environ["SUDO_GID"]))
+        level = logging.DEBUG
+    else:
+        log = "/dev/null"
+        level = logging.WARNING
+    # for saving a log file for analysis
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)s:\t%(message)s",
+        filename=log,
+        level=level,
+    )
+    return log
+
+
+def check_lockdown():
+    """Check if the system is in lockdown"""
+    fn = os.path.join("/", "sys", "kernel", "security", "lockdown")
+    if not os.path.exists(fn):
+        return False
+    lockdown = read_file(fn)
+    if lockdown.split()[0] != "[none]":
+        return lockdown
+    return False
+
+
+def print_temporary_message(msg) -> int:
+    """Print a temporary message to the console"""
+    print(msg, end="\r", flush=True)
+    return len(msg)
+
+
+def clear_temporary_message(msg_len) -> None:
+    """Clear a temporary message from the console"""
+    print(" " * msg_len, end="\r")
+
+
+def run_countdown(action, t) -> bool:
+    """Run a countdown timer"""
+    msg = ""
+    if t < 0:
+        return False
+    if t == 0:
+        return True
+    while t > 0:
+        msg = f"{action} in {timedelta(seconds=t)}"
+        print_temporary_message(msg)
+        time.sleep(1)
+        t -= 1
+    clear_temporary_message(len(msg))
+    return True
+
+
+def get_distro() -> str:
+    """Get the distribution name"""
+    distro = "unknown"
+    if os.path.exists("/etc/os-release"):
+        with open("/etc/os-release", "r", encoding="utf-8") as f:
+            for line in f:
+                if line.startswith("ID="):
+                    return line.split("=")[1].strip().strip('"')
+    if os.path.exists("/etc/arch-release"):
+        return "arch"
+    elif os.path.exists("/etc/fedora-release"):
+        return "fedora"
+    elif os.path.exists("/etc/debian_version"):
+        return "debian"
+
+    return distro
+
+
+def get_pretty_distro() -> str:
+    """Get the pretty distribution name"""
+    distro = "Unknown"
+    if os.path.exists("/etc/os-release"):
+        with open("/etc/os-release", "r", encoding="utf-8") as f:
+            for line in f:
+                if line.startswith("PRETTY_NAME="):
+                    distro = line.split("=")[1].strip().strip('"')
+                    break
+    return distro
+
+
+def is_root() -> bool:
+    """Check if the user is root"""
+    return os.geteuid() == 0
+
+
+def BIT(num):  # pylint: disable=invalid-name
+    """Return a bit shifted value"""
+    return 1 << num
+
+
+def get_log_priority(num):
+    """Maps an integer debug level to a priority type"""
+    if num:
+        try:
+            num = int(num)
+        except ValueError:
+            return num
+        if num == 7:
+            return "🦟"
+        elif num == 4:
+            return "🚦"
+        elif num <= 3:
+            return "❌"
+    return "○"
+
+
+def minimum_kernel(major, minor) -> bool:
+    """Checks if the kernel version is at least major.minor"""
+    ver = platform.uname().release.split(".")
+    kmajor = int(ver[0])
+    kminor = int(ver[1])
+    if kmajor > int(major):
+        return True
+    if kmajor < int(major):
+        return False
+    return kminor >= int(minor)
+
+
+def systemd_in_use() -> bool:
+    """Check if systemd is in use"""
+    # Check if /proc/1/comm exists and read its contents
+    init_daemon = read_file("/proc/1/comm")
+    return init_daemon == "systemd"
+
+
+def get_property_pyudev(properties, key, fallback=""):
+    """Get a property from a udev device"""
+    try:
+        return properties.get(key, fallback)
+    except UnicodeDecodeError:
+        return ""
+
+
+def read_msr(msr, cpu):
+    """Read a Model-Specific Register (MSR) value from the CPU."""
+    p = f"/dev/cpu/{cpu}/msr"
+    if not os.path.exists(p) and is_root():
+        os.system("modprobe msr")
+    try:
+        f = os.open(p, os.O_RDONLY)
+    except OSError as exc:
+        raise PermissionError from exc
+    try:
+        os.lseek(f, msr, os.SEEK_SET)
+        val = struct.unpack("Q", os.read(f, 8))[0]
+    except OSError as exc:
+        raise PermissionError from exc
+    finally:
+        os.close(f)
+    return val
+
+
+def relaunch_sudo() -> None:
+    """Relaunch the script with sudo if not already running as root"""
+    if not is_root():
+        logging.debug("Relaunching with sudo")
+        os.execvp("sudo", ["sudo", "-E"] + sys.argv)
+
+
+def running_ssh():
+    return "SSH_CLIENT" in os.environ or "SSH_TTY" in os.environ
+
+
+def _git_describe() -> str:
+    """Get the git description of the current commit"""
+    try:
+        result = subprocess.check_output(
+            ["git", "log", "-1", '--format=commit %h ("%s")'],
+            cwd=os.path.dirname(__file__),
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return result.strip()
+    except subprocess.CalledProcessError:
+        return None
+    except FileNotFoundError:
+        return None
+
+
+def version() -> str:
+    """Get version of the tool"""
+    ver = "unknown"
+    try:
+        ver = importlib.metadata.version("amd-debug-tools")
+    except importlib.metadata.PackageNotFoundError:
+        pass
+    describe = _git_describe()
+    if describe:
+        ver = f"{ver} [{describe}]"
+    return ver
+
+
+class AmdTool:
+    """Base class for AMD tools"""
+
+    def __init__(self, prefix):
+        self.log = _configure_log(prefix)
+        logging.debug("command: %s (module: %s)", sys.argv, type(self).__name__)
+        logging.debug("Version: %s", version())
+        if os.uname().sysname != "Linux":
+            raise RuntimeError("This tool only runs on Linux")

amd_debug/database.py

@@ -0,0 +1,331 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+from datetime import datetime
+import sqlite3
+import os
+
+from amd_debug.common import read_file
+
+SCHEMA_VERSION = 1
+
+
+def migrate(cur, user_version) -> None:
+    """Migrate sqlite database schema"""
+    cur.execute("PRAGMA user_version")
+    val = cur.fetchone()[0]
+    # Schema 1
+    # - add priority column
+    if val == 0:
+        cur.execute("ALTER TABLE debug ADD COLUMN priority INTEGER")
+    # Update schema if necessary
+    if val != user_version:
+        cur.execute(f"PRAGMA user_version = {user_version}")
+
+
+class SleepDatabase:
+    """Database class to store sleep cycle data"""
+
+    def __init__(self, dbf=None) -> None:
+        self.db = None
+        self.last_suspend = None
+        self.cycle_data_cnt = 0
+        self.debug_cnt = 0
+
+        if not dbf:
+            # if we were packaged we would have a directory in /var/lib
+            path = os.path.join("/", "var", "lib", "amd-s2idle")
+            if not os.path.exists(path):
+                path = os.path.join("/", "var", "local", "lib", "amd-s2idle")
+            os.makedirs(path, exist_ok=True)
+
+            dbf = os.path.join(path, "data.db")
+        new = not os.path.exists(dbf)
+        self.db = sqlite3.connect(dbf)
+        cur = self.db.cursor()
+        cur.execute(
+            "CREATE TABLE IF NOT EXISTS prereq_data ("
+            "t0 INTEGER,"
+            "id INTEGER,"
+            "message TEXT,"
+            "symbol TEXT,"
+            "PRIMARY KEY(t0, id))"
+        )
+        cur.execute(
+            "CREATE TABLE IF NOT EXISTS debug ("
+            "t0 INTEGER,"
+            "id INTEGER,"
+            "message TEXT,"
+            "priority INTEGER,"
+            "PRIMARY KEY(t0, id))"
+        )
+        cur.execute(
+            "CREATE TABLE IF NOT EXISTS cycle ("
+            "t0 INTEGER PRIMARY KEY,"
+            "t1 INTEGER,"
+            "requested INTEGER,"
+            "gpio TEXT,"
+            "wake_irq TEXT,"
+            "kernel REAL,"
+            "hw REAL)"
+        )
+        cur.execute(
+            "CREATE TABLE IF NOT EXISTS cycle_data ("
+            "t0 INTEGER,"
+            "id INTEGER,"
+            "message TEXT,"
+            "symbol TEXT,"
+            "PRIMARY KEY(t0, id))"
+        )
+        cur.execute(
+            "CREATE TABLE IF NOT EXISTS battery ("
+            "t0 INTEGER PRIMARY KEY,"
+            "name TEXT,"
+            "b0 INTEGER,"
+            "b1 INTEGER,"
+            "full INTEGER,"
+            "unit TEXT)"
+        )
+        self.prereq_data_cnt = 0
+
+        if new:
+            cur.execute(f"PRAGMA user_version = {SCHEMA_VERSION}")
+        else:
+            migrate(cur, SCHEMA_VERSION)
+
+    def __del__(self) -> None:
+        if self.db:
+            self.db.close()
+
+    def start_cycle(self, timestamp):
+        """Start a new sleep cycle"""
+        self.last_suspend = timestamp
+
+        # increment the counters so that systemd hooks work
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT MAX(id) FROM cycle_data WHERE t0=?",
+            (int(self.last_suspend.strftime("%Y%m%d%H%M%S")),),
+        )
+        val = cur.fetchone()[0]
+        if val is not None:
+            self.cycle_data_cnt = val + 1
+        else:
+            self.cycle_data_cnt = 0
+        cur.execute(
+            "SELECT MAX(id) FROM debug WHERE t0=?",
+            (int(self.last_suspend.strftime("%Y%m%d%H%M%S")),),
+        )
+        val = cur.fetchone()[0]
+        if val is not None:
+            self.debug_cnt = val + 1
+        else:
+            self.debug_cnt = 0
+
+    def sync(self) -> None:
+        """Sync the database to disk"""
+        self.db.commit()
+
+    def record_debug(self, message, level=6) -> None:
+        """Helper function to record a message to debug database"""
+        assert self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            "INSERT into debug (t0, id, message, priority) VALUES (?, ?, ?, ?)",
+            (
+                int(self.last_suspend.strftime("%Y%m%d%H%M%S")),
+                self.debug_cnt,
+                message,
+                level,
+            ),
+        )
+        self.debug_cnt += 1
+
+    def record_debug_file(self, fn):
+        """Helper function to record the entire contents of a file to debug database"""
+        try:
+            contents = read_file(fn)
+            self.record_debug(contents)
+        except PermissionError:
+            self.record_debug(f"Unable to capture {fn}")
+
+    def record_battery_energy(self, name, energy, full, unit):
+        """Helper function to record battery energy"""
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT * FROM battery WHERE t0=?",
+            (int(self.last_suspend.strftime("%Y%m%d%H%M%S")),),
+        )
+        if cur.fetchone():
+            cur.execute(
+                "UPDATE battery SET b1=? WHERE t0=?",
+                (energy, int(self.last_suspend.strftime("%Y%m%d%H%M%S"))),
+            )
+        else:
+            cur.execute(
+                """
+                INSERT into battery (t0, name, b0, b1, full, unit) 
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    int(self.last_suspend.strftime("%Y%m%d%H%M%S")),
+                    name,
+                    energy,
+                    None,
+                    full,
+                    unit,
+                ),
+            )
+
+    def record_cycle_data(self, message, symbol) -> None:
+        """Helper function to record a message to cycle_data database"""
+        assert self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            """
+            INSERT into cycle_data (t0, id, message, symbol)
+            VALUES (?, ?, ?, ?)
+            """,
+            (
+                (
+                    int(self.last_suspend.strftime("%Y%m%d%H%M%S")),
+                    self.cycle_data_cnt,
+                    message,
+                    symbol,
+                )
+            ),
+        )
+        self.cycle_data_cnt += 1
+
+    def record_cycle(
+        self,
+        requested_duration=0,
+        active_gpios="",
+        wakeup_irqs="",
+        kernel_duration=0,
+        hw_sleep_duration=0,
+    ) -> None:
+        """Helper function to record a sleep cycle into the cycle database"""
+        assert self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            """
+            REPLACE INTO cycle (t0, t1, requested, gpio, wake_irq, kernel, hw)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                int(self.last_suspend.strftime("%Y%m%d%H%M%S")),
+                int(datetime.now().strftime("%Y%m%d%H%M%S")),
+                requested_duration,
+                str(active_gpios) if active_gpios else "",
+                str(wakeup_irqs),
+                kernel_duration,
+                hw_sleep_duration,
+            ),
+        )
+
+    def record_prereq(self, message, symbol) -> None:
+        """Helper function to record a message to prereq_data database"""
+        assert self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            """
+            INSERT into prereq_data (t0, id, message, symbol)
+            VALUES (?, ?, ?, ?)
+            """,
+            (
+                (
+                    int(self.last_suspend.strftime("%Y%m%d%H%M%S")),
+                    self.prereq_data_cnt,
+                    message,
+                    symbol,
+                )
+            ),
+        )
+        self.prereq_data_cnt += 1
+
+    def report_prereq(self, t0) -> list:
+        """Helper function to report the prereq_data database"""
+        if t0 is None:
+            return []
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT * FROM prereq_data WHERE t0=?",
+            (int(t0.strftime("%Y%m%d%H%M%S")),),
+        )
+        return cur.fetchall()
+
+    def report_debug(self, t0) -> str:
+        """Helper function to report the debug database"""
+        if t0 is None:
+            return ""
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT message, priority FROM debug WHERE t0=?",
+            (int(t0.strftime("%Y%m%d%H%M%S")),),
+        )
+        return cur.fetchall()
+
+    def report_cycle(self, t0=None) -> list:
+        """Helper function to report a cycle from database"""
+        if t0 is None:
+            assert self.last_suspend
+            t0 = self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT * FROM cycle WHERE t0=?",
+            (int(t0.strftime("%Y%m%d%H%M%S")),),
+        )
+        return cur.fetchall()
+
+    def report_cycle_data(self, t0=None) -> str:
+        """Helper function to report a table matching a timestamp from cycle_data database"""
+        if t0 is None:
+            t0 = self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT message, symbol FROM cycle_data WHERE t0=? ORDER BY symbol",
+            (int(t0.strftime("%Y%m%d%H%M%S")),),
+        )
+        data = ""
+        for row in cur.fetchall():
+            data += f"{row[1]} {row[0]}\n"
+        return data
+
+    def report_battery(self, t0=None) -> list:
+        """Helper function to report a line from battery database"""
+        if t0 is None:
+            t0 = self.last_suspend
+        cur = self.db.cursor()
+        cur.execute(
+            "SELECT * FROM battery WHERE t0=?",
+            (int(t0.strftime("%Y%m%d%H%M%S")),),
+        )
+        return cur.fetchall()
+
+    def get_last_prereq_ts(self) -> int:
+        """Helper function to report the last line from prereq database"""
+        cur = self.db.cursor()
+        cur.execute("SELECT * FROM prereq_data ORDER BY t0 DESC LIMIT 1")
+        result = cur.fetchone()
+        return result[0] if result else None
+
+    def get_last_cycle(self) -> list:
+        """Helper function to report the last line from battery database"""
+        cur = self.db.cursor()
+        cur.execute("SELECT t0 FROM cycle ORDER BY t0 DESC LIMIT 1")
+        return cur.fetchone()
+
+    def report_summary_dataframe(self, since, until) -> object:
+        """Helper function to report a dataframe from the database"""
+        import pandas as pd  # pylint: disable=import-outside-toplevel
+
+        pd.set_option("display.precision", 2)
+        return pd.read_sql_query(
+            sql="SELECT cycle.t0, cycle.t1, hw, requested, gpio, wake_irq, b0, b1, full FROM cycle LEFT JOIN battery ON cycle.t0 = battery.t0 WHERE cycle.t0 >= ? and cycle.t0 <= ?",
+            con=self.db,
+            params=(
+                int(since.strftime("%Y%m%d%H%M%S")),
+                int(until.strftime("%Y%m%d%H%M%S")),
+            ),
+        )