mirror of
https://github.com/qemu/qemu.git
synced 2026-11-16 08:40:30 +00:00
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>
165 lines
4.3 KiB
Python
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)
|