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

amd_debug/__init__.py

@@ -23,8 +23,15 @@ def amd_pstate():
     return pstate.main()
 
 
+def amd_ttm():
+    """Launch the amd-ttm tool."""
+    from . import ttm  # pylint: disable=import-outside-toplevel
+
+    return ttm.main()
+
+
 def install_dep_superset():
-    """Install all supserset dependencies."""
+    """Install all superset dependencies."""
     from . import installer  # pylint: disable=import-outside-toplevel
 
     return installer.install_dep_superset()
@@ -36,6 +43,7 @@ def launch_tool(tool_name):
         "amd_s2idle.py": amd_s2idle,
         "amd_bios.py": amd_bios,
         "amd_pstate.py": amd_pstate,
+        "amd_ttm.py": amd_ttm,
         "install_deps.py": install_dep_superset,
     }
     if tool_name in tools:

amd_debug/bios.py

@@ -105,7 +105,9 @@ 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)
@@ -122,7 +124,7 @@ def parse_args():
     return args
 
 
-def main() -> None|int:
+def main() -> None | int:
     """Main function"""
     args = parse_args()
     ret = False
@@ -132,7 +134,7 @@ def main() -> None|int:
     elif args.command == "parse":
         app = AmdBios(args.input, args.tool_debug)
         ret = app.run()
-    elif args.command == "version":
+    elif args.version:
         print(version())
     show_log_info()
     if ret is False:

amd_debug/common.py

@@ -226,6 +226,45 @@ def get_pretty_distro() -> str:
     return distro
 
 
+def bytes_to_gb(bytes_value):
+    """Convert bytes to GB"""
+    return bytes_value * 4096 / (1024 * 1024 * 1024)
+
+
+def gb_to_pages(gb_value):
+    """Convert GB into bytes"""
+    return int(gb_value * (1024 * 1024 * 1024) / 4096)
+
+
+def reboot():
+    """Reboot the system"""
+    try:
+        import dbus  # pylint: disable=import-outside-toplevel
+
+        bus = dbus.SystemBus()
+        obj = bus.get_object("org.freedesktop.login1", "/org/freedesktop/login1")
+        intf = dbus.Interface(obj, "org.freedesktop.login1.Manager")
+        intf.Reboot(True)
+        return True
+    except ImportError:
+        fatal_error("Missing dbus")
+    except dbus.exceptions.DBusException as e:
+        fatal_error({e})
+    return True
+
+
+def get_system_mem():
+    """Get the total system memory in GB using /proc/meminfo"""
+    with open(os.path.join("/", "proc", "meminfo"), "r", encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("MemTotal:"):
+                # MemTotal line format: "MemTotal:       16384516 kB"
+                # Extract the number and convert from kB to GB
+                mem_kb = int(line.split()[1])
+                return mem_kb / (1024 * 1024)
+    raise ValueError("Could not find MemTotal in /proc/meminfo")
+
+
 def is_root() -> bool:
     """Check if the user is root"""
     return os.geteuid() == 0

amd_debug/installer.py

@@ -446,8 +446,8 @@ def parse_args():
     return parser.parse_args()
 
 
-def install_dep_superset() -> None|int:
-    """Install all python supserset dependencies"""
+def install_dep_superset() -> None | int:
+    """Install all python superset dependencies"""
     args = parse_args()
     tool = Installer(tool_debug=args.tool_debug)
     tool.set_requirements(

amd_debug/prerequisites.py

@@ -128,6 +128,28 @@ 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()
@@ -1227,9 +1249,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 +1265,7 @@ class PrerequisiteValidator(AmdTool):
             self.capture_logind,
             self.capture_pci_acpi,
             self.capture_edid,
+            self.capture_nvidia,
         ]
         checks = []
 

amd_debug/pstate.py

@@ -293,18 +293,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

@@ -385,7 +385,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 +396,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 +429,7 @@ def main() -> None|int:
             args.logind,
             args.bios_debug,
         )
-    elif args.action == "version":
+    elif args.version:
         print(version())
         return
     else:

amd_debug/test_ttm.py

