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

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.4.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.4
+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.4.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=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
-test_launcher.py,sha256=80xVbidrbx8ixMt_x5Uvfn7nFnB637nX69yIZTifyuk,1511
-test_prerequisites.py,sha256=DiB2SkZJf7OFEta1SifoEHyszuvKOfjs967CsHE6rg4,83244
+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/kernel.py,sha256=UAlxlXNuZxtHVtrfCmTp12YombVaUs4mizOxwuXTX2M,12038
-amd_debug/prerequisites.py,sha256=_SlRzYvWQpZt8VdioOAA2bMt1G9TbNs75swr60Yu1V4,50005
-amd_debug/pstate.py,sha256=lLRsayKi7KOXZCQ6Zjm2pNaobpjLXcgLHXZ9Zt40Fd4,9559
+amd_debug/installer.py,sha256=6_Y0oHypW-oh_P8N9JW7fzbqidpsi5jphw9_8s5Qvso,14288
+amd_debug/kernel.py,sha256=HpX-QRh8tgkvqKnExfo2JrYqfcbMY8GNgDrC2VVV0Oc,11638
+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.4.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.4.dist-info/METADATA,sha256=jzff0ncunf8ZwS6z90_U577R4OEOlZyf3tVtGA8RHsg,6877
-amd_debug_tools-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amd_debug_tools-0.2.4.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.4.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.4.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.4.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

@@ -85,7 +85,7 @@ class TestKernelLog(unittest.TestCase):
 
         # test a real post code line
         line = 'ex_trace_args: "  POST CODE: %X  ACPI TIMER: %X  TIME: %d.%d ms\\n", b0003f33, 83528798, 0, 77, 0, 0'
-        expected_output = "POST CODE: B0003F33  ACPI TIMER: 83528798  TIME: 0.77 ms"
+        expected_output = "POST CODE: B0003F33  ACPI TIMER: 83528798  TIME: 0.119 ms"
         result = sscanf_bios_args(line)
         self.assertEqual(result, expected_output)
 
@@ -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()