mirror of
https://github.com/cirosantilli/linux-kernel-module-cheat.git
synced 2026-01-13 20:12:26 +00:00
239 lines
7.8 KiB
Python
Executable File
239 lines
7.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import imp
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
|
|
import common
|
|
|
|
defaults = {
|
|
'after': '',
|
|
'before': '',
|
|
'break_at': None,
|
|
'kgdb': False,
|
|
'no_continue': False,
|
|
'no_lxsymbols': False,
|
|
'test': False,
|
|
'sim': False,
|
|
'userland': None,
|
|
}
|
|
|
|
class GdbTestcase:
|
|
def __init__(
|
|
self,
|
|
source_path,
|
|
test_script_path,
|
|
cmd,
|
|
verbose=False
|
|
):
|
|
'''
|
|
:param verbose: if True, print extra debug information to help understand
|
|
why a test is not working
|
|
'''
|
|
self.prompt = '\(gdb\) '
|
|
self.source_path = source_path
|
|
self.print_cmd(cmd)
|
|
cmd = self.strip_newlines(cmd)
|
|
import pexpect
|
|
self.child = pexpect.spawn(
|
|
cmd[0],
|
|
cmd[1:],
|
|
encoding='utf-8'
|
|
)
|
|
if verbose:
|
|
self.child.logfile = sys.stdout
|
|
self.child.setecho(False)
|
|
self.child.waitnoecho()
|
|
self.child.expect(self.prompt)
|
|
test = imp.load_source('test', test_script_path)
|
|
test.test(self)
|
|
self.child.sendcontrol('d')
|
|
self.child.close()
|
|
|
|
def before(self):
|
|
return self.child.before.rstrip()
|
|
|
|
def continue_to(self, lineid):
|
|
line_number = self.find_line(lineid)
|
|
self.sendline('tbreak {}'.format(line_number))
|
|
self.sendline('continue')
|
|
|
|
def get_int(self, int_id):
|
|
self.sendline('printf "%d\\n", {}'.format(int_id))
|
|
return int(self.before())
|
|
|
|
def get_float(self, float_id):
|
|
self.sendline('printf "%f\\n", {}'.format(float_id))
|
|
return float(self.before())
|
|
|
|
def find_line(self, lineid):
|
|
'''
|
|
Search for the first line that contains a comment line
|
|
that ends in /* test-gdb-<lineid> */ and return the line number.
|
|
'''
|
|
lineend = '/* test-gdb-' + lineid + ' */'
|
|
with open(self.source_path, 'r') as f:
|
|
for i, line in enumerate(f):
|
|
if line.rstrip().endswith(lineend):
|
|
return i + 1
|
|
return -1
|
|
|
|
def sendline(self, line):
|
|
self.child.sendline(line)
|
|
self.child.expect(self.prompt)
|
|
|
|
def main(args, extra_args=None):
|
|
'''
|
|
:param args: argparse parse_argument() output. Must contain all the common options,
|
|
but does not need GDB specific ones.
|
|
:type args: argparse.Namespace
|
|
|
|
:param extra_args: extra arguments to be added to args
|
|
:type extra_args: Dict[str,Any]
|
|
|
|
:return: GDB exit status
|
|
:rtype: int
|
|
'''
|
|
global defaults
|
|
args = self.resolve_args(defaults, args, extra_args)
|
|
after = self.sh.shlex_split(kwargs['after'])
|
|
before = self.sh.shlex_split(kwargs['before'])
|
|
no_continue = kwargs['no_continue']
|
|
if kwargs['test']:
|
|
no_continue = True
|
|
before.extend([
|
|
'-q', LF,
|
|
'-nh', LF,
|
|
'-ex', 'set confirm off', LF
|
|
])
|
|
elif kwargs['verbose']:
|
|
# The output of this would affect the tests.
|
|
# https://stackoverflow.com/questions/13496389/gdb-remote-protocol-how-to-analyse-packets
|
|
# Also be opinionated and set remotetimeout to allow you to step debug the emulator at the same time.
|
|
before.extend([
|
|
'-ex', 'set debug remote 1', LF,
|
|
'-ex', 'set remotetimeout 99999', LF,
|
|
])
|
|
if kwargs['break_at'] is not None:
|
|
break_at = ['-ex', 'break {}'.format(kwargs['break_at']), LF]
|
|
else:
|
|
break_at = []
|
|
linux_full_system = (kwargs['baremetal'] is None and kwargs['userland'] is None)
|
|
if kwargs['userland']:
|
|
image = self.resolve_userland(kwargs['userland'])
|
|
elif kwargs['baremetal']:
|
|
image = kwargs['image']
|
|
test_script_path = os.path.splitext(kwargs['source_path'])[0] + '.py'
|
|
else:
|
|
image = kwargs['vmlinux']
|
|
if kwargs['baremetal']:
|
|
allowed_toolchains = ['crosstool-ng', 'buildroot', 'host']
|
|
else:
|
|
allowed_toolchains = ['buildroot', 'crosstool-ng', 'host']
|
|
cmd = (
|
|
[self.get_toolchain_tool('gdb', allowed_toolchains=allowed_toolchains), LF] +
|
|
before +
|
|
['-q', LF]
|
|
)
|
|
if linux_full_system:
|
|
cmd.extend(['-ex', 'add-auto-load-safe-path {}'.format(kwargs['linux_build_dir']), LF])
|
|
if kwargs['sim']:
|
|
target = 'sim'
|
|
else:
|
|
if kwargs['kgdb']:
|
|
port = kwargs['extra_serial_port']
|
|
else:
|
|
port = kwargs['gdb_port']
|
|
target = 'remote localhost:{}'.format(port)
|
|
cmd.extend([
|
|
'-ex', 'file {}'.format(image), LF,
|
|
'-ex', 'target {}'.format(target), LF,
|
|
])
|
|
if not kwargs['kgdb']:
|
|
cmd.extend(break_at)
|
|
if not no_continue:
|
|
# ## lx-symbols
|
|
#
|
|
# ### lx-symbols after continue
|
|
#
|
|
# lx symbols must be run after continue.
|
|
#
|
|
# running it immediately after the connect on the bootloader leads to failure,
|
|
# likely because kernel structure on which it depends are not yet available.
|
|
#
|
|
# With this setup, continue runs, and lx-symbols only runs when a break happens,
|
|
# either by hitting the breakpoint, or by entering Ctrl + C.
|
|
#
|
|
# Sure, if the user sets a break on a raw address of the bootloader,
|
|
# problems will still arise, but let's think about that some other time.
|
|
#
|
|
# ### lx-symbols autoload
|
|
#
|
|
# The lx-symbols commands gets loaded through the file vmlinux-gdb.py
|
|
# which gets put on the kernel build root when python debugging scripts are enabled.
|
|
cmd.extend(['-ex', 'continue', LF])
|
|
if not kwargs['no_lxsymbols'] and linux_full_system:
|
|
cmd.extend(['-ex', 'lx-symbols {}'.format(kwargs['kernel_modules_build_subdir']), LF])
|
|
cmd.extend(after)
|
|
if kwargs['test']:
|
|
GdbTestcase(
|
|
kwargs['source_path'],
|
|
test_script_path,
|
|
cmd,
|
|
verbose=kwargs['verbose'],
|
|
)
|
|
else:
|
|
# I would rather have cwd be out_rootfs_overlay_dir,
|
|
# but then lx-symbols cannot fine the vmlinux and fails with:
|
|
# vmlinux: No such file or directory.
|
|
return self.sh.run_cmd(
|
|
cmd,
|
|
cmd_file=os.path.join(kwargs['run_dir'], 'run-gdb.sh'),
|
|
cwd=kwargs['linux_build_dir']
|
|
)
|
|
|
|
if __name__ == '__main__':
|
|
parser = self.get_argparse(argparse_args={'description': 'Connect with GDB to an emulator to debug Linux itself'})
|
|
parser.add_argument(
|
|
'-A', '--after', default=defaults['after'],
|
|
help='Pass extra arguments to GDB, to be appended after all other arguments'
|
|
)
|
|
parser.add_argument(
|
|
'--before', default=defaults['before'],
|
|
help='Pass extra arguments to GDB to be prepended before any of the arguments passed by this script'
|
|
)
|
|
parser.add_argument(
|
|
'-C', '--no-continue', default=defaults['no_continue'],
|
|
help="Don't run continue after connecting"
|
|
)
|
|
parser.add_argument(
|
|
'-k', '--kgdb', default=defaults['kgdb'],
|
|
)
|
|
parser.add_argument(
|
|
'--sim', default=defaults['sim'],
|
|
help='''Use the built-in GDB CPU simulator
|
|
See: https://github.com/cirosantilli/linux-kernel-module-cheat#gdb-builtin-cpu-simulator
|
|
'''
|
|
)
|
|
parser.add_argument(
|
|
'-X', '--no-lxsymbols', default=defaults['no_lxsymbols'],
|
|
)
|
|
parser.add_argument(
|
|
'--test', default=defaults['test'],
|
|
help='''\
|
|
Run an expect test case instead of interactive usage. For baremetal and userland,
|
|
the script is a .py file next to the source code.
|
|
'''
|
|
)
|
|
parser.add_argument(
|
|
'-u', '--userland', default=defaults['userland'],
|
|
)
|
|
parser.add_argument(
|
|
'break_at', nargs='?',
|
|
help='Extra options to append at the end of the emulator command line'
|
|
)
|
|
args = self.setup(parser)
|
|
sys.exit(main(args))
|