s2idle: Look at the socket level for telling how many CPUs are present

Looking at the complex level will return the wrong number of cores in
a multi-CCD system.

Reported-by: Pratap Nirujogi <[email protected]>
Signed-off-by: Mario Limonciello <[email protected]>

Author: superm1

src/amd_debug/failures.py

@@ -576,6 +576,15 @@ def __init__(self, actual_cores, max_cores):
         )
 
 
+class CpuTopologyUnknown(S0i3Failure):
+    """CPU topology unknown"""
+
+    def __init__(self):
+        super().__init__()
+        self.description = "CPU topology unknown"
+        self.explanation = "The CPU topology could not be determined. This may prevent the system from entering hardware sleep states correctly."
+
+
 class RogAllyOldMcu(S0i3Failure):
     """MCU firwmare is too old"""
 

src/amd_debug/prerequisites.py

@@ -44,6 +44,7 @@
     AmdHsmpBug,
     AmdgpuPpFeatureMask,
     ASpmWrong,
+    CpuTopologyUnknown,
     DeepSleep,
     DevSlpDiskIssue,
     DevSlpHostIssue,
@@ -1113,11 +1114,23 @@ def read_cpuid(cpu, leaf, subleaf):
         # check for artificially limited CPUs
         p = os.path.join("/", "sys", "devices", "system", "cpu", "kernel_max")
         max_cpus = int(read_file(p)) + 1  # 0 indexed
-        # https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/24594.pdf
-        # Extended Topology Enumeration (NumLogCores)
-        # CPUID 0x80000026 subleaf 1
+        # https://docs.amd.com/v/u/en-US/40332-PUB_4.08
+        # E.4.24 Function 8000_0026—Extended CPU Topology
         try:
