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

amd_debug/common.py

@@ -5,6 +5,7 @@
 This module contains common utility functions and classes for various amd-debug-tools.
 """
 
+import asyncio
 import importlib.metadata
 import logging
 import os
@@ -47,7 +48,7 @@ def get_group_color(group) -> str:
         color = Colors.WARNING
     elif group == "🗣️":
         color = Colors.HEADER
-    elif group == "💯":
+    elif any(mk in group for mk in ["💯", "🚫"]):
         color = Colors.UNDERLINE
     elif any(mk in group for mk in ["🦟", "🖴"]):
         color = Colors.DEBUG
@@ -238,18 +239,47 @@ def gb_to_pages(gb_value):
 
 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)
+    async def reboot_dbus_fast():
+        """Reboot using dbus-fast"""
+        try:
+            from dbus_fast.aio import (  # pylint: disable=import-outside-toplevel
+                MessageBus,
+            )
+            from dbus_fast import BusType  # pylint: disable=import-outside-toplevel
+
+            bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
+            introspection = await bus.introspect(
+                "org.freedesktop.login1", "/org/freedesktop/login1"
+            )
+            proxy_obj = bus.get_proxy_object(
+                "org.freedesktop.login1", "/org/freedesktop/login1", introspection
+            )
+            interface = proxy_obj.get_interface("org.freedesktop.login1.Manager")
+            await interface.call_reboot(True)
+
+        except ImportError:
+            return False
+        return True
+
+    def reboot_dbus():
+        """Reboot using python-dbus"""
+        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)
+        except ImportError:
+            return False
         return True
-    except ImportError:
-        fatal_error("Missing dbus")
-    except dbus.exceptions.DBusException as e:
-        fatal_error({e})
+
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(reboot_dbus_fast())
+    if not result:
+        return reboot_dbus()
+
     return True
 
 

amd_debug/prerequisites.py

@@ -21,7 +21,7 @@ import pyudev
 
 from amd_debug.wake import WakeIRQ
 from amd_debug.display import Display
-from amd_debug.kernel import get_kernel_log, SystemdLogger, DmesgLogger
+from amd_debug.kernel import get_kernel_log, SystemdLogger, CySystemdLogger, DmesgLogger
 from amd_debug.common import (
     apply_prefix_wrapper,
     BIT,
@@ -672,7 +672,9 @@ class PrerequisiteValidator(AmdTool):
         """Check the source for kernel logs"""
         if isinstance(self.kernel_log, SystemdLogger):
             self.db.record_prereq("Logs are provided via systemd", "✅")
-        if isinstance(self.kernel_log, DmesgLogger):
+        elif isinstance(self.kernel_log, CySystemdLogger):
+            self.db.record_prereq("Logs are provided via cysystemd", "✅")
+        elif isinstance(self.kernel_log, DmesgLogger):
             self.db.record_prereq(
                 "Logs are provided via dmesg, timestamps may not be accurate over multiple cycles",
                 "🚦",
@@ -1029,6 +1031,21 @@ class PrerequisiteValidator(AmdTool):
                     shutil.rmtree(tmpd)
         return True
 
+    def capture_cstates(self):
+        """Capture ACPI C state information for the first CPU (assumes the same for all CPUs)"""
+        base = os.path.join("/", "sys", "bus", "cpu", "devices", "cpu0", "cpuidle")
+        paths = {}
+        for root, _dirs, files in os.walk(base, topdown=False):
+            for fname in files:
+                target = os.path.join(root, fname)
+                with open(target, "rb") as f:
+                    paths[target] = f.read()
+        debug_str = "ACPI C-state information\n"
+        for path, data in paths.items():
+            prefix = "│ " if path != list(paths.keys())[-1] else "└─"
+            debug_str += f"{prefix}{path}: {data.decode('utf-8', 'ignore')}"
+        self.db.record_debug(debug_str)
+
     def capture_battery(self):
         """Capture battery information"""
         obj = Batteries()
@@ -1266,6 +1283,7 @@ class PrerequisiteValidator(AmdTool):
             self.capture_pci_acpi,
             self.capture_edid,
             self.capture_nvidia,
+            self.capture_cstates,
         ]
         checks = []
 
@@ -1318,7 +1336,7 @@ class PrerequisiteValidator(AmdTool):
             if not check():
                 result = False
         if not result:
-            self.db.record_prereq(Headers.BrokenPrerequisites, "💯")
+            self.db.record_prereq(Headers.BrokenPrerequisites, "🚫")
         self.db.sync()
         clear_temporary_message(len(msg))
         return result

amd_debug/sleep_report.py

@@ -488,7 +488,7 @@ class SleepReport(AmdTool):
             text = line.strip()
             if not text:
                 continue
-            for group in ["🗣️", "❌", "🚦", "🦟", "💯", "○"]:
+            for group in ["🗣️", "❌", "🚦", "🦟", "🚫", "○"]:
                 if line.startswith(group):
                     text = line.split(group)[-1]
                     color = get_group_color(group)

amd_debug/ttm.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: MIT
 """TTM configuration tool"""
 
+import asyncio
 import os
 import argparse
 from amd_debug.common import (
@@ -9,7 +10,7 @@ from amd_debug.common import (
     bytes_to_gb,
     gb_to_pages,
     get_system_mem,
-    is_root,
+    relaunch_sudo,
     print_color,
     reboot,
     version,
@@ -57,9 +58,7 @@ class AmdTtmTool(AmdTool):
 
     def set(self, gb_value) -> bool:
         """Set a new page limit"""
-        if not is_root():
-            print_color("Root privileges required", "❌")
-            return False
+        relaunch_sudo()
 
         # Check against system memory
         total = get_system_mem()
@@ -108,9 +107,7 @@ class AmdTtmTool(AmdTool):
             print_color(f"{MODPROBE_CONF_PATH} doesn't exist", "❌")
             return False
 
-        if not is_root():
-            print_color("Root privileges required", "❌")
-            return False
+        relaunch_sudo()
 
         os.remove(MODPROBE_CONF_PATH)
         print_color(f"Configuration {MODPROBE_CONF_PATH} removed", "🐧")

amd_debug_tools-0.2.8.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: amd-debug-tools
+Version: 0.2.8
+Summary: debug tools for AMD systems
+Author-email: Mario Limonciello <superm1@kernel.org>
+License-Expression: MIT
+Project-URL: Homepage, https://web.git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dbus-fast
+Requires-Dist: pyudev
+Requires-Dist: packaging
+Requires-Dist: pandas
+Requires-Dist: jinja2
+Requires-Dist: tabulate
+Requires-Dist: seaborn
+Requires-Dist: cysystemd
+Requires-Dist: Jinja2
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Dynamic: license-file
+
+# Helpful tools for debugging AMD Zen systems
+[![codecov](https://codecov.io/github/superm1/amd-debug-tools/graph/badge.svg?token=Z9WTBZADGT)](https://codecov.io/github/superm1/amd-debug-tools)
+[![PyPI](https://img.shields.io/pypi/v/amd-debug-tools.svg)](https://pypi.org/project/amd-debug-tools/)
+
+This repository hosts open tools that are useful for debugging issues on AMD systems.
+
+## Installation
+### Distro (Arch)
+`amd-debug-tools` has been [packaged for Arch Linux](https://archlinux.org/packages/extra/any/amd-debug-tools/) (and derivatives). You can install it using:
+
+    pacman -Sy amd-debug-tools
+
+### Using a python wheel (Generic)
+It is suggested to install tools in a virtual environment either using
+`pipx` or `python3 -m venv`.
+
+#### From PyPI
+`amd-debug-tools` is distributed as a python wheel, which is a
+binary package format for Python. To install from PyPI, run the following
+command:
+
+    pipx install amd-debug-tools
+
+### From source
+To build the package from source, you will need to the `python3-build`
+package natively installed by your distribution package manager. Then you
+can generate and install a wheel by running the following commands:
+
+    python3 -m build
+    pipx install dist/amd-debug-tools-*.whl
+
+### Ensuring path
+If you have not used a `pipx` environment before, you may need to run the following command
+to set up the environment:
+
+    pipx ensurepath
+
+This will add the `pipx` environment to your path.
+
+## Running in-tree
+Documentation about running directly from a git checkout is available [here](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-s2idle.md).
+
+## Tools
+
+Each tool has its own individual documentation page:
+* [amd-s2idle](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-s2idle.md)
+* [amd-bios](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-bios.md)
+* [amd-pstate](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-pstate.md)
+* [amd-ttm](https://github.com/superm1/amd-debug-tools/blob/master/docs/amd-ttm.md)
+

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

@@ -2,36 +2,36 @@ launcher.py,sha256=M8kT9DtyZoQgZaKWDbSBu4jsS6tZF1gWko3sovNVyag,947
 test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
 test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
 test_bios.py,sha256=x_KLmQqGEbQhTugyWCHGXjGp2H1dCdhRz0kgw2Big8w,9276
-test_common.py,sha256=EYbyObC9vIXquT3EbgQ_98V4Zw2ebUCY9cfS9VOoywE,19722
+test_common.py,sha256=qOCouXyO-dhY_x_L8kyNyuP_c0bhHhlqPoc084_F6Xg,20757
 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=2EXrLht5ZWdT4N5pb_F3zqZl9NEghjnDpcMGCMw3obI,7917
 test_launcher.py,sha256=8g8CBTvLX64Us4RmHtRPSdpV5E2kQFaudBl7VIsxLhE,1733
-test_prerequisites.py,sha256=-q6v80QXDMB_Mdek2KZTmKfKcRVZnHf8SBEhcT0RyIY,88498
+test_prerequisites.py,sha256=ig0ENpnR-wRMNlxLQ1FghivQsOu4yx5XP4HsJlptyQA,91791
 test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
 test_s2idle.py,sha256=FxsyujgX9Px3m56VzHNeA8yMTHmJiRLWxYt-fh1m5gw,33585
 test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
+test_ttm.py,sha256=QrCdRodQ_CD3nyDqKodb6yR158mgE0iIM5f1fV1Axu8,10515
 test_validator.py,sha256=RpjyzxDpExhLcSJfQ0UDuonr4sTFAfa7sTtY5g7tc_Q,36410
 test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
 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=y1iwDqX-mXCkoUtHSi-XO9pN-oLfaqbAMzANGI12zHs,4041
-amd_debug/common.py,sha256=fHrmSEVerVAE7KXjspf60eOAetUO7K9s1yhNyE2xi94,11598
+amd_debug/common.py,sha256=JclB-X3xwz2Ovvm0nsejE3W9FirP-inTgvHYx7MPNZo,12635
 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=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/prerequisites.py,sha256=-awyFaG2KCX3GSvVyzH1-o3UPhkMNm7Wf3F5AwYWH5U,52340
 amd_debug/pstate.py,sha256=AOKCvUb0ngwHU2C59uSKrFwdLzEyn8r1w2DgWhZAMKM,9583
 amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
 amd_debug/s2idle.py,sha256=4cxHNfmvq11BE-AtkEthIqR-xrWmxW2LTa6oVDtGztY,13284
-amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
-amd_debug/test_ttm.py,sha256=McNdEJZ14AeFw8fIxzul9ff8kr67dz1dPvK2fqlM4IA,11219
-amd_debug/ttm.py,sha256=U7beRffgoXIPgUXet4ZMabEGo7b0qqKMluhBVMD7O04,4830
+amd_debug/sleep_report.py,sha256=EzzvOHe0XxZcr8ZurxQXFjKs21gJPBj-qksj4a2WLuM,17317
+amd_debug/ttm.py,sha256=p9zV7OAOrcbI8apOkRMnsI8g1GDvOJfNEAklFuFGdRQ,4679
 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
@@ -39,9 +39,9 @@ amd_debug/templates/html,sha256=JfGhpmHIB2C2GItdGI1kuC8uayqEVgrpQvAWAj35eZ4,1458
 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.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.8.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.8.dist-info/METADATA,sha256=rd1U-CfX7hGfsubYk0mvuR3Ec92dAZrquTKGKRdOFEk,2775
+amd_debug_tools-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.8.dist-info/entry_points.txt,sha256=hIskDz6k0_6q1qpqWCpVFsca_djxAqkLrUAwzAyEGuE,144
+amd_debug_tools-0.2.8.dist-info/top_level.txt,sha256=VvGkkY5I7O3HoLNrc2VfgjCA-to3PUjnnKd7juONaFw,243
+amd_debug_tools-0.2.8.dist-info/RECORD,,

{amd_debug_tools-0.2.6.dist-info → amd_debug_tools-0.2.8.dist-info}/top_level.txt

@@ -14,5 +14,6 @@ test_prerequisites
 test_pstate
 test_s2idle
 test_sleep_report
+test_ttm
 test_validator
 test_wake

test_common.py

@@ -4,13 +4,16 @@
 """
 This module contains unit tests for the common functions in the amd-debug-tools package.
 """
-from unittest.mock import patch, mock_open, call
+from unittest.mock import patch, mock_open, call, Mock
 
+import asyncio
+import builtins
 import logging
 import tempfile
 import unittest
 import os
 from platform import uname_result
+import sys
 
 
 from amd_debug.common import (
@@ -49,6 +52,7 @@ color_dict = {
     "○": Colors.OK,
     "💤": Colors.OK,
     "💯": Colors.UNDERLINE,
+    "🚫": Colors.UNDERLINE,
     "🗣️": Colors.HEADER,
 }
 
@@ -473,63 +477,84 @@ class TestCommon(unittest.TestCase):
         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 test_reboot_dbus_fast_success(self):
+        """Test reboot returns True when reboot_dbus_fast succeeds"""
 
-            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):
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                # Close the coroutine to prevent the warning
+                coro.close()
+            except (AttributeError, RuntimeError):
                 pass
+            return True
 
-        class DummyBus:  # pylint: disable=too-few-public-methods
-            """Dummy bus"""
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
 
-            def get_object(self, *args, **kwargs):
-                """Dummy get_object method"""
-                return DummyObj()
+        with patch("amd_debug.common.asyncio.get_event_loop", return_value=mock_loop):
+            result = reboot()
+            self.assertTrue(result)
+            mock_loop.run_until_complete.assert_called_once()
 
-        class DummyDBus:
-            """Dummy dbus"""
+    @patch("asyncio.get_event_loop")
+    def test_reboot_dbus_fast_failure_and_dbus_success(self, mock_get_event_loop):
+        """Test reboot falls back to reboot_dbus when reboot_dbus_fast fails"""
 
-            class exceptions:  # pylint: disable=invalid-name
-                """Dummy exceptions"""
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                coro.close()
+            except (AttributeError, RuntimeError):
+                pass
+            return False
+
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+        mock_get_event_loop.return_value = mock_loop
+
+        # Mock the dbus module to avoid ImportError in CI
+        mock_dbus = Mock()
+        mock_bus = Mock()
+        mock_obj = Mock()
+        mock_intf = Mock()
+
+        mock_dbus.SystemBus.return_value = mock_bus
+        mock_bus.get_object.return_value = mock_obj
+        mock_obj.get_interface.return_value = mock_intf
+        mock_dbus.Interface = Mock(return_value=mock_intf)
+
+        with patch.dict("sys.modules", {"dbus": mock_dbus}):
+            result = reboot()
+            self.assertTrue(result)
+
+    @patch("asyncio.get_event_loop")
+    def test_reboot_dbus_fast_failure_and_dbus_failure(self, mock_get_event_loop):
+        """Test reboot returns False when both reboot_dbus_fast and reboot_dbus fail"""
+
+        # Create a mock loop that properly handles coroutines
+        def mock_run_until_complete(coro):
+            # Consume the coroutine to prevent the warning
+            try:
+                coro.close()
+            except (AttributeError, RuntimeError):
+                pass
+            return False
 
-                DBusException = DummyDBusException
+        mock_loop = Mock()
+        mock_loop.run_until_complete.side_effect = mock_run_until_complete
+        mock_get_event_loop.return_value = mock_loop
 
-            def SystemBus(self):  # pylint: disable=invalid-name
-                """Dummy SystemBus method"""
-                return DummyBus()
+        # Mock the import to raise ImportError when dbus is imported
+        original_import = builtins.__import__
 
-            def Interface(self, _obj, _name):  # pylint: disable=invalid-name
-                """Dummy Interface method"""
-                return DummyIntf()
+        def mock_import(name, *args, **kwargs):
+            if name == "dbus":
+                raise ImportError("No module named 'dbus'")
+            return original_import(name, *args, **kwargs)
 
-        with patch.dict("sys.modules", {"dbus": DummyDBus()}):
-            reboot()
-            self.assertTrue(mock_fatal_error.called)
+        with patch("builtins.__import__", side_effect=mock_import):
+            result = reboot()
+            self.assertFalse(result)

test_prerequisites.py

@@ -2035,3 +2035,76 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_prereq.assert_called_with(
             "NVIDIA GPU {f} not readable", "👀"
         )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch(
+        "builtins.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"C1 state info",
+    )
+    def test_capture_cstates_single_file(self, mock_open, mock_walk):
+        """Test capture_cstates with a single cpuidle file"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with(
+            "ACPI C-state information\n└─/sys/bus/cpu/devices/cpu0/cpuidle/state1: C1 state info"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("builtins.open", new_callable=mock_open)
+    def test_capture_cstates_multiple_files(self, mock_open_func, mock_walk):
+        """Test capture_cstates with multiple cpuidle files"""
+        # Setup mock file reads for two files
+        file_contents = {
+            "/sys/bus/cpu/devices/cpu0/cpuidle/state1": b"C1 info",
+            "/sys/bus/cpu/devices/cpu0/cpuidle/state2": b"C2 info",
+        }
+
+        def side_effect(path, mode="rb"):
+            mock_file = mock_open(read_data=file_contents[path])()
+            return mock_file
+
+        mock_open_func.side_effect = side_effect
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1", "state2"]),
+        ]
+        self.validator.capture_cstates()
+        # The prefix logic is based on order, so check for both lines
+        debug_call = self.mock_db.record_debug.call_args[0][0]
+        self.assertIn("/sys/bus/cpu/devices/cpu0/cpuidle/state1: C1 info", debug_call)
+        self.assertIn("/sys/bus/cpu/devices/cpu0/cpuidle/state2: C2 info", debug_call)
+        self.assertTrue(debug_call.startswith("ACPI C-state information\n"))
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("builtins.open", new_callable=mock_open, read_data=b"")
+    def test_capture_cstates_empty_files(self, _mock_open, mock_walk):
+        """Test capture_cstates with empty cpuidle files"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with(
+            "ACPI C-state information\n└─/sys/bus/cpu/devices/cpu0/cpuidle/state1: "
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("builtins.open", side_effect=PermissionError)
+    def test_capture_cstates_permission_error(self, _mock_open, mock_walk):
+        """Test capture_cstates when reading cpuidle files raises PermissionError"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], ["state1"]),
+        ]
+        with self.assertRaises(PermissionError):
+            self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.walk")
+    def test_capture_cstates_no_files(self, mock_walk):
+        """Test capture_cstates when no cpuidle files are present"""
+        mock_walk.return_value = [
+            ("/sys/bus/cpu/devices/cpu0/cpuidle", [], []),
+        ]
+        self.validator.capture_cstates()
+        self.mock_db.record_debug.assert_called_with("ACPI C-state information\n")