@@ -0,0 +1,291 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the ttm tool in the amd-debug-tools package.
+"""
+import unittest
+import sys
+import logging
+from unittest import mock
+
+from amd_debug.ttm import main, parse_args, AmdTtmTool, maybe_reboot
+
+
+class TestParseArgs(unittest.TestCase):
+    """Test parse_args function"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def setUp(self):
+        self.default_sys_argv = sys.argv
+
+    def tearDown(self):
+        sys.argv = self.default_sys_argv
+
+    @mock.patch.object(sys, "argv", new=["ttm", "--version"])
+    def test_parse_args_version(self):
+        """Test version argument"""
+        args = parse_args()
+        self.assertTrue(args.version)
+        self.assertFalse(args.set)
+        self.assertFalse(args.clear)
+
+    @mock.patch.object(sys, "argv", new=["ttm", "--clear"])
+    def test_parse_args_clear(self):
+        """Test clear argument"""
+        args = parse_args()
+        self.assertFalse(args.version)
+        self.assertFalse(args.set)
+        self.assertTrue(args.clear)
+
+
+class TestMainFunction(unittest.TestCase):
+    """Test main() function logic"""
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.version", return_value="1.2.3")
+    @mock.patch("builtins.print")
+    def test_main_version(self, mock_print, _mock_version, mock_parse_args):
+        """Test main function with version argument"""
+        mock_parse_args.return_value = mock.Mock(
+            version=True, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        mock_print.assert_called_with("1.2.3")
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    @mock.patch("builtins.print")
+    def test_main_set_invalid(self, mock_print, _mock_tool, mock_parse_args):
+        """Test main function with invalid set argument"""
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=0, clear=False, tool_debug=False
+        )
+        ret = main()
+        mock_print.assert_called_with("Error: GB value must be greater than 0")
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_set_valid(self, mock_tool, mock_parse_args):
+        """Test main function with set argument"""
+        instance = mock_tool.return_value
+        instance.set.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=2, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.set.assert_called_with(2)
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_set_failed(self, mock_tool, mock_parse_args):
+        instance = mock_tool.return_value
+        instance.set.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=2, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.set.assert_called_with(2)
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_clear_success(self, mock_tool, mock_parse_args):
+        """Test main function with clear argument"""
+        instance = mock_tool.return_value
+        instance.clear.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=True, tool_debug=False
+        )
+        ret = main()
+        instance.clear.assert_called_once()
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_clear_failed(self, mock_tool, mock_parse_args):
+        """Test main function with clear argument failure"""
+        instance = mock_tool.return_value
+        instance.clear.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=True, tool_debug=False
+        )
+        ret = main()
+        instance.clear.assert_called_once()
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_get_success(self, mock_tool, mock_parse_args):
+        """Test main function with get argument"""
+        instance = mock_tool.return_value
+        instance.get.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.get.assert_called_once()
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_get_failed(self, mock_tool, mock_parse_args):
+        """Test main function with get argument failure"""
+        instance = mock_tool.return_value
+        instance.get.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.get.assert_called_once()
+        self.assertEqual(ret, 1)
+
+
+class TestMaybeReboot(unittest.TestCase):
+    """Test maybe_reboot function"""
+
+    @mock.patch("builtins.input", return_value="y")
+    @mock.patch("amd_debug.ttm.reboot", return_value=True)
+    def test_maybe_reboot_yes(self, mock_reboot, _mock_input):
+        """Test reboot confirmation and execution"""
+        result = maybe_reboot()
+        mock_reboot.assert_called_once()
+        self.assertTrue(result)
+
+    @mock.patch("builtins.input", return_value="n")
+    @mock.patch("amd_debug.ttm.reboot", return_value=True)
+    def test_maybe_reboot_no(self, mock_reboot, _mock_input):
+        """Test reboot confirmation without execution"""
+        result = maybe_reboot()
+        mock_reboot.assert_not_called()
+        self.assertTrue(result)
+
+
+class TestAmdTtmTool(unittest.TestCase):
+    """Unit tests for AmdTtmTool class"""
+
+    def setUp(self):
+        self.tool = AmdTtmTool(logging=False)
+
+    @mock.patch("builtins.open", new_callable=mock.mock_open, read_data="4096")
+    @mock.patch("amd_debug.ttm.bytes_to_gb", return_value=4.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=16.0)
+    def test_get_success(self, _mock_mem, mock_print, _mock_bytes_to_gb, mock_open):
+        """Test get() when TTM_PARAM_PATH exists"""
+        result = self.tool.get()
+        mock_open.assert_called_once_with(
+            "/sys/module/ttm/parameters/pages_limit", "r", encoding="utf-8"
+        )
+        mock_print.assert_any_call(
+            "Current TTM pages limit: 4096 pages (4.00 GB)", "💻"
+        )
+        mock_print.assert_any_call("Total system memory: 16.00 GB", "💻")
+        self.assertTrue(result)
+
+    @mock.patch("builtins.open", side_effect=FileNotFoundError)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_get_file_not_found(self, mock_print, _mock_open):
+        """Test get() when TTM_PARAM_PATH does not exist"""
+        result = self.tool.get()
+        mock_print.assert_called_with(
+            "Error: Could not find /sys/module/ttm/parameters/pages_limit", "❌"
+        )
+        self.assertFalse(result)
+
+    @mock.patch("amd_debug.ttm.is_root", return_value=False)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_set_not_root(self, mock_print, _mock_is_root):
+        """Test set() when not root"""
+        result = self.tool.set(2)
+        mock_print.assert_called_with("Root privileges required", "❌")
+        self.assertFalse(result)
+
+    @mock.patch("amd_debug.ttm.is_root", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=8.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_set_gb_greater_than_total(self, mock_print, _mock_mem, _mock_is_root):
+        """Test set() when gb_value > total system memory"""
+        result = self.tool.set(16)
+        mock_print.assert_any_call(
+            "16.00 GB is greater than total system memory (8.00 GB)", "❌"
+        )
+        self.assertFalse(result)
+
+    @mock.patch("amd_debug.ttm.is_root", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=10.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("builtins.input", return_value="n")
+    def test_set_gb_exceeds_max_percentage_cancel(
+        self, _mock_input, mock_print, _mock_mem, mock_is_root
+    ):
+        """Test set() when gb_value exceeds max percentage and user cancels"""
+        result = self.tool.set(9.5)
+        self.assertFalse(result)
+        mock_print.assert_any_call("Operation cancelled.", "🚦")
+
+    @mock.patch("amd_debug.ttm.is_root", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=10.0)
+    @mock.patch("amd_debug.ttm.gb_to_pages", return_value=20480)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("builtins.open", new_callable=mock.mock_open)
+    @mock.patch("builtins.input", return_value="y")
+    @mock.patch("amd_debug.ttm.maybe_reboot", return_value=True)
+    def test_set_success(
+        self,
+        _mock_reboot,
+        _mock_input,
+        mock_open,
+        mock_print,
+        _mock_gb_to_pages,
+        mock_mem,
+        mock_is_root,
+    ):
+        """Test set() success path"""
+        result = self.tool.set(5)
+        mock_open.assert_called_once_with(
+            "/etc/modprobe.d/ttm.conf", "w", encoding="utf-8"
+        )
+        mock_print.assert_any_call(
+            "Successfully set TTM pages limit to 20480 pages (5.00 GB)", "🐧"
+        )
+        self.assertTrue(result)
+
+    @mock.patch("os.path.exists", return_value=False)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_clear_file_not_exists(self, mock_print, _mock_exists):
+        """Test clear() when config file does not exist"""
+        result = self.tool.clear()
+        mock_print.assert_called_with("/etc/modprobe.d/ttm.conf doesn't exist", "❌")
+        self.assertFalse(result)
+
+    @mock.patch("os.path.exists", return_value=True)
+    @mock.patch("amd_debug.ttm.is_root", return_value=False)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_clear_not_root(self, mock_print, _mock_is_root, _mock_exists):
+        """Test clear() when not root"""
+        result = self.tool.clear()
+        mock_print.assert_called_with("Root privileges required", "❌")
+        self.assertFalse(result)
+
+    @mock.patch("os.path.exists", return_value=True)
+    @mock.patch("amd_debug.ttm.is_root", return_value=True)
+    @mock.patch("os.remove")
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("amd_debug.ttm.maybe_reboot", return_value=True)
+    def test_clear_success(
+        self, _mock_reboot, mock_print, mock_remove, _mock_is_root, mock_exists
+    ):
+        """Test clear() success path"""
+        result = self.tool.clear()
+        mock_remove.assert_called_once_with("/etc/modprobe.d/ttm.conf")
+        mock_print.assert_any_call(
+            "Configuration /etc/modprobe.d/ttm.conf removed", "🐧"
+        )
+        self.assertTrue(result)

amd_debug/ttm.py

@@ -0,0 +1,161 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+"""TTM configuration tool"""
+
+import os
+import argparse
+from amd_debug.common import (
+    AmdTool,
+    bytes_to_gb,
+    gb_to_pages,
+    get_system_mem,
+    is_root,
+    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"""
+        if not is_root():
+            print_color("Root privileges required", "❌")
+            return False
+
+        # 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
+
+        if not is_root():
+            print_color("Root privileges required", "❌")
+            return False
+
+        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

amd_debug/validator.py

@@ -703,6 +703,22 @@ class SleepValidator(AmdTool):
         else:
             print_color("No RTC device found, please manually wake system", "🚦")
 
+    def toggle_nvidia(self, value):
+        """Write to the NVIDIA suspend interface"""
+        p = os.path.join("/", "proc", "driver", "nvidia", "suspend")
+        if not os.path.exists(p):
+            return True
+        fd = os.open(p, os.O_WRONLY | os.O_SYNC)
+        try:
+            os.write(fd, value)
+        except OSError as e:
+            self.db.record_cycle_data(f"Failed to set {value} in NVIDIA {e}", "❌")
+            return False
+        finally:
+            os.close(fd)
+        self.db.record_debug(f"Wrote {value} to NVIDIA driver")
+        return True
+
     @pm_debugging
     def suspend_system(self):
         """Suspend the system using the dbus or sysfs interface"""
@@ -744,6 +760,8 @@ class SleepValidator(AmdTool):
                 self.db.record_cycle_data("Missing dbus", "❌")
                 return False
         else:
+            if not self.toggle_nvidia(b"suspend"):
+                return False
             old = get_wakeup_count()
             p = os.path.join("/", "sys", "power", "state")
             fd = os.open(p, os.O_WRONLY | os.O_SYNC)
@@ -757,6 +775,8 @@ class SleepValidator(AmdTool):
                 return False
             finally:
                 os.close(fd)
+            if not self.toggle_nvidia(b"resume"):
+                return False
             return True
 
     def unlock_session(self):

{amd_debug_tools-0.2.5.dist-info → amd_debug_tools-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.5
+Version: 0.2.6
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT
@@ -131,7 +131,7 @@ The following optional arguments are supported for this command:
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.
 
-### `amd-s2idle version`
+### `amd-s2idle --version`
 This will print the version of the tool and exit.
 
 ### Debug output
@@ -164,7 +164,7 @@ The following optional arguments are supported for this command:
         --input INPUT  Optional input file to parse
         --tool-debug   Enable tool debug logging
 
-### `amd-bios version`
+### `amd-bios --version`
 This will print the version of the tool and exit.
 
 ## amd-pstate
@@ -172,6 +172,9 @@ This will print the version of the tool and exit.
 It will capture some state from the system as well as from the machine specific registers that
 amd-pstate uses.
 
+## amd-ttm
+`amd-ttm` is a tool used for managing the TTM memory settings on AMD systems.
+
 ## Compatibility scripts
 
 Compatibility scripts are provided for the previous names the tools went by:

{amd_debug_tools-0.2.5.dist-info → amd_debug_tools-0.2.6.dist-info}/RECORD

@@ -1,45 +1,47 @@
 launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
 test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
 test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
-test_bios.py,sha256=ZPqI5X0QpEJBNJP-i5gNZzlbOlVSpznH4uv34esSqD8,8984
-test_common.py,sha256=fb16Oilh5ga6VgF-UgBj6azoYzZnPrS7KpECQ3nCwlg,16335
+test_bios.py,sha256=x_KLmQqGEbQhTugyWCHGXjGp2H1dCdhRz0kgw2Big8w,9276
+test_common.py,sha256=EYbyObC9vIXquT3EbgQ_98V4Zw2ebUCY9cfS9VOoywE,19722
 test_database.py,sha256=q5ZjI5u20f7ki6iCY5o1iPi0YOvPz1_W0LTDraU8mN4,10040
 test_display.py,sha256=hHggv-zBthF1BlwWWSjzAm7BBw1DWcElwil5xAuz87g,5822
 test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
 test_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
-test_kernel.py,sha256=xw7zpLcZjiRLWvO7vyHQ03_CjmKd_Np8ULhc-WhUV6A,7872
-test_launcher.py,sha256=80xVbidrbx8ixMt_x5Uvfn7nFnB637nX69yIZTifyuk,1511
-test_prerequisites.py,sha256=5fHtdMSGMf7sjDykIUfOP2h7XOAe-jNhJoZ0Vll5B58,84982
+test_kernel.py,sha256=2EXrLht5ZWdT4N5pb_F3zqZl9NEghjnDpcMGCMw3obI,7917
+test_launcher.py,sha256=8g8CBTvLX64Us4RmHtRPSdpV5E2kQFaudBl7VIsxLhE,1733
+test_prerequisites.py,sha256=-q6v80QXDMB_Mdek2KZTmKfKcRVZnHf8SBEhcT0RyIY,88498
 test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
-test_s2idle.py,sha256=YpFGpH84xvjI9mY6uBSKapa74hZnG8ZwBShXsJXpmyQ,33540
+test_s2idle.py,sha256=FxsyujgX9Px3m56VzHNeA8yMTHmJiRLWxYt-fh1m5gw,33585
 test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
-test_validator.py,sha256=-MfrWfhwef_aRqOSD_dJGhH0shsghhtOBgzeijzyLW4,33975
+test_validator.py,sha256=RpjyzxDpExhLcSJfQ0UDuonr4sTFAfa7sTtY5g7tc_Q,36410
 test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
-amd_debug/__init__.py,sha256=3wZxCDY3KPpfIxMz4vGmp6jUAB2GF4VTK4Xb86vy8c4,1101
+amd_debug/__init__.py,sha256=66Ya61av8RCws6bEY_vdujGmjBIZ6_UqfuWHgMNNOJY,1271
 amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
 amd_debug/battery.py,sha256=WN-6ys9PHCZIwg7PdwyBOa62GjBp8WKG0v1YZt5_W5s,3122
-amd_debug/bios.py,sha256=nVIDYqyyKiIO21nyS8lV-qB3ypBJOSIKIuVYFOVoBuw,4017
-amd_debug/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
+amd_debug/bios.py,sha256=y1iwDqX-mXCkoUtHSi-XO9pN-oLfaqbAMzANGI12zHs,4041
+amd_debug/common.py,sha256=fHrmSEVerVAE7KXjspf60eOAetUO7K9s1yhNyE2xi94,11598
 amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
 amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
 amd_debug/failures.py,sha256=z4O4Q-akv3xYGssSZFCqE0cDE4P9F_aw1hxil3McoD4,22910
-amd_debug/installer.py,sha256=tNWhlfxQEA30guk-fzMvcc237hf_PARVQuHaH3sTp4A,14287
+amd_debug/installer.py,sha256=6_Y0oHypW-oh_P8N9JW7fzbqidpsi5jphw9_8s5Qvso,14288
 amd_debug/kernel.py,sha256=HpX-QRh8tgkvqKnExfo2JrYqfcbMY8GNgDrC2VVV0Oc,11638
-amd_debug/prerequisites.py,sha256=E5_VpRd2mHiNYQBf13JqsoA5iiJS13wxcH3RERS_qJw,50502
-amd_debug/pstate.py,sha256=lLRsayKi7KOXZCQ6Zjm2pNaobpjLXcgLHXZ9Zt40Fd4,9559
+amd_debug/prerequisites.py,sha256=zK-IXL52p_jomA1SsS-6btIHuaapNKW4sD-Fy0wBr68,51399
+amd_debug/pstate.py,sha256=AOKCvUb0ngwHU2C59uSKrFwdLzEyn8r1w2DgWhZAMKM,9583
 amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
-amd_debug/s2idle.py,sha256=lr1wcuJcpvI5pL2gNHqrc7n5E7EYCztvaAYYFPMlGYk,13259
+amd_debug/s2idle.py,sha256=4cxHNfmvq11BE-AtkEthIqR-xrWmxW2LTa6oVDtGztY,13284
 amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
-amd_debug/validator.py,sha256=-rPqPnYAM1Vevw7vxIbGNPKo1bCRo48IpCBi3Y72-Cw,33419
+amd_debug/test_ttm.py,sha256=McNdEJZ14AeFw8fIxzul9ff8kr67dz1dPvK2fqlM4IA,11219
+amd_debug/ttm.py,sha256=U7beRffgoXIPgUXet4ZMabEGo7b0qqKMluhBVMD7O04,4830
+amd_debug/validator.py,sha256=X-cNFVvHWKzFgT4aR0Td3I2kwQRBOK4vQUk6L276VCQ,34153
 amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
 amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
 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.5.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.5.dist-info/METADATA,sha256=Dkhw4XQncTgjECNEa3Nk6HCYBzqa5lPAS_IbIli7cvA,6877
-amd_debug_tools-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amd_debug_tools-0.2.5.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.5.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.5.dist-info/RECORD,,
+amd_debug_tools-0.2.6.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.6.dist-info/METADATA,sha256=pMVZTIUIqoKEksnbkS2UCFJPnDRJ1k6sf3Jwj74mNxk,6971
+amd_debug_tools-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.6.dist-info/entry_points.txt,sha256=hIskDz6k0_6q1qpqWCpVFsca_djxAqkLrUAwzAyEGuE,144
+amd_debug_tools-0.2.6.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.6.dist-info/RECORD,,

{amd_debug_tools-0.2.5.dist-info → amd_debug_tools-0.2.6.dist-info}/entry_points.txt

@@ -2,3 +2,4 @@
 amd-bios = amd_debug:amd_bios
 amd-pstate = amd_debug:amd_pstate
 amd-s2idle = amd_debug:amd_s2idle
+amd-ttm = amd_debug:amd_ttm

test_bios.py

@@ -33,8 +33,14 @@ class TestAmdBios(unittest.TestCase):
     @patch("amd_debug.bios.minimum_kernel")
     @patch("amd_debug.bios.AcpicaTracer")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_set_tracing_enable(
-        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+        self,
+        _mock_run,
+        _mock_print,
+        mock_acpica_tracer,
+        mock_minimum_kernel,
+        mock_relaunch_sudo,
     ):
         """Test enabling tracing"""
         mock_minimum_kernel.return_value = True
@@ -53,8 +59,14 @@ class TestAmdBios(unittest.TestCase):
     @patch("amd_debug.bios.minimum_kernel")
     @patch("amd_debug.bios.AcpicaTracer")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_set_tracing_disable(
-        self, _mock_print, mock_acpica_tracer, mock_minimum_kernel, mock_relaunch_sudo
+        self,
+        _mock_run,
+        _mock_print,
+        mock_acpica_tracer,
+        mock_minimum_kernel,
+        mock_relaunch_sudo,
     ):
         """Test disabling tracing"""
         mock_minimum_kernel.return_value = True
@@ -71,7 +83,10 @@ class TestAmdBios(unittest.TestCase):
 
     @patch("amd_debug.bios.sscanf_bios_args")
     @patch("amd_debug.bios.print_color")
-    def test_analyze_kernel_log_line(self, mock_print_color, mock_sscanf_bios_args):
+    @patch("subprocess.run")
+    def test_analyze_kernel_log_line(
+        self, _mock_run, mock_print_color, mock_sscanf_bios_args
+    ):
         """Test analyzing kernel log line"""
         mock_sscanf_bios_args.return_value = "BIOS argument found"
 
@@ -85,8 +100,9 @@ class TestAmdBios(unittest.TestCase):
 
     @patch("amd_debug.bios.sscanf_bios_args")
     @patch("amd_debug.bios.print_color")
+    @patch("subprocess.run")
     def test_analyze_kernel_log_line_no_bios_args(
-        self, mock_print_color, mock_sscanf_bios_args
+        self, _mock_run, mock_print_color, mock_sscanf_bios_args
     ):
         """Test analyzing kernel log line with no BIOS arguments"""
         mock_sscanf_bios_args.return_value = None
@@ -140,12 +156,12 @@ class TestAmdBios(unittest.TestCase):
         self.assertFalse(args.enable)
         self.assertTrue(args.disable)
 
-    @patch("sys.argv", ["bios.py", "version"])
+    @patch("sys.argv", ["bios.py", "--version"])
     def test_parse_args_version_command(self):
         """Test parse_args with version command"""
 
         args = parse_args()
-        self.assertEqual(args.command, "version")
+        self.assertTrue(args.version)
 
     @patch("sys.argv", ["bios.py"])
     @patch("argparse.ArgumentParser.print_help")
@@ -227,7 +243,7 @@ class TestAmdBios(unittest.TestCase):
         self, _mock_print, mock_show_log_info, mock_version, mock_parse_args
     ):
         """Test main function with version command"""
-        mock_parse_args.return_value = argparse.Namespace(command="version")
+        mock_parse_args.return_value = argparse.Namespace(version=True, command=None)
         mock_version.return_value = "1.0.0"
 
         result = main()
@@ -241,7 +257,9 @@ class TestAmdBios(unittest.TestCase):
     @patch("amd_debug.bios.show_log_info")
     def test_main_invalid_command(self, mock_show_log_info, mock_parse_args):
         """Test main function with an invalid command"""
-        mock_parse_args.return_value = argparse.Namespace(command="invalid")
+        mock_parse_args.return_value = argparse.Namespace(
+            version=False, command="invalid"
+        )
 
         result = main()
 

test_common.py

@@ -15,6 +15,7 @@ from platform import uname_result
 
 from amd_debug.common import (
     apply_prefix_wrapper,
+    bytes_to_gb,
     Colors,
     convert_string_to_bool,
     colorize_choices,
@@ -22,12 +23,15 @@ from amd_debug.common import (
     compare_file,
     find_ip_version,
     fatal_error,
+    gb_to_pages,
     get_distro,
     get_log_priority,
     get_pretty_distro,
+    get_system_mem,
     is_root,
     minimum_kernel,
     print_color,
+    reboot,
     run_countdown,
     systemd_in_use,
     running_ssh,
@@ -442,3 +446,90 @@ class TestCommon(unittest.TestCase):
         with patch("sys.exit") as mock_exit:
             convert_string_to_bool("[unclosed_list")
             mock_exit.assert_called_once_with("Invalid entry: [unclosed_list")
+
+    def test_bytes_to_gb(self):
+        """Test bytes_to_gb conversion"""
+        # 4096 bytes should be 4096*4096/(1024*1024*1024) GB
+        self.assertAlmostEqual(bytes_to_gb(1), 4096 / (1024 * 1024 * 1024))
+        self.assertAlmostEqual(bytes_to_gb(0), 0)
+        self.assertAlmostEqual(bytes_to_gb(1024), 1024 * 4096 / (1024 * 1024 * 1024))
+
+    def test_gb_to_pages(self):
+        """Test gb_to_pages conversion"""
+        # 1 GB should be int(1 * (1024*1024*1024) / 4096)
+        self.assertEqual(gb_to_pages(1), int((1024 * 1024 * 1024) / 4096))
+        self.assertEqual(gb_to_pages(0), 0)
+        self.assertEqual(gb_to_pages(2), int(2 * (1024 * 1024 * 1024) / 4096))
+
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="MemTotal:       16384516 kB\n",
+    )
+    @patch("os.path.join", return_value="/proc/meminfo")
+    def test_get_system_mem_valid(self, _mock_join, mock_file):
+        """Test get_system_mem returns correct value"""
+        expected_gb = 16384516 / (1024 * 1024)
+        self.assertAlmostEqual(get_system_mem(), expected_gb)
+        mock_file.assert_called_once_with("/proc/meminfo", "r", encoding="utf-8")
+
+    @patch("builtins.open", new_callable=mock_open, read_data="NoMemHere: 1234\n")
+    @patch("os.path.join", return_value="/proc/meminfo")
+    def test_get_system_mem_missing(self, _mock_join, _mock_file):
+        """Test get_system_mem raises ValueError if MemTotal is missing"""
+        with self.assertRaises(ValueError):
+            get_system_mem()
+
+    @patch("amd_debug.common.fatal_error")
+    def test_reboot_importerror(self, mock_fatal_error):
+        """Test reboot handles ImportError"""
+        with patch.dict("sys.modules", {"dbus": None}):
+            reboot()
+            mock_fatal_error.assert_called_once_with("Missing dbus")
+
+    @patch("amd_debug.common.fatal_error")
+    def test_reboot_dbus_exception(self, mock_fatal_error):
+        """Test reboot handles dbus.exceptions.DBusException"""
+
+        class DummyDBusException(Exception):
+            """Dummy exception"""
+
+        class DummyIntf:
+            """Dummy interface"""
+
+            def Reboot(self, _arg):  # pylint: disable=invalid-name
+                """Dummy Reboot method"""
+                raise DummyDBusException("fail")
+
+        class DummyObj:  # pylint: disable=too-few-public-methods
+            """Dummy object"""
+
+            def __init__(self):
+                pass
+
+        class DummyBus:  # pylint: disable=too-few-public-methods
+            """Dummy bus"""
+
+            def get_object(self, *args, **kwargs):
+                """Dummy get_object method"""
+                return DummyObj()
+
+        class DummyDBus:
+            """Dummy dbus"""
+
+            class exceptions:  # pylint: disable=invalid-name
+                """Dummy exceptions"""
+
+                DBusException = DummyDBusException
+
+            def SystemBus(self):  # pylint: disable=invalid-name
+                """Dummy SystemBus method"""
+                return DummyBus()
+
+            def Interface(self, _obj, _name):  # pylint: disable=invalid-name
+                """Dummy Interface method"""
+                return DummyIntf()
+
+        with patch.dict("sys.modules", {"dbus": DummyDBus()}):
+            reboot()
+            self.assertTrue(mock_fatal_error.called)

test_kernel.py

@@ -114,7 +114,8 @@ class TestDmesgLogger(unittest.TestCase):
     """Test Dmesg logger functions"""
 
     @classmethod
-    def setUpClass(cls):
+    @patch("subprocess.run")
+    def setUpClass(cls, _mock_run=None):
         logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
 
     def test_dmesg_logger_initialization(self):

test_launcher.py

@@ -52,3 +52,10 @@ class TestLauncher(unittest.TestCase):
         with patch("amd_debug.pstate.main") as mock_main:
             amd_debug.launch_tool("amd_pstate.py")
             mock_main.assert_called_once()
+
+    def test_launcher_amd_ttm(self):
+        """Test launching amd_ttm"""
+
+        with patch("amd_debug.ttm.main") as mock_main:
+            amd_debug.launch_tool("amd_ttm.py")
+            mock_main.assert_called_once()

test_prerequisites.py

@@ -326,7 +326,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             BIT(9) | 1
         )  # Kernel warnings ignored, other taint present
         result = self.validator.check_taint()
-        self.assertFalse(result)
+        self.assertTrue(result)
         self.assertTrue(
             any(isinstance(f, TaintedKernel) for f in self.validator.failures)
         )
@@ -1959,3 +1959,79 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.check_dpia_pg_dmcub()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_version_file_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/version does not exist"""
+        mock_exists.side_effect = lambda p: False if "version" in p else True
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_not_called()
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_gpus_dir_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/gpus does not exist"""
+
+        def exists_side_effect(path):
+            if "version" in path:
+                return True
+            if "gpus" in path:
+                return False
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_called_once_with(
+            "/proc/driver/nvidia/version"
+        )
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_success(self, mock_exists, mock_walk):
+        """Test capture_nvidia when NVIDIA GPU files are present and readable"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info", "power"])
+        ]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_any_call("/proc/driver/nvidia/version")
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/info"
+        )
+        self.mock_db.record_debug.assert_any_call("NVIDIA power")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/power"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_version(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading version file"""
+        mock_exists.side_effect = lambda p: True if "version" in p else False
+        self.mock_db.record_debug_file.side_effect = PermissionError
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU version not readable", "👀"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_gpu_file(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading a GPU file"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info"])
+        ]
+        self.mock_db.record_debug_file.side_effect = [None, PermissionError]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU {f} not readable", "👀"
+        )

