Files
qemu/tests/functional/gdb-scripts/kernel_gdb_test.py
Alex Bennée e0a7139b21 tests/functional: add tuxrun kvm gdb test for s390x
As with x86_64 we now have the bits to add a KVM gdb test. A couple of
minor wrinkles need to be handled.

The first is applying an offset when loading the symbols to take into
account the relocation that happens.

The other minor wrinkle is the s390x only supports WP_WRITE watch
points so we skip the other watch point tests lest we get confusing
messages about failing to insert HW breakpoints.

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Ilya Leoshkevich <iii@linux.ibm.com>
Message-ID: <20261019192704.3220373-20-alex.bennee@linaro.org>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
2026-10-23 17:32:05 +01:00

165 lines
4.3 KiB
Python

# SPDX-License-Identifier: GPL-2.0-or-later
#
# Generic Kernel GDB script to verify functionality:
# - Single-stepping
# - Hardware breakpoints
# - Software breakpoints
# - Watchpoints
#
# It relies on fairly common kernel points to break at and symbols for
# the kernel. Address space randomisation (kaslr) needs to be disabled.
#
# Copyright (c) 2026 Linaro Limited
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# This is launched by the tuxrun functional tests via tests/guest-debug/run-test.py
import gdb
from test_gdbstub import main, report
def parse_registers():
"""Parse 'info registers' into a name -> value dictionary."""
regs = {}
for line in gdb.execute("info registers", to_string=True).splitlines():
parts = line.split()
if len(parts) >= 2:
regs[parts[0]] = parts[1]
return regs
def check_step():
"Step an instruction, check it moved."
start_pc = gdb.parse_and_eval('$pc')
gdb.execute("si")
end_pc = gdb.parse_and_eval('$pc')
return not (start_pc == end_pc)
def check_reg_updates(regs_start):
regs_end = parse_registers()
changed = [k for k in regs_start
if k in regs_end and regs_start[k] != regs_end[k]]
report(len(changed) > 0, f"{len(changed)} registers changed.")
def check_break(sym_name):
"Setup breakpoint, continue and check we stopped."
bp = gdb.Breakpoint(sym_name)
gdb.execute("c")
res = bp.hit_count == 1
bp.delete()
return res
def check_hbreak(sym_name):
"Setup hardware breakpoint, continue and check we stopped."
bp = gdb.Breakpoint(sym_name, type = gdb.BP_HARDWARE_BREAKPOINT)
gdb.execute("c")
res = bp.hit_count == 1
bp.delete()
return res
class WatchPoint(gdb.Breakpoint):
def __init__(self, sym_name, type):
super(WatchPoint, self).__init__(sym_name, gdb.BP_WATCHPOINT, type)
def stop(self):
end_pc = gdb.parse_and_eval('$pc')
print("HIT WP @ %s" % (end_pc))
return True
def do_one_watch(sym, wtype, text):
wp = WatchPoint(sym, wtype)
gdb.execute("c")
report_str = "%s for %s" % (text, sym)
if wp.hit_count > 0:
report(True, report_str)
else:
report(False, report_str)
wp.delete()
def check_watches(sym_name):
"Watch a symbol for any access."
# s390 only supports write watchpoints
if "s390" not in gdb.selected_frame().architecture().name():
# Should hit for any read
do_one_watch(sym_name, gdb.WP_ACCESS, "awatch")
# Again should hit for reads
do_one_watch(sym_name, gdb.WP_READ, "rwatch")
# Finally when it is written
do_one_watch(sym_name, gdb.WP_WRITE, "watch")
class CatchBreakpoint(gdb.Breakpoint):
def __init__(self, sym_name):
super(CatchBreakpoint, self).__init__(sym_name, type = gdb.BP_BREAKPOINT)
self.sym, ok = gdb.lookup_symbol(sym_name)
def stop(self):
end_pc = gdb.parse_and_eval('$pc')
print("CB: %s == %s" % (end_pc, self.sym.value()))
if end_pc == self.sym.value():
report(False, "Hit final catchpoint")
def run_test():
"Run through the tests one by one"
# get the initial register state
regs_start = parse_registers()
print("Checking we can step the first few instructions")
step_ok = 0
for i in range(3):
if check_step():
step_ok += 1
report(step_ok == 3, "single step in boot code")
# check some registers changed
print("Checking register access works")
check_reg_updates(regs_start)
print("Checking HW breakpoint works")
break_ok = check_hbreak("kernel_init")
report(break_ok, "hbreak @ kernel_init")
# Can't set this up until we are in the kernel proper
# if we make it to run_init_process we've over-run and
# one of the tests failed
print("Setup catch-all for run_init_process")
cbp = CatchBreakpoint("run_init_process")
# We should see wait_for_completion called right at the start of
# kernel_init
print("Checking Normal breakpoint works")
break_ok = check_break("wait_for_completion")
report(break_ok, "break @ wait_for_completion")
print("Checking watchpoint works")
check_watches("system_state")
# check we didn't hit the end
report(cbp.hit_count == 0, "CatchBreakpoint not hit")
main(run_test)