-            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, 1)
+            # Need to discover the socket level to look at all CCDs in the socket
+            for level in range(0, 5):
+                _, _, ecx, _ = read_cpuid(0, 0x80000026, level)
+                level_type = (ecx >> 8) & 0xFF
+                if level_type == 0:
+                    self.db.record_prereq(
+                        "Unable to discover CPU topology, didn't find socket level",
+                        "❌",
+                    )
+                    self.failures += [CpuTopologyUnknown()]
+                    return False
+                if level_type == 4:
+                    break
+            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, level)
             if cpu_count > max_cpus:
                 self.db.record_prereq(
                     f"The kernel has been limited to {max_cpus} CPU cores, "

src/test_prerequisites.py

@@ -8,6 +8,7 @@
 import logging
 import unittest
 import subprocess
+import struct
 from unittest.mock import patch, MagicMock, mock_open
 
 from amd_debug.prerequisites import PrerequisiteValidator
@@ -436,6 +437,176 @@ def test_check_cpu_unsupported_model(self, mock_path_exists, mock_read_file):
             "This CPU model does not support hardware sleep over s2idle", "❌"
         )
 
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_limited_cores_single_ccd(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu with artificially limited CPUs on single-CCD system"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"  # kernel_max = 7 (8 cores)
+        mock_path_exists.return_value = True
+        # Simulate finding socket level at subleaf 1
+        # First call: subleaf 0, level_type = 1 (not socket)
+        # Second call: subleaf 1, level_type = 4 (socket level)
+        # Third call: read cpu_count from subleaf 1
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1 (thread)
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 1: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 1: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.assertTrue(
+            any(isinstance(f, LimitedCores) for f in self.validator.failures)
+        )
+        self.mock_db.record_prereq.assert_called_with(
+            "The kernel has been limited to 8 CPU cores, but the system has 16 cores",
+            "❌",
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_limited_cores_multi_ccd(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu with multi-CCD system (tests socket-level counting)"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "15"  # kernel_max = 15 (16 cores)
+        mock_path_exists.return_value = True
+        # Simulate multi-CCD: iterate through levels to find socket
+        # subleaf 0: level_type = 1 (thread)
+        # subleaf 1: level_type = 2 (core)
+        # subleaf 2: level_type = 3 (complex/CCD)
+        # subleaf 3: level_type = 4 (socket) - FOUND
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1 (thread)
+            struct.pack("4I", 0, 0, 0x200, 0),  # subleaf 1: level_type = 2 (core)
+            struct.pack(
+                "4I", 0, 0, 0x300, 0
+            ),  # subleaf 2: level_type = 3 (complex/CCD)
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 3: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 32, 0, 0),  # subleaf 3: cpu_count = 32
+        ]
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.assertTrue(
+            any(isinstance(f, LimitedCores) for f in self.validator.failures)
+        )
+        self.mock_db.record_prereq.assert_called_with(
+            "The kernel has been limited to 16 CPU cores, but the system has 32 cores",
+            "❌",
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_not_limited(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when CPUs are not artificially limited"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "31"  # kernel_max = 31 (32 cores)
+        mock_path_exists.return_value = True
+        # Simulate finding socket level
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1
+            struct.pack("4I", 0, 0, 0x400, 0),  # subleaf 1: level_type = 4 (socket)
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 1: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with("CPU core count: 16 max: 32")
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_socket_level_at_boundary(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when socket level is found at the last checked subleaf"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "15"  # kernel_max = 15 (16 cores)
+        mock_path_exists.return_value = True
+        # Socket level found at subleaf 4 (last iteration)
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack("4I", 0, 0, 0x100, 0),  # subleaf 0: level_type = 1
+            struct.pack("4I", 0, 0, 0x200, 0),  # subleaf 1: level_type = 2
+            struct.pack("4I", 0, 0, 0x300, 0),  # subleaf 2: level_type = 3
+            struct.pack("4I", 0, 0, 0x000, 0),  # subleaf 3: level_type = 0
+            struct.pack("4I", 0, 0, 0x400, 0),  # subleaf 4: level_type = 4 (socket)
+            struct.pack("4I", 0, 16, 0, 0),  # subleaf 4: cpu_count = 16
+        ]
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "Unable to discover CPU topology, didn't find socket level", "❌"
+        )
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_socket_level_first_subleaf(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when socket level is found at first subleaf"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"  # kernel_max = 7 (8 cores)
+        mock_path_exists.return_value = True
+        # Socket level found immediately at subleaf 0
+        mock_file_open.return_value.read.side_effect = [
+            struct.pack(
+                "4I", 0, 0, 0x400, 0
+            ),  # subleaf 0: level_type = 4 (socket) - FOUND
+            struct.pack("4I", 0, 8, 0, 0),  # subleaf 0: cpu_count = 8
+        ]
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with("CPU core count: 8 max: 8")
+
+    @patch("builtins.open", side_effect=FileNotFoundError)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_cpuid_file_not_found(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when cpuid kernel module is not loaded"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"
+        mock_path_exists.return_value = False
+        result = self.validator.check_cpu()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "Unable to check CPU topology: cpuid kernel module not loaded", "❌"
+        )
+
+    @patch("builtins.open", side_effect=PermissionError)
+    @patch("amd_debug.prerequisites.read_file")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_check_cpu_cpuid_permission_error(
+        self, mock_path_exists, mock_read_file, mock_file_open
+    ):
+        """Test check_cpu when there is a permission error accessing cpuid"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_read_file.return_value = "7"
+        mock_path_exists.return_value = True
+        result = self.validator.check_cpu()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with("CPUID checks unavailable", "🚦")
+
     @patch("amd_debug.prerequisites.os.walk")
     @patch(
         "amd_debug.prerequisites.open",
@@ -1127,7 +1298,11 @@ def test_capture_disabled_pins_with_parameters(self, _mock_open, mock_path_exist
         )
 
     @patch("amd_debug.prerequisites.os.path.exists")
-    @patch("amd_debug.prerequisites.open", new_callable=unittest.mock.mock_open, read_data="(null)")
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data="(null)",
+    )
     def test_capture_disabled_pins_with_null_values(self, _mock_open, mock_path_exists):
         mock_path_exists.side_effect = (
             lambda path: "ignore_wake" in path or "ignore_interrupt" in path