amd-debug-tools 0.2.4__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/kernel.py

@@ -115,24 +115,16 @@ def sscanf_bios_args(line):
 
             converted_args = []
             arg_index = 0
-            for specifier in format_specifiers:
+            for _specifier in format_specifiers:
                 if arg_index < len(arguments):
                     value = arguments[arg_index]
                     if value == "Unknown":
                         converted_args.append(-1)
-                    elif specifier.lower() == "x":
+                    else:
                         try:
                             converted_args.append(int(value, 16))
                         except ValueError:
                             return None
-                    else:  # Decimal conversion
-                        try:
-                            converted_args.append(int(value))
-                        except ValueError:
-                            try:
-                                converted_args.append(int(value, 16))
-                            except ValueError:
-                                return None
                     arg_index += 1
                 else:
                     break

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()
@@ -1145,26 +1167,13 @@ class PrerequisiteValidator(AmdTool):
                 found_iommu = True
                 debug_str += f"Found IOMMU {dev.sys_path}\n"
                 break
+
+            # User turned off IOMMU, no problems
             if not found_iommu:
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
-            p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
-            with open(p, "rb") as f:
-                data = f.read()
-            if len(data) < 40:
-                raise ValueError(
-                    "IVRS table appears too small to contain virtualization info."
-                )
-            virt_info = struct.unpack_from("I", data, 36)[0]
-            debug_str += f"Virtualization info: 0x{virt_info:x}"
-            found_dmar = (virt_info & 0x2) != 0
-            self.db.record_debug(debug_str)
-            if not found_dmar:
-                self.db.record_prereq(
-                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
-                )
-                self.failures += [DMArNotEnabled()]
-                return False
+
+            # Look for MSFT0201 in DSDT/SSDT
             for dev in self.pyudev.list_devices(subsystem="acpi"):
                 if "MSFT0201" in dev.sys_path:
                     found_acpi = True
@@ -1174,13 +1183,39 @@ class PrerequisiteValidator(AmdTool):
                 )
                 self.failures += [MissingIommuACPI("MSFT0201")]
                 return False
-            # check that policy is bound to it
+
+            # Check that policy is bound to it
             for dev in self.pyudev.list_devices(subsystem="platform"):
                 if "MSFT0201" in dev.sys_path:
                     p = os.path.join(dev.sys_path, "iommu")
                     if not os.path.exists(p):
                         self.failures += [MissingIommuPolicy("MSFT0201")]
                         return False
+
+            # Check pre-boot DMA
+            p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
+            with open(p, "rb") as f:
+                data = f.read()
+            if len(data) < 40:
+                raise ValueError(
+                    "IVRS table appears too small to contain virtualization info."
+                )
+            virt_info = struct.unpack_from("I", data, 36)[0]
+            debug_str += f"IVRS: Virtualization info: 0x{virt_info:x}\n"
+            found_ivrs_dmar = (virt_info & 0x2) != 0
+
+            # check for MSFT0201 in IVRS (alternative to pre-boot DMA)
+            target_bytes = "MSFT0201".encode("utf-8")
+            found_ivrs_msft0201 = data.find(target_bytes) != -1
+            debug_str += f"IVRS: Found MSFT0201: {found_ivrs_msft0201}"
+
+            self.db.record_debug(debug_str)
+            if not found_ivrs_dmar and not found_ivrs_msft0201:
+                self.db.record_prereq(
+                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
+                )
+                self.failures += [DMArNotEnabled()]
+                return False
             self.db.record_prereq("IOMMU properly configured", "✅")
         return True
 
@@ -1190,6 +1225,8 @@ class PrerequisiteValidator(AmdTool):
             return True
         if self.cpu_model not in [0x74, 0x78]:
             return True
+        if not self.smu_version:
+            return True
         if version.parse(self.smu_version) > version.parse("76.60.0"):
             return True
         if version.parse(self.smu_version) < version.parse("76.18.0"):
@@ -1212,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):
@@ -1229,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)