blob: 993cf8c00368b9a9464563e1410e9523c2103832 [file]
#!/usr/bin/python3
# SPDX-License-Identifier: MIT
"""Unit tests for the IVRS parser implementation."""
import struct
import tempfile
import unittest
from contextlib import redirect_stdout
from io import StringIO
from unittest.mock import patch
import amd_debug.ivrs as ivrs_mod
from amd_debug.ivrs import IvhdDeviceEntry, IvhdEntry, IvmdMapping, IvrsParser
from amd_debug.ivrs_fixtures import (
_pack_ivmd_all_devices,
_pack_ivmd_exclusion_range,
_pack_ivmd_single_device,
make_ivrs_table,
)
class TestIvrsParser(unittest.TestCase):
def test_rejects_too_small_table(self):
with self.assertRaises(ValueError):
IvrsParser(b"\x00" * 47)
def test_parses_dma_remap_from_ivinfo(self):
parser = IvrsParser(make_ivrs_table(dma_remap=True))
self.assertTrue(parser.has_dma_remap)
self.assertEqual(parser.virt_info & 0x2, 0x2)
def test_parses_ivhd_type_10_header(self):
parser = IvrsParser(make_ivrs_table(ivhd_type=0x10))
self.assertEqual(len(parser.ivhd_entries), 1)
self.assertEqual(parser.ivhd_entries[0].subtable_type, 0x10)
self.assertEqual(parser.ivhd_entries[0].header_size, 24)
def test_parses_ivhd_type_11_header(self):
parser = IvrsParser(make_ivrs_table(ivhd_type=0x11))
self.assertEqual(len(parser.ivhd_entries), 1)
self.assertEqual(parser.ivhd_entries[0].subtable_type, 0x11)
self.assertEqual(parser.ivhd_entries[0].header_size, 40)
def test_parses_ivhd_type_40_instead_of_skipping(self):
parser = IvrsParser(make_ivrs_table(ivhd_type=0x40))
self.assertEqual(len(parser.ivhd_entries), 1)
self.assertEqual(parser.ivhd_entries[0].subtable_type, 0x40)
self.assertEqual(parser.ivhd_entries[0].header_size, 40)
def test_finds_msft0201_device_in_f0_entry(self):
parser = IvrsParser(make_ivrs_table(msft0201_devid=0x60, ivhd_type=0x40))
self.assertTrue(parser.has_msft0201_in_acpi())
self.assertEqual(parser.find_msft0201_device_id(), 0x60)
def test_handles_broken_f0_uid_length_without_exception(self):
table = bytearray(make_ivrs_table(msft0201_devid=0x60, ivhd_type=0x40))
# F0 entry starts after IVRS header (48), IVHD 40-byte header and two 4-byte range entries.
f0_offset = 48 + 40 + 8
uid_len_offset = f0_offset + 21
table[uid_len_offset] = 0xFF
parser = IvrsParser(bytes(table))
self.assertIsNone(parser.find_msft0201_device_id())
def test_ivmd_type_20_requires_unity_flag(self):
ivmd = bytearray(_pack_ivmd_all_devices(memory_length=0x100000))
ivmd[1] = 0x00 # clear all flags
parser = IvrsParser(
make_ivrs_table(msft0201_devid=0x60, ivmd_entries=[bytes(ivmd)])
)
self.assertFalse(parser.has_valid_msft0201_mapping(0x60))
def test_ivmd_type_21_requires_matching_device_id(self):
parser = IvrsParser(
make_ivrs_table(
msft0201_devid=0x60,
ivmd_entries=[_pack_ivmd_single_device(0x70, memory_length=0x100000)],
)
)
self.assertFalse(parser.has_valid_msft0201_mapping(0x60))
def test_ivmd_type_22_uses_inclusive_device_range(self):
parser = IvrsParser(
make_ivrs_table(
msft0201_devid=0x60,
ivmd_entries=[
_pack_ivmd_exclusion_range(
device_id=0x50,
end_device_id=0x70,
memory_length=0x100000,
)
],
)
)
self.assertTrue(parser.has_valid_msft0201_mapping(0x60))
self.assertFalse(parser.has_valid_msft0201_mapping(0x80))
def test_none_msft_device_id_never_matches_mapping(self):
parser = IvrsParser(
make_ivrs_table(
ivmd_entries=[_pack_ivmd_all_devices(memory_length=0x100000)]
)
)
self.assertFalse(parser.has_valid_msft0201_mapping(None))
def test_malformed_subtable_length_stops_parsing_cleanly(self):
table = bytearray(make_ivrs_table(msft0201_devid=0x60, ivhd_type=0x11))
# Corrupt first IVDB length so it extends past table end.
struct.pack_into("<H", table, 48 + 2, 0xFFFF)
parser = IvrsParser(bytes(table))
self.assertEqual(parser.subtables, [])
def test_get_entry_size_rules(self):
self.assertEqual(IvhdDeviceEntry.get_entry_size(bytes([0x02]), 0), 4)
self.assertEqual(IvhdDeviceEntry.get_entry_size(bytes([0x40]), 0), 8)
f0 = bytearray(22)
f0[0] = 0xF0
f0[21] = 5
self.assertEqual(IvhdDeviceEntry.get_entry_size(bytes(f0 + b"abcde"), 0), 27)
self.assertIsNone(
IvhdDeviceEntry.get_entry_size(bytes([0x90]) + b"\x00" * 40, 0)
)
def test_get_entry_size_handles_short_f0_header(self):
self.assertIsNone(
IvhdDeviceEntry.get_entry_size(bytes([0xF0]) + b"\x00" * 10, 0)
)
def test_ivhd_entry_rejects_unknown_type(self):
data = bytearray(24)
data[0] = 0x12
struct.pack_into("<H", data, 2, 24)
with self.assertRaises(ValueError):
IvhdEntry(bytes(data), 0)
def test_ivhd_entry_rejects_short_type_11_header(self):
data = bytearray(24)
data[0] = 0x11
struct.pack_into("<H", data, 2, 24)
with self.assertRaises(ValueError):
IvhdEntry(bytes(data), 0)
def test_ivhd_entry_breaks_when_fixed_entry_overruns_end(self):
# 24-byte type 10 header plus a single 4-byte device-entry payload that starts
# with a type in the 40h-7Fh range (implies 8-byte fixed length).
data = bytearray(24 + 4)
data[0] = 0x10
struct.pack_into("<H", data, 2, len(data))
data[24] = 0x40
ivhd = IvhdEntry(bytes(data), 0)
self.assertEqual(ivhd.device_entries, [])
def test_ivhd_device_ids_property(self):
parser = IvrsParser(
make_ivrs_table(extra_devices=[0x0010, 0x0020], ivhd_type=0x10)
)
self.assertEqual(
parser.ivhd_entries[0].device_ids, {0x0003, 0xFFFE, 0x0010, 0x0020}
)
def test_ivhd_device_length_property_for_fixed_entry(self):
entry = IvhdDeviceEntry(bytes([0x02, 0x34, 0x12, 0x00]), 0, 4)
self.assertEqual(entry.length, 4)
def test_ivhd_device_hid_none_when_hid_field_truncated(self):
# Explicitly pass entry_length to avoid automatic size inference.
entry = IvhdDeviceEntry(bytes([0xF0, 0x34, 0x12, 0x00, 0x4D]), 0, 22)
self.assertIsNone(entry.hid)
def test_ivhd_device_hid_none_when_entry_length_cannot_be_inferred(self):
entry = IvhdDeviceEntry(bytes([0xF0, 0x34, 0x12, 0x00, 0x4D]), 0)
self.assertIsNone(entry.hid)
self.assertEqual(entry.length, 4)
def test_ivmd_rejects_too_short_subtable(self):
ivmd = bytearray(_pack_ivmd_single_device(0x60, 0x1000))
struct.pack_into("<H", ivmd, 2, 16)
with self.assertRaises(ValueError):
IvmdMapping(bytes(ivmd), 0)
def test_ivmd_helpers_and_properties(self):
parser = IvrsParser(
make_ivrs_table(
msft0201_devid=0x60,
ivmd_entries=[_pack_ivmd_single_device(0x60, memory_length=0x1000)],
)
)
ivmd = parser.ivmd_mappings[0]
self.assertEqual(ivmd.subtable_type, 0x21)
self.assertTrue(ivmd.is_unity_map)
self.assertFalse(ivmd.is_exclusion_range)
self.assertTrue(ivmd.has_valid_mapping)
self.assertFalse(ivmd.covers_device_id(0x70))
def test_ivmd_type_20_uses_has_valid_mapping_for_cover(self):
ivmd = bytearray(_pack_ivmd_all_devices(memory_length=0))
parser = IvrsParser(make_ivrs_table(ivmd_entries=[bytes(ivmd)]))
self.assertFalse(parser.ivmd_mappings[0].covers_device(0x1234))
def test_ivmd_covers_device_id_rejects_zero_length_mapping(self):
ivmd = bytearray(_pack_ivmd_single_device(0x60, memory_length=0))
parser = IvrsParser(make_ivrs_table(ivmd_entries=[bytes(ivmd)]))
self.assertFalse(parser.ivmd_mappings[0].covers_device_id(0x60))
def test_subtable_raw_slice_property(self):
parser = IvrsParser(make_ivrs_table(msft0201_devid=0x60, ivhd_type=0x11))
subtable = parser.subtables[0]
self.assertEqual(
subtable.raw,
parser.data[subtable.offset : subtable.offset + subtable.length],
)
def test_parse_subtables_breaks_on_zero_and_too_small_length(self):
# length == 0 at first subtable offset
zero_len = bytearray(make_ivrs_table())
struct.pack_into("<H", zero_len, 48 + 2, 0)
self.assertEqual(IvrsParser(bytes(zero_len)).subtables, [])
# length < 4 at first subtable offset
tiny_len = bytearray(make_ivrs_table())
struct.pack_into("<H", tiny_len, 48 + 2, 3)
self.assertEqual(IvrsParser(bytes(tiny_len)).subtables, [])
def test_parse_subtables_skips_unknown_type(self):
table = bytearray(make_ivrs_table())
table[48] = 0x33
parser = IvrsParser(bytes(table))
self.assertEqual(parser.subtables, [])
def test_parse_subtables_handles_malformed_ivhd_and_continues(self):
table = bytearray(make_ivrs_table())
# Unknown IVHD-like type with valid length to trigger IvhdEntry ValueError path.
table[48] = 0x10
struct.pack_into("<H", table, 48 + 2, 8)
parser = IvrsParser(bytes(table))
self.assertEqual(parser.subtables, [])
def test_subtable_validation_rejects_length_too_small(self):
bad = bytearray(_pack_ivmd_single_device(0x60, 0x1000))
struct.pack_into("<H", bad, 2, 3)
with self.assertRaises(ValueError):
IvmdMapping(bytes(bad), 0)
def test_subtable_validation_rejects_out_of_bounds_length(self):
bad = bytearray(_pack_ivmd_single_device(0x60, 0x1000))
struct.pack_into("<H", bad, 2, 0x4000)
with self.assertRaises(ValueError):
IvmdMapping(bytes(bad), 0)
def test_main_success_output(self):
data = make_ivrs_table(
msft0201_devid=0x60,
ivmd_entries=[_pack_ivmd_single_device(0x60, memory_length=0x1000)],
)
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(data)
path = f.name
argv = ["ivrs.py", path]
buf = StringIO()
try:
with patch("sys.argv", argv), redirect_stdout(buf):
rc = ivrs_mod.main()
finally:
import os
os.unlink(path)
out = buf.getvalue()
self.assertEqual(rc, 0)
self.assertIn("IVRS Table Analysis", out)
self.assertIn("MSFT0201 check", out)
def test_main_parse_error_output(self):
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(b"\x00" * 4)
path = f.name
argv = ["ivrs.py", path]
buf = StringIO()
try:
with patch("sys.argv", argv), redirect_stdout(buf):
rc = ivrs_mod.main()
finally:
import os
os.unlink(path)
out = buf.getvalue()
self.assertEqual(rc, 1)
self.assertIn("Error parsing IVRS table", out)
def test_main_reports_msft_string_without_parsed_f0_entry(self):
table = bytearray(make_ivrs_table(msft0201_devid=0x60, ivhd_type=0x40))
f0_offset = 48 + 40 + 8
table[f0_offset + 21] = 0xFF
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(bytes(table))
path = f.name
argv = ["ivrs.py", path]
buf = StringIO()
try:
with patch("sys.argv", argv), redirect_stdout(buf):
rc = ivrs_mod.main()
finally:
import os
os.unlink(path)
out = buf.getvalue()
self.assertEqual(rc, 0)
self.assertIn("Not found in IVHD device entries", out)
self.assertIn("But MSFT0201 HID string found in table", out)
def test_module_main_invocation_path(self):
data = make_ivrs_table()
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(data)
path = f.name
argv = ["amd_debug.ivrs", path]
buf = StringIO()
try:
with patch("sys.argv", argv), redirect_stdout(buf):
import runpy
runpy.run_module("amd_debug.ivrs", run_name="__main__")
finally:
import os
os.unlink(path)
if __name__ == "__main__":
unittest.main()