blob: d0d3bcc98534825d9a128c80d293f2f52affbd87 [file]
#!/usr/bin/python3
# SPDX-License-Identifier: MIT
"""
This module contains unit tests for the kernel log functions in the amd-debug-tools package.
"""
from datetime import datetime
from unittest.mock import patch, mock_open, MagicMock
import subprocess
import unittest
import logging
from amd_debug.kernel import (
sscanf_bios_args,
get_kernel_command_line,
redact_sensitive,
DmesgLogger,
InputFile,
KernelLogger,
get_kernel_log,
)
class TestKernelLog(unittest.TestCase):
"""Test Common kernel scan functions"""
@classmethod
def setUpClass(cls):
logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
def test_get_kernel_command_line(self):
"""Test get_kernel_command_line function"""
# Test case with a valid kernel command line that is fully filtered
kernel_cmdline = "quiet splash"
expected_output = ""
with patch(
"amd_debug.common.open", new_callable=mock_open, read_data=kernel_cmdline
) as _mock_file:
result = get_kernel_command_line()
self.assertEqual(result, expected_output)
# Test case with an empty kernel command line
kernel_cmdline = ""
expected_output = ""
with patch(
"amd_debug.common.open", new_callable=mock_open, read_data=kernel_cmdline
) as _mock_file:
result = get_kernel_command_line()
self.assertEqual(result, expected_output)
# Test case with a kernel command line containing special characters
kernel_cmdline = "quiet splash --debug=1"
expected_output = "--debug=1"
with patch(
"amd_debug.common.open", new_callable=mock_open, read_data=kernel_cmdline
) as _mock_file:
result = get_kernel_command_line()
self.assertEqual(result, expected_output)
# Test case with a kernel command line containing special characters
kernel_cmdline = "quiet splash initrd=foo modprobe.blacklist=foo"
expected_output = "modprobe.blacklist=foo"
with patch(
"amd_debug.common.open", new_callable=mock_open, read_data=kernel_cmdline
) as _mock_file:
result = get_kernel_command_line()
self.assertEqual(result, expected_output)
def test_redact_sensitive(self):
"""Test redact_sensitive function"""
# MAC addresses are redacted
result = redact_sensitive("wlan0: link up 00:11:22:33:44:55 detected")
self.assertEqual(result, "wlan0: link up <redacted-mac> detected")
# UUIDs are redacted
result = redact_sensitive(
"cryptsetup: 12345678-90ab-cdef-1234-567890abcdef mounted"
)
self.assertEqual(result, "cryptsetup: <redacted-uuid> mounted")
# key/secret/password/token assignments are redacted
self.assertEqual(
redact_sensitive("luks key=abcd1234"), "luks key=<redacted>"
)
self.assertEqual(
redact_sensitive("token=deadbeef"), "token=<redacted>"
)
# Ordinary log text is preserved
line = "amd_pmc AMDI0009:00: SMU idlemask s0i3: 0x1234abcd"
self.assertEqual(redact_sensitive(line), line)
def test_sscanf_bios_args(self):
"""Test sscanf_bios_args function"""
# Test case with a valid line
line = 'ex_trace_args: "format_string", 0x1234, 0x5678'
expected_output = "format_string"
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
# Test case with an invalid line
line = 'invalid_line: "format_string", 0x1234, 0x5678'
result = sscanf_bios_args(line)
self.assertIsNone(result)
# Test case with a line containing "Unknown"
line = 'ex_trace_args: "format_string", Unknown, 0x5678'
expected_output = "format_string"
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
# make sure that lines with ex_trace_point are not parsed
line = 'ex_trace_point: "format_string", 0x1234, 0x5678'
result = sscanf_bios_args(line)
self.assertTrue(result)
# 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.119 ms"
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
# test a real _REG print
line = 'ex_trace_args: " OEM-ASL-PCIe Address (0x%X)._REG (%d %d) PCSA = %d\\n", ec303000, 2, 0, 0, 0, 0'
expected_output = "OEM-ASL-PCIe Address (0xEC303000)._REG (2 0) PCSA = 0"
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
# test case of too may arguments
line = 'ex_trace_args : " APGE = %d\\n", 1, 0, 0, 0, 0, 0'
expected_output = "APGE = 1"
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
# test case for Dispatch notify
line = "evmisc-0132 ev_queue_notify_reques: Dispatching Notify on [UBTC] (Device) Value 0x80 (Status Change) Node 00000000851b15c1"
expected_output = (
"Dispatching Notify on [UBTC] (Device) Value 0x80 (Status Change)"
)
result = sscanf_bios_args(line)
self.assertEqual(result, expected_output)
class TestDmesgLogger(unittest.TestCase):
"""Test Dmesg logger functions"""
@classmethod
@patch("subprocess.run")
def setUpClass(cls, _mock_run=None):
logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
def test_dmesg_logger_initialization(self):
"""Test initialization of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg -h
mock_run.return_value.stdout = b"--since supported\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
self.assertTrue(logger.since_support)
self.assertEqual(logger.command, ["dmesg", "-t", "-k"])
def test_dmesg_logger_refresh_head(self):
"""Test _refresh_head method of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg
mock_run.return_value.stdout = b"line1\nline2\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger._refresh_head() # pylint: disable=protected-access
self.assertEqual(logger.buffer, "line1\nline2\n")
def test_dmesg_logger_seek_tail(self):
"""Test seek_tail method of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg
mock_run.return_value.stdout = b"line1\nline2\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger.seek_tail()
self.assertEqual(logger.buffer, "line1\nline2\n")
def test_dmesg_logger_process_callback(self):
"""Test process_callback method of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg
mock_run.return_value.stdout = b"line1\nline2\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger._refresh_head() # pylint: disable=protected-access
mock_callback = unittest.mock.Mock()
logger.process_callback(mock_callback)
mock_callback.assert_any_call("line1", None)
mock_callback.assert_any_call("line2", None)
def test_dmesg_logger_match_line(self):
"""Test match_line method of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg
mock_run.return_value.stdout = b"line1\nline2\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger._refresh_head() # pylint: disable=protected-access
result = logger.match_line(["line1"])
self.assertEqual(result, "line1")
result = logger.match_line(["nonexistent"])
self.assertEqual(result, "")
def test_dmesg_logger_match_pattern(self):
"""Test match_pattern method of DmesgLogger"""
with patch("subprocess.run") as mock_run:
# Mock the subprocess output for dmesg
mock_run.return_value.stdout = b"line1\nline2\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger._refresh_head() # pylint: disable=protected-access
result = logger.match_pattern(r"line\d")
self.assertEqual(result, "line1")
result = logger.match_pattern(r"nonexistent")
self.assertEqual(result, "")
def test_dmesg_logger_seek_refreshes_if_seeked(self):
"""seek() re-refreshes the buffer if it was previously seeked"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"old\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger.seeked = True
mock_run.return_value.stdout = b"new\n"
logger.seek()
self.assertEqual(logger.buffer, "new\n")
self.assertFalse(logger.seeked)
def test_dmesg_logger_seek_noop_if_not_seeked(self):
"""seek() is a no-op when not seeked"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"init\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
logger.buffer = "untouched"
logger.seeked = False
logger.seek()
self.assertEqual(logger.buffer, "untouched")
def test_dmesg_logger_seek_tail_with_time_since_support(self):
"""seek_tail with timestamp uses --since when supported"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"--since supported\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
self.assertTrue(logger.since_support)
mock_run.reset_mock()
mock_run.return_value.stdout = b"sliced\n"
mock_run.return_value.returncode = 0
logger.seek_tail(datetime(2025, 1, 2, 3, 4, 5))
call_args = mock_run.call_args[0][0]
self.assertIn("--time-format=iso", call_args)
self.assertTrue(any(a.startswith("--since=") for a in call_args))
self.assertEqual(logger.buffer, "sliced\n")
self.assertTrue(logger.seeked)
def test_dmesg_logger_seek_tail_with_time_no_since_support(self):
"""seek_tail with timestamp but without --since support runs plain dmesg"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"no since here\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
self.assertFalse(logger.since_support)
mock_run.return_value.stdout = b"plain\n"
logger.seek_tail(datetime(2025, 1, 2, 3, 4, 5))
self.assertEqual(logger.buffer, "plain\n")
self.assertFalse(logger.seeked)
def test_dmesg_logger_capture_header(self):
"""capture_header returns the first line"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"first\nsecond\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
self.assertEqual(logger.capture_header(), "first")
def test_dmesg_logger_get_full_log(self):
"""get_full_log returns the buffer"""
with patch("subprocess.run") as mock_run:
mock_run.return_value.stdout = b"a\nb\n"
mock_run.return_value.returncode = 0
logger = DmesgLogger()
self.assertEqual(logger.get_full_log(), "a\nb\n")
class TestKernelLoggerBase(unittest.TestCase):
"""Test the KernelLogger base class default implementations"""
def test_base_methods_return_defaults(self):
logger = KernelLogger()
self.assertIsNone(logger.seek())
self.assertIsNone(logger.seek_tail())
self.assertIsNone(logger.process_callback(lambda x, p: None))
self.assertEqual(logger.match_line(["foo"]), "")
self.assertEqual(logger.match_pattern("foo"), "")
self.assertEqual(logger.get_full_log(), "")
class TestInputFile(unittest.TestCase):
"""Test the InputFile kernel logger"""
@patch("amd_debug.kernel.read_file", return_value="alpha\nbeta\n")
def test_input_file_init_and_full_log(self, _mock_read):
f = InputFile("/path/to/log")
self.assertEqual(f.get_full_log(), "alpha\nbeta\n")
self.assertFalse(f.since_support)
@patch("amd_debug.kernel.read_file", return_value="alpha\nbeta")
def test_input_file_process_callback(self, _mock_read):
f = InputFile("/path/to/log")
cb = MagicMock()
f.process_callback(cb, priority=3)
cb.assert_any_call("alpha", 3)
cb.assert_any_call("beta", 3)
class TestSscanfBiosArgsEdge(unittest.TestCase):
"""Edge cases for sscanf_bios_args"""
def test_ex_trace_args_no_separator(self):
"""ex_trace_args without ': ' separator returns None"""
self.assertIsNone(sscanf_bios_args("ex_trace_args nothing"))
def test_ex_trace_args_no_format_string(self):
"""ex_trace_args present but no quoted format -> True"""
self.assertTrue(sscanf_bios_args("ex_trace_args: nonquoted stuff"))
def test_ex_trace_args_bad_hex(self):
"""Non-hex argument value returns None"""
line = 'ex_trace_args: "value: %x", notHex'
self.assertIsNone(sscanf_bios_args(line))
def test_ev_queue_notify_no_separator(self):
"""ev_queue_notify_reques without ': ' returns None"""
self.assertIsNone(sscanf_bios_args("ev_queue_notify_reques nothing"))
def test_ex_trace_args_oversized_width(self):
"""An oversized field width is rejected instead of allocating memory"""
line = 'ex_trace_args: "%2147483646d", 1, 0, 0, 0, 0, 0'
self.assertIsNone(sscanf_bios_args(line))
def test_ex_trace_args_unexpected_conversion(self):
"""A conversion outside the whitelist is rejected"""
line = 'ex_trace_args: "value: %s", 1, 0, 0, 0, 0, 0'
self.assertIsNone(sscanf_bios_args(line))
def test_ex_trace_args_valid_conversion(self):
"""A whitelisted conversion is still applied normally"""
line = 'ex_trace_args: "%x", 1234'
self.assertEqual(sscanf_bios_args(line), "1234")
class TestGetKernelLog(unittest.TestCase):
"""Test get_kernel_log provider selection"""
@patch("amd_debug.kernel.read_file", return_value="x")
def test_input_file_branch(self, _mock_read):
log = get_kernel_log(input_file="/tmp/file")
self.assertIsInstance(log, InputFile)
@patch("amd_debug.kernel.systemd_in_use", return_value=False)
@patch("amd_debug.kernel.subprocess.run")
def test_dmesg_branch(self, mock_run, _mock_systemd):
mock_run.return_value.stdout = b""
mock_run.return_value.returncode = 0
log = get_kernel_log()
self.assertIsInstance(log, DmesgLogger)
@patch("amd_debug.kernel.fatal_error")
@patch("amd_debug.kernel.systemd_in_use", return_value=False)
@patch(
"amd_debug.kernel.subprocess.run",
side_effect=subprocess.CalledProcessError(1, "dmesg"),
)
def test_dmesg_failure_falls_back(self, _mock_run, _mock_systemd, mock_fatal):
log = get_kernel_log()
self.assertIsInstance(log, KernelLogger)
mock_fatal.assert_called_once()