amd_debug/test_ttm.py → test_ttm.py

@@ -199,18 +199,12 @@ class TestAmdTtmTool(unittest.TestCase):
         )
         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.relaunch_sudo", 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):
+    def test_set_gb_greater_than_total(
+        self, mock_print, _mock_mem, _mock_relaunch_sudo
+    ):
         """Test set() when gb_value > total system memory"""
         result = self.tool.set(16)
         mock_print.assert_any_call(
@@ -218,19 +212,19 @@ class TestAmdTtmTool(unittest.TestCase):
         )
         self.assertFalse(result)
 
-    @mock.patch("amd_debug.ttm.is_root", return_value=True)
+    @mock.patch("amd_debug.ttm.relaunch_sudo", 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
+        self, _mock_input, mock_print, _mock_mem, mock_relaunch_sudo
     ):
         """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.relaunch_sudo", 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")
@@ -244,8 +238,8 @@ class TestAmdTtmTool(unittest.TestCase):
         mock_open,
         mock_print,
         _mock_gb_to_pages,
-        mock_mem,
-        mock_is_root,
+        _mock_mem,
+        _relaunch_sudo,
     ):
         """Test set() success path"""
         result = self.tool.set(5)
@@ -266,21 +260,12 @@ class TestAmdTtmTool(unittest.TestCase):
         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("amd_debug.ttm.relaunch_sudo", 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
+        self, _mock_reboot, mock_print, mock_remove, _mock_relaunch_sudo, _mock_exists
     ):
         """Test clear() success path"""
         result = self.tool.clear()

amd_debug_tools-0.2.6.dist-info/METADATA

@@ -1,184 +0,0 @@
-Metadata-Version: 2.4
-Name: amd-debug-tools
-Version: 0.2.6
-Summary: debug tools for AMD systems
-Author-email: Mario Limonciello <superm1@kernel.org>
-License-Expression: MIT
-Project-URL: Homepage, https://web.git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git/
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyudev
-Requires-Dist: packaging
-Requires-Dist: pandas
-Requires-Dist: jinja2
-Requires-Dist: tabulate
-Requires-Dist: seaborn
-Requires-Dist: cysystemd
-Requires-Dist: Jinja2
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Dynamic: license-file
-
-# Helpful tools for debugging AMD Zen systems
-[![codecov](https://codecov.io/github/superm1/amd-debug-tools/graph/badge.svg?token=Z9WTBZADGT)](https://codecov.io/github/superm1/amd-debug-tools)
-[![PyPI](https://img.shields.io/pypi/v/amd-debug-tools.svg)](https://pypi.org/project/amd-debug-tools/)
-
-This repository hosts open tools that are useful for debugging issues on AMD systems.
-
-## Installation
-It is suggested to install tools in a virtual environment either using
-`pipx` or `python3 -m venv`.
-
-### From PyPI
-`amd-debug-tools` is distributed as a python wheel, which is a
-binary package format for Python. To install from PyPI, run the following
-command:
-
-    pipx install amd-debug-tools
-
-### From source
-To build the package from source, you will need to the `python3-build`
-package natively installed by your distribution package manager. Then you
-can generate and install a wheel by running the following commands:
-
-    python3 -m build
-    pipx install dist/amd-debug-tools-*.whl
-
-### Ensuring path
-If you have not used a `pipx` environment before, you may need to run the following command
-to set up the environment:
-
-    pipx ensurepath
-
-This will add the `pipx` environment to your path.
-
-### Running in tree
-If you want to run the tools in tree, you need to make sure that distro dependencies
-that would normally install into a venv are installed. This can be done by running:
-
-    ./install_deps.py
-
-After dependencies are installed, you can run the tools by running:
-
-    ./amd_s2idle.py
-    ./amd_bios.py
-    ./amd_pstate.py
-
-## amd-s2idle
-`amd-s2idle` is a tool used for analyzing the entry and exit of the s2idle
-state of a Linux system.
-
-It is intended to use with Linux kernel 6.1 or later and works by hooking
-into dynamic debugging messages and events that are generated by the kernel.
-
-For analysis of power consumption issues it can be hooked into `systemd` to
-run a command to capture data right before and after the system enters and
-exits the s2idle state.
-
-4 high level commands are supported.
-
-### `amd-s2idle install`
-This will install the systemd hook so that data will be captured before and
-after the system enters and exits the s2idle state.
-
-This will also install a bash completion script that can be used for other
-commands.
-
-**NOTE:** This command is only supported when run from a venv.
-
-### `amd-s2idle uninstall`
-This will uninstall the systemd hook and remove the bash completion script.
-
-**NOTE:** This command is only supported when run from a venv.
-
-### `amd-s2idle test`
-This will run a suspend cycle with a timer based wakeup and capture relevant
-data into a database and produce a report. This can also be used to run multiple cycles.
-
-The following optional arguments are supported for this command:
-
-        --count COUNT         Number of cycles to run
-        --duration DURATION   Duration of the cycle in seconds
-        --wait WAIT           Time to wait before starting the cycle in seconds
-        --format FORMAT       Format of the report to produce (html, txt or md)
-        --report-file         File to write the report to
-        --force               Run a test cycle even if the system fails to pass prerequisite checks
-        --random              Run sleep cycles for random durations and waits, using the --duration and --wait arguments as an upper bound
-        --logind              Use logind to suspend the system
-        --tool-debug          Enable debug logging
-        --bios-debug          Enable BIOS debug logging instead of notify logging
-
-If the tool is launched with an environment that can call `xdg-open`, the report
-will be opened in a browser.
-
-### `amd-s2idle report`
-This will produce a report from the data captured by the `test` command
-and/or from the systemd hook.  The report will default to 60 days of data.
-
-The following optional arguments are supported for this command:
-
-        --since SINCE         Date to start the report from
-        --until UNTIL         Date to end the report at
-        --format FORMAT       Format of the report to produce (html, txt or md)
-        --report-file         File to write the report to
-        --tool-debug          Enable tool debug logging
-        --report-debug
-        --no-report-debug
-                              Include debug messages in report (WARNING: can significantly increase report size)
-If the tool is launched with an environment that can call `xdg-open`, the report
-will be opened in a browser.
-
-### `amd-s2idle --version`
-This will print the version of the tool and exit.
-
-### Debug output
-All commands support the `--tool-debug` argument which will enable extra debug output. This is often needed for debugging issues with a particular cycle.
-
-**NOTE:** enabling debug output significantly increases the size of the report.
-It's suggested that you use `--since` and `--until` to focus on the cycles that you are interested in.
-
-## amd-bios
-`amd-bios` is a a tool that can be used to enable or disable BIOS AML debug logging
--and to parse a kernel log that contains BIOS logs.
-
-### `amd-bios trace`
-Modify BIOS AML trace debug logging.
-
-One of the following arguments must be set for this command:
-
-        --enable       Enable BIOS AML tracing
-        --disable      Disable BIOS AML tracing
-
-The following optional arguments are supported for this command:
-
-        --tool-debug   Enable tool debug logging
-
-### `amd-bios parse`
-Parses a kernel log that contains BIOS AML debug logging and produces a report.
-
-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`
-This will print the version of the tool and exit.
-
-## amd-pstate
-`amd-pstate` is a tool used for identification of issues with amd-pstate.
-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_s2idle.py`, `amd_bios.py` and `amd_pstate.py`.
-These allow cloning the repository and running the scripts without installing
-the package.
-