amd-debug-tools 0.2.5__tar.gz → 0.2.6__tar.gz

{amd_debug_tools-0.2.5 → amd_debug_tools-0.2.6}/PKG-INFO

@@ -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 → amd_debug_tools-0.2.6}/README.md

@@ -107,7 +107,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
@@ -140,7 +140,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
@@ -148,6 +148,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 → amd_debug_tools-0.2.6}/pyproject.toml

@@ -50,3 +50,4 @@ license = "MIT"
 amd-s2idle = "amd_debug:amd_s2idle"
 amd-bios = "amd_debug:amd_bios"
 amd-pstate = "amd_debug:amd_pstate"
+amd-ttm = "amd_debug:amd_ttm"

{amd_debug_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.5 → amd_debug_tools-0.2.6}/src/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_tools-0.2.6/src/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)