gdb is only attached in the replay phase, and the recorded trace is
single-stepped to build up an address map that is used to then verify
reverse-step and reverse-continue.
This change attaches gdb in the record phase, and builds the address
map by single-stepping the live machine. That address map is then
verified by single-stepping the replay, and then used for the same
reverse debug verification.
This is a stronger verifcation between the record and the replay phases,
as well as providing some testing of gdb operation in record mode.
x86_64 has problems with taking the first step, it does not advance the
icount, so a workaround is added for it.
Signed-off-by: Nicholas Piggin <npig...@gmail.com>
---
tests/avocado/reverse_debugging.py | 68 +++++++++++++++++++++++++-----
1 file changed, 58 insertions(+), 10 deletions(-)
diff --git a/tests/avocado/reverse_debugging.py
b/tests/avocado/reverse_debugging.py
index e76cf54ad7..8a9578ad5a 100644
--- a/tests/avocado/reverse_debugging.py
+++ b/tests/avocado/reverse_debugging.py
@@ -35,6 +35,10 @@ class ReverseDebugging(LinuxKernelTest):
STEPS = 10
endian_is_le = True
+ # If first_step_workaround is true, check whether the first step moved
+ # icount, and if not then step again.
+ first_step_workaround = False
+
def run_vm(self, record, shift, args, replay_path, image_path, port):
logger = logging.getLogger('replay')
vm = self.get_vm()
@@ -45,7 +49,7 @@ def run_vm(self, record, shift, args, replay_path,
image_path, port):
else:
logger.info('replaying the execution...')
mode = 'replay'
- vm.add_args('-gdb', 'tcp::%d' % port, '-S')
+ 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')
@@ -87,6 +91,17 @@ def check_pc(self, g, addr):
if pc != addr:
self.fail('Invalid PC (read %x instead of %x)' % (pc, addr))
+ @staticmethod
+ def gdb_cont(g):
+ g.cmd(b'c')
+
+ @staticmethod
+ def gdb_cont_nowait(g):
+ # The avocado GDBRemote does not have a good way to disconnect or
+ # continue without waiting for a reply, so open-code our own here.
+ data = g.encode(b'c')
+ g._socket.send(data)
+
@staticmethod
def gdb_step(g):
g.cmd(b's', b'T05thread:01;')
@@ -117,11 +132,40 @@ def reverse_debugging(self, shift=7, args=None):
replay_path = os.path.join(self.workdir, 'replay.bin')
port = find_free_port()
+ steps = []
+
# record the log
vm = self.run_vm(True, shift, args, replay_path, image_path, port)
+ logger.info('connecting to gdbstub')
+ g = gdb.GDBRemote('127.0.0.1', port, False, False)
+ g.connect()
+ r = g.cmd(b'qSupported')
+ if b'qXfer:features:read+' in r:
+ g.cmd(b'qXfer:features:read:target.xml:0,ffb')
+
+ if self.vm_get_icount(vm) != 0:
+ self.fail('icount does not start at zero')
+
+ # save the addresses of the first STEPS instructions executed
+ logger.info('stepping forward')
+ for i in range(self.STEPS):
+ pc = self.get_pc(g)
+ logger.info('saving position %x' % pc)
+ steps.append(pc)
+ self.gdb_step(g)
+ if self.first_step_workaround and i == 0 and
self.vm_get_icount(vm) == 0:
+ logger.warn('failed to take first step, stepping again')
+ self.gdb_step(g)
+ if self.vm_get_icount(vm) != self.STEPS:
+ self.fail('icount (%d) does not match number of instructions
stepped' % self.vm_get_icount(vm))
+
+ logger.info('continue running')
+ self.gdb_cont_nowait(g)
+
while self.vm_get_icount(vm) <= self.STEPS:
pass
last_icount = self.vm_get_icount(vm)
+ logger.info('shutdown...')
vm.shutdown()
logger.info("recorded log with %s+ steps" % last_icount)
@@ -139,23 +183,23 @@ def reverse_debugging(self, shift=7, args=None):
if b'ReverseContinue+' not in r:
self.fail('Reverse continue is not supported by QEMU')
+ # Try single stepping
logger.info('stepping forward')
- steps = []
- # record first instruction addresses
- for _ in range(self.STEPS):
- pc = self.get_pc(g)
- logger.info('saving position %x' % pc)
- steps.append(pc)
+ for addr in steps:
+ # verify addresses match what initial execution saw
+ self.check_pc(g, addr)
self.gdb_step(g)
+ logger.info('found position %x' % addr)
- # visit the recorded instruction in reverse order
+ # Try reverse stepping
logger.info('stepping backward')
for addr in steps[::-1]:
self.gdb_bstep(g)
+ # verify addresses match what initial execution saw
self.check_pc(g, addr)
logger.info('found position %x' % addr)
- # visit the recorded instruction in forward order
+ # Step forward again
logger.info('stepping forward')
for addr in steps:
self.check_pc(g, addr)
@@ -175,7 +219,7 @@ def reverse_debugging(self, shift=7, args=None):
# continue - will return after pausing
# This could stop at the end and get a T02 return, or by
# re-executing one of the breakpoints and get a T05 return.
- g.cmd(b'c')
+ self.gdb_cont(g)
if self.vm_get_icount(vm) == last_icount - 1:
logger.info('reached the end (icount %s)' % (last_icount - 1))
else:
@@ -201,6 +245,10 @@ class ReverseDebugging_X86_64(ReverseDebugging):
REG_PC = 0x10
REG_CS = 0x12
+
+ # The initial step does not change pc on x86 for some reason.
+ first_step_workaround = True
+
def get_pc(self, g):
return self.get_reg_le(g, self.REG_PC) \
+ self.get_reg_le(g, self.REG_CS) * 0x10
--
2.42.0
