471 lines
19 KiB
Python
Executable file
471 lines
19 KiB
Python
Executable file
#!/usr/bin/env python
|
|
|
|
# ----------------------------------------------------------------------
|
|
# Be sure to add the python path that points to the LLDB shared library.
|
|
# On MacOSX csh, tcsh:
|
|
# setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
|
|
# On MacOSX sh, bash:
|
|
# export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
|
|
# ----------------------------------------------------------------------
|
|
|
|
import optparse
|
|
import os
|
|
import platform
|
|
import sys
|
|
import subprocess
|
|
|
|
# ----------------------------------------------------------------------
|
|
# Code that auto imports LLDB
|
|
# ----------------------------------------------------------------------
|
|
try:
|
|
# Just try for LLDB in case PYTHONPATH is already correctly setup
|
|
import lldb
|
|
except ImportError:
|
|
lldb_python_dirs = list()
|
|
# lldb is not in the PYTHONPATH, try some defaults for the current platform
|
|
platform_system = platform.system()
|
|
if platform_system == "Darwin":
|
|
# On Darwin, try the currently selected Xcode directory
|
|
xcode_dir = subprocess.check_output("xcode-select --print-path", shell=True)
|
|
if xcode_dir:
|
|
lldb_python_dirs.append(
|
|
os.path.realpath(
|
|
xcode_dir + "/../SharedFrameworks/LLDB.framework/Resources/Python"
|
|
)
|
|
)
|
|
lldb_python_dirs.append(
|
|
xcode_dir + "/Library/PrivateFrameworks/LLDB.framework/Resources/Python"
|
|
)
|
|
lldb_python_dirs.append(
|
|
"/System/Library/PrivateFrameworks/LLDB.framework/Resources/Python"
|
|
)
|
|
success = False
|
|
for lldb_python_dir in lldb_python_dirs:
|
|
if os.path.exists(lldb_python_dir):
|
|
if not (sys.path.__contains__(lldb_python_dir)):
|
|
sys.path.append(lldb_python_dir)
|
|
try:
|
|
import lldb
|
|
except ImportError:
|
|
pass
|
|
else:
|
|
print('imported lldb from: "%s"' % (lldb_python_dir))
|
|
success = True
|
|
break
|
|
if not success:
|
|
print(
|
|
"error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
|
|
)
|
|
sys.exit(1)
|
|
|
|
|
|
def print_threads(process, options):
|
|
if options.show_threads:
|
|
for thread in process:
|
|
print("%s %s" % (thread, thread.GetFrameAtIndex(0)))
|
|
|
|
|
|
def run_commands(command_interpreter, commands):
|
|
return_obj = lldb.SBCommandReturnObject()
|
|
for command in commands:
|
|
command_interpreter.HandleCommand(command, return_obj)
|
|
if return_obj.Succeeded():
|
|
print(return_obj.GetOutput())
|
|
else:
|
|
print(return_obj)
|
|
if options.stop_on_error:
|
|
break
|
|
|
|
|
|
def main(argv):
|
|
description = """Debugs a program using the LLDB python API and uses asynchronous broadcast events to watch for process state changes."""
|
|
epilog = """Examples:
|
|
|
|
#----------------------------------------------------------------------
|
|
# Run "/bin/ls" with the arguments "-lAF /tmp/", and set a breakpoint
|
|
# at "malloc" and backtrace and read all registers each time we stop
|
|
#----------------------------------------------------------------------
|
|
% ./process_events.py --breakpoint malloc --stop-command bt --stop-command 'register read' -- /bin/ls -lAF /tmp/
|
|
|
|
"""
|
|
optparse.OptionParser.format_epilog = lambda self, formatter: self.epilog
|
|
parser = optparse.OptionParser(
|
|
description=description,
|
|
prog="process_events",
|
|
usage="usage: process_events [options] program [arg1 arg2]",
|
|
epilog=epilog,
|
|
)
|
|
parser.add_option(
|
|
"-v",
|
|
"--verbose",
|
|
action="store_true",
|
|
dest="verbose",
|
|
help="Enable verbose logging.",
|
|
default=False,
|
|
)
|
|
parser.add_option(
|
|
"-b",
|
|
"--breakpoint",
|
|
action="append",
|
|
type="string",
|
|
metavar="BPEXPR",
|
|
dest="breakpoints",
|
|
help='Breakpoint commands to create after the target has been created, the values will be sent to the "_regexp-break" command which supports breakpoints by name, file:line, and address.',
|
|
)
|
|
parser.add_option(
|
|
"-a",
|
|
"--arch",
|
|
type="string",
|
|
dest="arch",
|
|
help="The architecture to use when creating the debug target.",
|
|
default=None,
|
|
)
|
|
parser.add_option(
|
|
"--platform",
|
|
type="string",
|
|
metavar="platform",
|
|
dest="platform",
|
|
help='Specify the platform to use when creating the debug target. Valid values include "localhost", "darwin-kernel", "ios-simulator", "remote-freebsd", "remote-macosx", "remote-ios", "remote-linux".',
|
|
default=None,
|
|
)
|
|
parser.add_option(
|
|
"-l",
|
|
"--launch-command",
|
|
action="append",
|
|
type="string",
|
|
metavar="CMD",
|
|
dest="launch_commands",
|
|
help="LLDB command interpreter commands to run once after the process has launched. This option can be specified more than once.",
|
|
default=[],
|
|
)
|
|
parser.add_option(
|
|
"-s",
|
|
"--stop-command",
|
|
action="append",
|
|
type="string",
|
|
metavar="CMD",
|
|
dest="stop_commands",
|
|
help="LLDB command interpreter commands to run each time the process stops. This option can be specified more than once.",
|
|
default=[],
|
|
)
|
|
parser.add_option(
|
|
"-c",
|
|
"--crash-command",
|
|
action="append",
|
|
type="string",
|
|
metavar="CMD",
|
|
dest="crash_commands",
|
|
help="LLDB command interpreter commands to run in case the process crashes. This option can be specified more than once.",
|
|
default=[],
|
|
)
|
|
parser.add_option(
|
|
"-x",
|
|
"--exit-command",
|
|
action="append",
|
|
type="string",
|
|
metavar="CMD",
|
|
dest="exit_commands",
|
|
help="LLDB command interpreter commands to run once after the process has exited. This option can be specified more than once.",
|
|
default=[],
|
|
)
|
|
parser.add_option(
|
|
"-T",
|
|
"--no-threads",
|
|
action="store_false",
|
|
dest="show_threads",
|
|
help="Don't show threads when process stops.",
|
|
default=True,
|
|
)
|
|
parser.add_option(
|
|
"--ignore-errors",
|
|
action="store_false",
|
|
dest="stop_on_error",
|
|
help="Don't stop executing LLDB commands if the command returns an error. This applies to all of the LLDB command interpreter commands that get run for launch, stop, crash and exit.",
|
|
default=True,
|
|
)
|
|
parser.add_option(
|
|
"-n",
|
|
"--run-count",
|
|
type="int",
|
|
dest="run_count",
|
|
metavar="N",
|
|
help="How many times to run the process in case the process exits.",
|
|
default=1,
|
|
)
|
|
parser.add_option(
|
|
"-t",
|
|
"--event-timeout",
|
|
type="int",
|
|
dest="event_timeout",
|
|
metavar="SEC",
|
|
help="Specify the timeout in seconds to wait for process state change events.",
|
|
default=lldb.UINT32_MAX,
|
|
)
|
|
parser.add_option(
|
|
"-e",
|
|
"--environment",
|
|
action="append",
|
|
type="string",
|
|
metavar="ENV",
|
|
dest="env_vars",
|
|
help="Environment variables to set in the inferior process when launching a process.",
|
|
)
|
|
parser.add_option(
|
|
"-d",
|
|
"--working-dir",
|
|
type="string",
|
|
metavar="DIR",
|
|
dest="working_dir",
|
|
help="The current working directory when launching a process.",
|
|
default=None,
|
|
)
|
|
parser.add_option(
|
|
"-p",
|
|
"--attach-pid",
|
|
type="int",
|
|
dest="attach_pid",
|
|
metavar="PID",
|
|
help="Specify a process to attach to by process ID.",
|
|
default=-1,
|
|
)
|
|
parser.add_option(
|
|
"-P",
|
|
"--attach-name",
|
|
type="string",
|
|
dest="attach_name",
|
|
metavar="PROCESSNAME",
|
|
help="Specify a process to attach to by name.",
|
|
default=None,
|
|
)
|
|
parser.add_option(
|
|
"-w",
|
|
"--attach-wait",
|
|
action="store_true",
|
|
dest="attach_wait",
|
|
help="Wait for the next process to launch when attaching to a process by name.",
|
|
default=False,
|
|
)
|
|
try:
|
|
(options, args) = parser.parse_args(argv)
|
|
except:
|
|
return
|
|
|
|
attach_info = None
|
|
launch_info = None
|
|
exe = None
|
|
if args:
|
|
exe = args.pop(0)
|
|
launch_info = lldb.SBLaunchInfo(args)
|
|
if options.env_vars:
|
|
launch_info.SetEnvironmentEntries(options.env_vars, True)
|
|
if options.working_dir:
|
|
launch_info.SetWorkingDirectory(options.working_dir)
|
|
elif options.attach_pid != -1:
|
|
if options.run_count == 1:
|
|
attach_info = lldb.SBAttachInfo(options.attach_pid)
|
|
else:
|
|
print("error: --run-count can't be used with the --attach-pid option")
|
|
sys.exit(1)
|
|
elif not options.attach_name is None:
|
|
if options.run_count == 1:
|
|
attach_info = lldb.SBAttachInfo(options.attach_name, options.attach_wait)
|
|
else:
|
|
print("error: --run-count can't be used with the --attach-name option")
|
|
sys.exit(1)
|
|
else:
|
|
print(
|
|
"error: a program path for a program to debug and its arguments are required"
|
|
)
|
|
sys.exit(1)
|
|
|
|
# Create a new debugger instance
|
|
debugger = lldb.SBDebugger.Create()
|
|
debugger.SetAsync(True)
|
|
command_interpreter = debugger.GetCommandInterpreter()
|
|
# Create a target from a file and arch
|
|
|
|
if exe:
|
|
print("Creating a target for '%s'" % exe)
|
|
error = lldb.SBError()
|
|
target = debugger.CreateTarget(exe, options.arch, options.platform, True, error)
|
|
|
|
if target:
|
|
# Set any breakpoints that were specified in the args if we are launching. We use the
|
|
# command line command to take advantage of the shorthand breakpoint
|
|
# creation
|
|
if launch_info and options.breakpoints:
|
|
for bp in options.breakpoints:
|
|
debugger.HandleCommand("_regexp-break %s" % (bp))
|
|
run_commands(command_interpreter, ["breakpoint list"])
|
|
|
|
for run_idx in range(options.run_count):
|
|
# Launch the process. Since we specified synchronous mode, we won't return
|
|
# from this function until we hit the breakpoint at main
|
|
error = lldb.SBError()
|
|
|
|
if launch_info:
|
|
if options.run_count == 1:
|
|
print('Launching "%s"...' % (exe))
|
|
else:
|
|
print(
|
|
'Launching "%s"... (launch %u of %u)'
|
|
% (exe, run_idx + 1, options.run_count)
|
|
)
|
|
|
|
process = target.Launch(launch_info, error)
|
|
else:
|
|
if options.attach_pid != -1:
|
|
print("Attaching to process %i..." % (options.attach_pid))
|
|
else:
|
|
if options.attach_wait:
|
|
print(
|
|
'Waiting for next to process named "%s" to launch...'
|
|
% (options.attach_name)
|
|
)
|
|
else:
|
|
print(
|
|
'Attaching to existing process named "%s"...'
|
|
% (options.attach_name)
|
|
)
|
|
process = target.Attach(attach_info, error)
|
|
|
|
# Make sure the launch went ok
|
|
if process and process.GetProcessID() != lldb.LLDB_INVALID_PROCESS_ID:
|
|
pid = process.GetProcessID()
|
|
print("Process is %i" % (pid))
|
|
if attach_info:
|
|
# continue process if we attached as we won't get an
|
|
# initial event
|
|
process.Continue()
|
|
|
|
listener = debugger.GetListener()
|
|
# sign up for process state change events
|
|
stop_idx = 0
|
|
done = False
|
|
while not done:
|
|
event = lldb.SBEvent()
|
|
if listener.WaitForEvent(options.event_timeout, event):
|
|
if lldb.SBProcess.EventIsProcessEvent(event):
|
|
state = lldb.SBProcess.GetStateFromEvent(event)
|
|
if state == lldb.eStateInvalid:
|
|
# Not a state event
|
|
print("process event = %s" % (event))
|
|
else:
|
|
print(
|
|
"process state changed event: %s"
|
|
% (lldb.SBDebugger.StateAsCString(state))
|
|
)
|
|
if state == lldb.eStateStopped:
|
|
if stop_idx == 0:
|
|
if launch_info:
|
|
print("process %u launched" % (pid))
|
|
run_commands(
|
|
command_interpreter, ["breakpoint list"]
|
|
)
|
|
else:
|
|
print("attached to process %u" % (pid))
|
|
for m in target.modules:
|
|
print(m)
|
|
if options.breakpoints:
|
|
for bp in options.breakpoints:
|
|
debugger.HandleCommand(
|
|
"_regexp-break %s" % (bp)
|
|
)
|
|
run_commands(
|
|
command_interpreter,
|
|
["breakpoint list"],
|
|
)
|
|
run_commands(
|
|
command_interpreter, options.launch_commands
|
|
)
|
|
else:
|
|
if options.verbose:
|
|
print("process %u stopped" % (pid))
|
|
run_commands(
|
|
command_interpreter, options.stop_commands
|
|
)
|
|
stop_idx += 1
|
|
print_threads(process, options)
|
|
print("continuing process %u" % (pid))
|
|
process.Continue()
|
|
elif state == lldb.eStateExited:
|
|
exit_desc = process.GetExitDescription()
|
|
if exit_desc:
|
|
print(
|
|
"process %u exited with status %u: %s"
|
|
% (pid, process.GetExitStatus(), exit_desc)
|
|
)
|
|
else:
|
|
print(
|
|
"process %u exited with status %u"
|
|
% (pid, process.GetExitStatus())
|
|
)
|
|
run_commands(
|
|
command_interpreter, options.exit_commands
|
|
)
|
|
done = True
|
|
elif state == lldb.eStateCrashed:
|
|
print("process %u crashed" % (pid))
|
|
print_threads(process, options)
|
|
run_commands(
|
|
command_interpreter, options.crash_commands
|
|
)
|
|
done = True
|
|
elif state == lldb.eStateDetached:
|
|
print("process %u detached" % (pid))
|
|
done = True
|
|
elif state == lldb.eStateRunning:
|
|
# process is running, don't say anything,
|
|
# we will always get one of these after
|
|
# resuming
|
|
if options.verbose:
|
|
print("process %u resumed" % (pid))
|
|
elif state == lldb.eStateUnloaded:
|
|
print(
|
|
"process %u unloaded, this shouldn't happen"
|
|
% (pid)
|
|
)
|
|
done = True
|
|
elif state == lldb.eStateConnected:
|
|
print("process connected")
|
|
elif state == lldb.eStateAttaching:
|
|
print("process attaching")
|
|
elif state == lldb.eStateLaunching:
|
|
print("process launching")
|
|
else:
|
|
print("event = %s" % (event))
|
|
else:
|
|
# timeout waiting for an event
|
|
print(
|
|
"no process event for %u seconds, killing the process..."
|
|
% (options.event_timeout)
|
|
)
|
|
done = True
|
|
# Now that we are done dump the stdout and stderr
|
|
process_stdout = process.GetSTDOUT(1024)
|
|
if process_stdout:
|
|
print("Process STDOUT:\n%s" % (process_stdout))
|
|
while process_stdout:
|
|
process_stdout = process.GetSTDOUT(1024)
|
|
print(process_stdout)
|
|
process_stderr = process.GetSTDERR(1024)
|
|
if process_stderr:
|
|
print("Process STDERR:\n%s" % (process_stderr))
|
|
while process_stderr:
|
|
process_stderr = process.GetSTDERR(1024)
|
|
print(process_stderr)
|
|
process.Kill() # kill the process
|
|
else:
|
|
if error:
|
|
print(error)
|
|
else:
|
|
if launch_info:
|
|
print("error: launch failed")
|
|
else:
|
|
print("error: attach failed")
|
|
|
|
lldb.SBDebugger.Terminate()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main(sys.argv[1:])
|