mirror of
https://github.com/mborgerson/xemu.git
synced 2026-03-26 03:24:42 +00:00
03ec40942d
If the reverse_debugging_run method fails, the GDB client will not be closed resulting in python complaining about resource leaks. Hoisting the GDB client creation into the caller allows this to be cleaned up easily. While doing this, also move the VM shutdown call to match. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> Message-ID: <20251014140047.385347-3-berrange@redhat.com> Reviewed-by: Thomas Huth <thuth@redhat.com> Signed-off-by: Thomas Huth <thuth@redhat.com>
198 lines
7.4 KiB
Python
198 lines
7.4 KiB
Python
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
#
|
|
# Reverse debugging test
|
|
#
|
|
# Copyright (c) 2020 ISP RAS
|
|
# Copyright (c) 2025 Linaro Limited
|
|
#
|
|
# Author:
|
|
# Pavel Dovgalyuk <Pavel.Dovgalyuk@ispras.ru>
|
|
# Gustavo Romero <gustavo.romero@linaro.org> (Run without Avocado)
|
|
#
|
|
# This work is licensed under the terms of the GNU GPL, version 2 or
|
|
# later. See the COPYING file in the top-level directory.
|
|
|
|
import logging
|
|
import os
|
|
from subprocess import check_output
|
|
|
|
from qemu_test import LinuxKernelTest, get_qemu_img, GDB, \
|
|
skipIfMissingEnv, skipIfMissingImports
|
|
from qemu_test.ports import Ports
|
|
|
|
|
|
class ReverseDebugging(LinuxKernelTest):
|
|
"""
|
|
Test GDB reverse debugging commands: reverse step and reverse continue.
|
|
Recording saves the execution of some instructions and makes an initial
|
|
VM snapshot to allow reverse execution.
|
|
Replay saves the order of the first instructions and then checks that they
|
|
are executed backwards in the correct order.
|
|
After that the execution is replayed to the end, and reverse continue
|
|
command is checked by setting several breakpoints, and asserting
|
|
that the execution is stopped at the last of them.
|
|
"""
|
|
|
|
STEPS = 10
|
|
|
|
def run_vm(self, record, shift, args, replay_path, image_path, port):
|
|
vm = self.get_vm(name='record' if record else 'replay')
|
|
vm.set_console()
|
|
if record:
|
|
self.log.info('recording the execution...')
|
|
mode = 'record'
|
|
else:
|
|
self.log.info('replaying the execution...')
|
|
mode = 'replay'
|
|
vm.add_args('-gdb', 'tcp::%d' % port, '-S')
|
|
vm.add_args('-icount', 'shift=%s,rr=%s,rrfile=%s,rrsnapshot=init' %
|
|
(shift, mode, replay_path),
|
|
'-net', 'none')
|
|
vm.add_args('-drive', 'file=%s,if=none' % image_path)
|
|
if args:
|
|
vm.add_args(*args)
|
|
vm.launch()
|
|
return vm
|
|
|
|
@staticmethod
|
|
def get_pc(gdb: GDB):
|
|
return gdb.cli("print $pc").get_addr()
|
|
|
|
@staticmethod
|
|
def vm_get_icount(vm):
|
|
return vm.qmp('query-replay')['return']['icount']
|
|
|
|
@skipIfMissingImports("pygdbmi") # Required by GDB class
|
|
@skipIfMissingEnv("QEMU_TEST_GDB")
|
|
def reverse_debugging(self, gdb_arch, shift=7, args=None):
|
|
from qemu_test import GDB
|
|
|
|
# create qcow2 for snapshots
|
|
self.log.info('creating qcow2 image for VM snapshots')
|
|
image_path = os.path.join(self.workdir, 'disk.qcow2')
|
|
qemu_img = get_qemu_img(self)
|
|
if qemu_img is None:
|
|
self.skipTest('Could not find "qemu-img", which is required to '
|
|
'create the temporary qcow2 image')
|
|
out = check_output([qemu_img, 'create', '-f', 'qcow2', image_path, '128M'],
|
|
encoding='utf8')
|
|
self.log.info("qemu-img: %s" % out)
|
|
|
|
replay_path = os.path.join(self.workdir, 'replay.bin')
|
|
|
|
# record the log
|
|
vm = self.run_vm(True, shift, args, replay_path, image_path, -1)
|
|
while self.vm_get_icount(vm) <= self.STEPS:
|
|
pass
|
|
last_icount = self.vm_get_icount(vm)
|
|
vm.shutdown()
|
|
|
|
self.log.info("recorded log with %s+ steps" % last_icount)
|
|
|
|
# replay and run debug commands
|
|
with Ports() as ports:
|
|
port = ports.find_free_port()
|
|
vm = self.run_vm(False, shift, args, replay_path, image_path, port)
|
|
|
|
try:
|
|
self.log.info('Connecting to gdbstub...')
|
|
gdb_cmd = os.getenv('QEMU_TEST_GDB')
|
|
gdb = GDB(gdb_cmd)
|
|
try:
|
|
self.reverse_debugging_run(gdb, vm, port, gdb_arch, last_icount)
|
|
finally:
|
|
self.log.info('exiting gdb and qemu')
|
|
gdb.exit()
|
|
vm.shutdown()
|
|
self.log.info('Test passed.')
|
|
except GDB.TimeoutError:
|
|
# Convert a GDB timeout exception into a unittest failure exception.
|
|
raise self.failureException("Timeout while connecting to or "
|
|
"communicating with gdbstub...") from None
|
|
except Exception:
|
|
# Re-throw exceptions from unittest, like the ones caused by fail(),
|
|
# skipTest(), etc.
|
|
raise
|
|
|
|
def reverse_debugging_run(self, gdb, vm, port, gdb_arch, last_icount):
|
|
r = gdb.cli("set architecture").get_log()
|
|
if gdb_arch not in r:
|
|
self.skipTest(f"GDB does not support arch '{gdb_arch}'")
|
|
|
|
gdb.cli("set debug remote 1")
|
|
|
|
c = gdb.cli(f"target remote localhost:{port}").get_console()
|
|
if not f"Remote debugging using localhost:{port}" in c:
|
|
self.fail("Could not connect to gdbstub!")
|
|
|
|
# Remote debug messages are in 'log' payloads.
|
|
r = gdb.get_log()
|
|
if 'ReverseStep+' not in r:
|
|
self.fail('Reverse step is not supported by QEMU')
|
|
if 'ReverseContinue+' not in r:
|
|
self.fail('Reverse continue is not supported by QEMU')
|
|
|
|
gdb.cli("set debug remote 0")
|
|
|
|
self.log.info('stepping forward')
|
|
steps = []
|
|
# record first instruction addresses
|
|
for _ in range(self.STEPS):
|
|
pc = self.get_pc(gdb)
|
|
self.log.info('saving position %x' % pc)
|
|
steps.append(pc)
|
|
gdb.cli("stepi")
|
|
|
|
# visit the recorded instruction in reverse order
|
|
self.log.info('stepping backward')
|
|
for addr in steps[::-1]:
|
|
self.log.info('found position %x' % addr)
|
|
gdb.cli("reverse-stepi")
|
|
pc = self.get_pc(gdb)
|
|
if pc != addr:
|
|
self.log.info('Invalid PC (read %x instead of %x)' % (pc, addr))
|
|
self.fail('Reverse stepping failed!')
|
|
|
|
# visit the recorded instruction in forward order
|
|
self.log.info('stepping forward')
|
|
for addr in steps:
|
|
self.log.info('found position %x' % addr)
|
|
pc = self.get_pc(gdb)
|
|
if pc != addr:
|
|
self.log.info('Invalid PC (read %x instead of %x)' % (pc, addr))
|
|
self.fail('Forward stepping failed!')
|
|
gdb.cli("stepi")
|
|
|
|
# set breakpoints for the instructions just stepped over
|
|
self.log.info('setting breakpoints')
|
|
for addr in steps:
|
|
gdb.cli(f"break *{hex(addr)}")
|
|
|
|
# this may hit a breakpoint if first instructions are executed
|
|
# again
|
|
self.log.info('continuing execution')
|
|
vm.qmp('replay-break', icount=last_icount - 1)
|
|
# continue - will return after pausing
|
|
# This can stop at the end of the replay-break and gdb gets a SIGINT,
|
|
# or by re-executing one of the breakpoints and gdb stops at a
|
|
# breakpoint.
|
|
gdb.cli("continue")
|
|
|
|
if self.vm_get_icount(vm) == last_icount - 1:
|
|
self.log.info('reached the end (icount %s)' % (last_icount - 1))
|
|
else:
|
|
self.log.info('hit a breakpoint again at %x (icount %s)' %
|
|
(self.get_pc(gdb), self.vm_get_icount(vm)))
|
|
|
|
self.log.info('running reverse continue to reach %x' % steps[-1])
|
|
# reverse continue - will return after stopping at the breakpoint
|
|
gdb.cli("reverse-continue")
|
|
|
|
# assume that none of the first instructions is executed again
|
|
# breaking the order of the breakpoints
|
|
pc = self.get_pc(gdb)
|
|
if pc != steps[-1]:
|
|
self.fail("'reverse-continue' did not hit the first PC in reverse order!")
|
|
|
|
self.log.info('successfully reached %x' % steps[-1])
|