test_s2idle.py

@@ -117,9 +117,9 @@ class TestParseArgs(unittest.TestCase):
 
     def test_version_command(self):
         """Test parse_args with version command"""
-        sys.argv = ["s2idle.py", "version"]
+        sys.argv = ["s2idle.py", "--version"]
         args = parse_args()
-        self.assertEqual(args.action, "version")
+        self.assertTrue(args.version)
 
 
 class TestMainFunction(unittest.TestCase):
@@ -214,7 +214,7 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with version action"""
         sys.argv = ["s2idle.py", "version"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action="version")
+            mock_parse_args.return_value = argparse.Namespace(version=True, action=None)
             mock_version.return_value = "1.0.0"
             with patch("builtins.print") as mock_print:
                 result = main()
@@ -226,7 +226,9 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with no action specified"""
         sys.argv = ["s2idle.py"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action=None)
+            mock_parse_args.return_value = argparse.Namespace(
+                version=False, action=None
+            )
             with self.assertRaises(SystemExit) as cm:
                 main()
             self.assertEqual(cm.exception.code, "no action specified")

test_validator.py

@@ -71,7 +71,8 @@ class TestValidator(unittest.TestCase):
         logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
 
     @patch("amd_debug.validator.SleepDatabase")
-    def setUp(self, _db_mock):
+    @patch("subprocess.run")
+    def setUp(self, _db_mock, _mock_run):
         """Set up a mock context for testing"""
         self.validator = SleepValidator(tool_debug=True, bios_debug=False)
 
@@ -830,3 +831,64 @@ class TestValidator(unittest.TestCase):
         )
         mock_os_write.assert_called_once_with(3, b"mem")
         mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_file_not_exists(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia returns True if NVIDIA suspend file does not exist"""
+        mock_exists.return_value = False
+        result = self.validator.toggle_nvidia(b"suspend")
+        self.assertTrue(result)
+        mock_open.assert_not_called()
+        mock_write.assert_not_called()
+        mock_close.assert_not_called()
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_success(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia writes value and returns True on success"""
+        mock_exists.return_value = True
+        mock_open.return_value = 42
+        mock_write.return_value = None
+        with patch.object(self.validator.db, "record_debug") as mock_record_debug:
+            result = self.validator.toggle_nvidia(b"suspend")
+            self.assertTrue(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(42, b"suspend")
+            mock_close.assert_called_once_with(42)
+            mock_record_debug.assert_called_once_with(
+                "Wrote b'suspend' to NVIDIA driver"
+            )
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_oserror(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia handles OSError and returns False"""
+        mock_exists.return_value = True
+        mock_open.return_value = 99
+        mock_write.side_effect = OSError("write error")
+        with patch.object(
+            self.validator.db, "record_cycle_data"
+        ) as mock_record_cycle_data:
+            result = self.validator.toggle_nvidia(b"resume")
+            self.assertFalse(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(99, b"resume")
+            mock_close.assert_called_once_with(99)
+            mock_record_cycle_data.assert_called_once()