You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1632 lines
57 KiB
1632 lines
57 KiB
#!/usr/bin/env python
|
|
|
|
#----------------------------------------------------------------------
|
|
# This module will enable GDB remote packet logging when the
|
|
# 'start_gdb_log' command is called with a filename to log to. When the
|
|
# 'stop_gdb_log' command is called, it will disable the logging and
|
|
# print out statistics about how long commands took to execute and also
|
|
# will primnt ou
|
|
# Be sure to add the python path that points to the LLDB shared library.
|
|
#
|
|
# To use this in the embedded python interpreter using "lldb" just
|
|
# import it with the full path using the "command script import"
|
|
# command. This can be done from the LLDB command line:
|
|
# (lldb) command script import /path/to/gdbremote.py
|
|
# Or it can be added to your ~/.lldbinit file so this module is always
|
|
# available.
|
|
#----------------------------------------------------------------------
|
|
|
|
from __future__ import print_function
|
|
import binascii
|
|
import subprocess
|
|
import json
|
|
import math
|
|
import optparse
|
|
import os
|
|
import re
|
|
import shlex
|
|
import string
|
|
import sys
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
|
|
#----------------------------------------------------------------------
|
|
# Global variables
|
|
#----------------------------------------------------------------------
|
|
g_log_file = ''
|
|
g_byte_order = 'little'
|
|
g_number_regex = re.compile('^(0x[0-9a-fA-F]+|[0-9]+)')
|
|
g_thread_id_regex = re.compile('^(-1|[0-9a-fA-F]+|0)')
|
|
|
|
|
|
class TerminalColors:
|
|
'''Simple terminal colors class'''
|
|
|
|
def __init__(self, enabled=True):
|
|
# TODO: discover terminal type from "file" and disable if
|
|
# it can't handle the color codes
|
|
self.enabled = enabled
|
|
|
|
def reset(self):
|
|
'''Reset all terminal colors and formatting.'''
|
|
if self.enabled:
|
|
return "\x1b[0m"
|
|
return ''
|
|
|
|
def bold(self, on=True):
|
|
'''Enable or disable bold depending on the "on" parameter.'''
|
|
if self.enabled:
|
|
if on:
|
|
return "\x1b[1m"
|
|
else:
|
|
return "\x1b[22m"
|
|
return ''
|
|
|
|
def italics(self, on=True):
|
|
'''Enable or disable italics depending on the "on" parameter.'''
|
|
if self.enabled:
|
|
if on:
|
|
return "\x1b[3m"
|
|
else:
|
|
return "\x1b[23m"
|
|
return ''
|
|
|
|
def underline(self, on=True):
|
|
'''Enable or disable underline depending on the "on" parameter.'''
|
|
if self.enabled:
|
|
if on:
|
|
return "\x1b[4m"
|
|
else:
|
|
return "\x1b[24m"
|
|
return ''
|
|
|
|
def inverse(self, on=True):
|
|
'''Enable or disable inverse depending on the "on" parameter.'''
|
|
if self.enabled:
|
|
if on:
|
|
return "\x1b[7m"
|
|
else:
|
|
return "\x1b[27m"
|
|
return ''
|
|
|
|
def strike(self, on=True):
|
|
'''Enable or disable strike through depending on the "on" parameter.'''
|
|
if self.enabled:
|
|
if on:
|
|
return "\x1b[9m"
|
|
else:
|
|
return "\x1b[29m"
|
|
return ''
|
|
|
|
def black(self, fg=True):
|
|
'''Set the foreground or background color to black.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[30m"
|
|
else:
|
|
return "\x1b[40m"
|
|
return ''
|
|
|
|
def red(self, fg=True):
|
|
'''Set the foreground or background color to red.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[31m"
|
|
else:
|
|
return "\x1b[41m"
|
|
return ''
|
|
|
|
def green(self, fg=True):
|
|
'''Set the foreground or background color to green.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[32m"
|
|
else:
|
|
return "\x1b[42m"
|
|
return ''
|
|
|
|
def yellow(self, fg=True):
|
|
'''Set the foreground or background color to yellow.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[33m"
|
|
else:
|
|
return "\x1b[43m"
|
|
return ''
|
|
|
|
def blue(self, fg=True):
|
|
'''Set the foreground or background color to blue.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[34m"
|
|
else:
|
|
return "\x1b[44m"
|
|
return ''
|
|
|
|
def magenta(self, fg=True):
|
|
'''Set the foreground or background color to magenta.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[35m"
|
|
else:
|
|
return "\x1b[45m"
|
|
return ''
|
|
|
|
def cyan(self, fg=True):
|
|
'''Set the foreground or background color to cyan.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[36m"
|
|
else:
|
|
return "\x1b[46m"
|
|
return ''
|
|
|
|
def white(self, fg=True):
|
|
'''Set the foreground or background color to white.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[37m"
|
|
else:
|
|
return "\x1b[47m"
|
|
return ''
|
|
|
|
def default(self, fg=True):
|
|
'''Set the foreground or background color to the default.
|
|
The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.'''
|
|
if self.enabled:
|
|
if fg:
|
|
return "\x1b[39m"
|
|
else:
|
|
return "\x1b[49m"
|
|
return ''
|
|
|
|
|
|
def start_gdb_log(debugger, command, result, dict):
|
|
'''Start logging GDB remote packets by enabling logging with timestamps and
|
|
thread safe logging. Follow a call to this function with a call to "stop_gdb_log"
|
|
in order to dump out the commands.'''
|
|
global g_log_file
|
|
command_args = shlex.split(command)
|
|
usage = "usage: start_gdb_log [options] [<LOGFILEPATH>]"
|
|
description = '''The command enables GDB remote packet logging with timestamps. The packets will be logged to <LOGFILEPATH> if supplied, or a temporary file will be used. Logging stops when stop_gdb_log is called and the packet times will
|
|
be aggregated and displayed.'''
|
|
parser = optparse.OptionParser(
|
|
description=description,
|
|
prog='start_gdb_log',
|
|
usage=usage)
|
|
parser.add_option(
|
|
'-v',
|
|
'--verbose',
|
|
action='store_true',
|
|
dest='verbose',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
try:
|
|
(options, args) = parser.parse_args(command_args)
|
|
except:
|
|
return
|
|
|
|
if g_log_file:
|
|
result.PutCString(
|
|
'error: logging is already in progress with file "%s"' %
|
|
g_log_file)
|
|
else:
|
|
args_len = len(args)
|
|
if args_len == 0:
|
|
g_log_file = tempfile.mktemp()
|
|
elif len(args) == 1:
|
|
g_log_file = args[0]
|
|
|
|
if g_log_file:
|
|
debugger.HandleCommand(
|
|
'log enable --threadsafe --timestamp --file "%s" gdb-remote packets' %
|
|
g_log_file)
|
|
result.PutCString(
|
|
"GDB packet logging enable with log file '%s'\nUse the 'stop_gdb_log' command to stop logging and show packet statistics." %
|
|
g_log_file)
|
|
return
|
|
|
|
result.PutCString('error: invalid log file path')
|
|
result.PutCString(usage)
|
|
|
|
|
|
def stop_gdb_log(debugger, command, result, dict):
|
|
'''Stop logging GDB remote packets to the file that was specified in a call
|
|
to "start_gdb_log" and normalize the timestamps to be relative to the first
|
|
timestamp in the log file. Also print out statistics for how long each
|
|
command took to allow performance bottlenecks to be determined.'''
|
|
global g_log_file
|
|
# Any commands whose names might be followed by more valid C identifier
|
|
# characters must be listed here
|
|
command_args = shlex.split(command)
|
|
usage = "usage: stop_gdb_log [options]"
|
|
description = '''The command stops a previously enabled GDB remote packet logging command. Packet logging must have been previously enabled with a call to start_gdb_log.'''
|
|
parser = optparse.OptionParser(
|
|
description=description,
|
|
prog='stop_gdb_log',
|
|
usage=usage)
|
|
parser.add_option(
|
|
'-v',
|
|
'--verbose',
|
|
action='store_true',
|
|
dest='verbose',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'-q',
|
|
'--quiet',
|
|
action='store_true',
|
|
dest='quiet',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'-C',
|
|
'--color',
|
|
action='store_true',
|
|
dest='color',
|
|
help='add terminal colors',
|
|
default=False)
|
|
parser.add_option(
|
|
'-c',
|
|
'--sort-by-count',
|
|
action='store_true',
|
|
dest='sort_count',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'-s',
|
|
'--symbolicate',
|
|
action='store_true',
|
|
dest='symbolicate',
|
|
help='symbolicate addresses in log using current "lldb.target"',
|
|
default=False)
|
|
try:
|
|
(options, args) = parser.parse_args(command_args)
|
|
except:
|
|
return
|
|
options.colors = TerminalColors(options.color)
|
|
options.symbolicator = None
|
|
if options.symbolicate:
|
|
if lldb.target:
|
|
import lldb.utils.symbolication
|
|
options.symbolicator = lldb.utils.symbolication.Symbolicator()
|
|
options.symbolicator.target = lldb.target
|
|
else:
|
|
print("error: can't symbolicate without a target")
|
|
|
|
if not g_log_file:
|
|
result.PutCString(
|
|
'error: logging must have been previously enabled with a call to "stop_gdb_log"')
|
|
elif os.path.exists(g_log_file):
|
|
if len(args) == 0:
|
|
debugger.HandleCommand('log disable gdb-remote packets')
|
|
result.PutCString(
|
|
"GDB packet logging disabled. Logged packets are in '%s'" %
|
|
g_log_file)
|
|
parse_gdb_log_file(g_log_file, options)
|
|
else:
|
|
result.PutCString(usage)
|
|
else:
|
|
print('error: the GDB packet log file "%s" does not exist' % g_log_file)
|
|
|
|
|
|
def is_hex_byte(str):
|
|
if len(str) == 2:
|
|
return str[0] in string.hexdigits and str[1] in string.hexdigits
|
|
return False
|
|
|
|
def get_hex_string_if_all_printable(str):
|
|
try:
|
|
s = binascii.unhexlify(str).decode()
|
|
if all(c in string.printable for c in s):
|
|
return s
|
|
except (TypeError, binascii.Error, UnicodeDecodeError):
|
|
pass
|
|
return None
|
|
|
|
# global register info list
|
|
g_register_infos = list()
|
|
g_max_register_info_name_len = 0
|
|
|
|
|
|
class RegisterInfo:
|
|
"""Class that represents register information"""
|
|
|
|
def __init__(self, kvp):
|
|
self.info = dict()
|
|
for kv in kvp:
|
|
key = kv[0]
|
|
value = kv[1]
|
|
self.info[key] = value
|
|
|
|
def name(self):
|
|
'''Get the name of the register.'''
|
|
if self.info and 'name' in self.info:
|
|
return self.info['name']
|
|
return None
|
|
|
|
def bit_size(self):
|
|
'''Get the size in bits of the register.'''
|
|
if self.info and 'bitsize' in self.info:
|
|
return int(self.info['bitsize'])
|
|
return 0
|
|
|
|
def byte_size(self):
|
|
'''Get the size in bytes of the register.'''
|
|
return self.bit_size() / 8
|
|
|
|
def get_value_from_hex_string(self, hex_str):
|
|
'''Dump the register value given a native byte order encoded hex ASCII byte string.'''
|
|
encoding = self.info['encoding']
|
|
bit_size = self.bit_size()
|
|
packet = Packet(hex_str)
|
|
if encoding == 'uint':
|
|
uval = packet.get_hex_uint(g_byte_order)
|
|
if bit_size == 8:
|
|
return '0x%2.2x' % (uval)
|
|
elif bit_size == 16:
|
|
return '0x%4.4x' % (uval)
|
|
elif bit_size == 32:
|
|
return '0x%8.8x' % (uval)
|
|
elif bit_size == 64:
|
|
return '0x%16.16x' % (uval)
|
|
bytes = list()
|
|
uval = packet.get_hex_uint8()
|
|
while uval is not None:
|
|
bytes.append(uval)
|
|
uval = packet.get_hex_uint8()
|
|
value_str = '0x'
|
|
if g_byte_order == 'little':
|
|
bytes.reverse()
|
|
for byte in bytes:
|
|
value_str += '%2.2x' % byte
|
|
return '%s' % (value_str)
|
|
|
|
def __str__(self):
|
|
'''Dump the register info key/value pairs'''
|
|
s = ''
|
|
for key in self.info.keys():
|
|
if s:
|
|
s += ', '
|
|
s += "%s=%s " % (key, self.info[key])
|
|
return s
|
|
|
|
|
|
class Packet:
|
|
"""Class that represents a packet that contains string data"""
|
|
|
|
def __init__(self, packet_str):
|
|
self.str = packet_str
|
|
|
|
def peek_char(self):
|
|
ch = 0
|
|
if self.str:
|
|
ch = self.str[0]
|
|
return ch
|
|
|
|
def get_char(self):
|
|
ch = 0
|
|
if self.str:
|
|
ch = self.str[0]
|
|
self.str = self.str[1:]
|
|
return ch
|
|
|
|
def skip_exact_string(self, s):
|
|
if self.str and self.str.startswith(s):
|
|
self.str = self.str[len(s):]
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def get_thread_id(self, fail_value=-1):
|
|
match = g_number_regex.match(self.str)
|
|
if match:
|
|
number_str = match.group(1)
|
|
self.str = self.str[len(number_str):]
|
|
return int(number_str, 0)
|
|
else:
|
|
return fail_value
|
|
|
|
def get_hex_uint8(self):
|
|
if self.str and len(self.str) >= 2 and self.str[
|
|
0] in string.hexdigits and self.str[1] in string.hexdigits:
|
|
uval = int(self.str[0:2], 16)
|
|
self.str = self.str[2:]
|
|
return uval
|
|
return None
|
|
|
|
def get_hex_uint16(self, byte_order):
|
|
uval = 0
|
|
if byte_order == 'big':
|
|
uval |= self.get_hex_uint8() << 8
|
|
uval |= self.get_hex_uint8()
|
|
else:
|
|
uval |= self.get_hex_uint8()
|
|
uval |= self.get_hex_uint8() << 8
|
|
return uval
|
|
|
|
def get_hex_uint32(self, byte_order):
|
|
uval = 0
|
|
if byte_order == 'big':
|
|
uval |= self.get_hex_uint8() << 24
|
|
uval |= self.get_hex_uint8() << 16
|
|
uval |= self.get_hex_uint8() << 8
|
|
uval |= self.get_hex_uint8()
|
|
else:
|
|
uval |= self.get_hex_uint8()
|
|
uval |= self.get_hex_uint8() << 8
|
|
uval |= self.get_hex_uint8() << 16
|
|
uval |= self.get_hex_uint8() << 24
|
|
return uval
|
|
|
|
def get_hex_uint64(self, byte_order):
|
|
uval = 0
|
|
if byte_order == 'big':
|
|
uval |= self.get_hex_uint8() << 56
|
|
uval |= self.get_hex_uint8() << 48
|
|
uval |= self.get_hex_uint8() << 40
|
|
uval |= self.get_hex_uint8() << 32
|
|
uval |= self.get_hex_uint8() << 24
|
|
uval |= self.get_hex_uint8() << 16
|
|
uval |= self.get_hex_uint8() << 8
|
|
uval |= self.get_hex_uint8()
|
|
else:
|
|
uval |= self.get_hex_uint8()
|
|
uval |= self.get_hex_uint8() << 8
|
|
uval |= self.get_hex_uint8() << 16
|
|
uval |= self.get_hex_uint8() << 24
|
|
uval |= self.get_hex_uint8() << 32
|
|
uval |= self.get_hex_uint8() << 40
|
|
uval |= self.get_hex_uint8() << 48
|
|
uval |= self.get_hex_uint8() << 56
|
|
return uval
|
|
|
|
def get_number(self, fail_value=-1):
|
|
'''Get a number from the packet. The number must be in big endian format and should be parsed
|
|
according to its prefix (starts with "0x" means hex, starts with "0" means octal, starts with
|
|
[1-9] means decimal, etc)'''
|
|
match = g_number_regex.match(self.str)
|
|
if match:
|
|
number_str = match.group(1)
|
|
self.str = self.str[len(number_str):]
|
|
return int(number_str, 0)
|
|
else:
|
|
return fail_value
|
|
|
|
def get_hex_ascii_str(self, n=0):
|
|
hex_chars = self.get_hex_chars(n)
|
|
if hex_chars:
|
|
return binascii.unhexlify(hex_chars)
|
|
else:
|
|
return None
|
|
|
|
def get_hex_chars(self, n=0):
|
|
str_len = len(self.str)
|
|
if n == 0:
|
|
# n was zero, so we need to determine all hex chars and
|
|
# stop when we hit the end of the string of a non-hex character
|
|
while n < str_len and self.str[n] in string.hexdigits:
|
|
n = n + 1
|
|
else:
|
|
if n > str_len:
|
|
return None # Not enough chars
|
|
# Verify all chars are hex if a length was specified
|
|
for i in range(n):
|
|
if self.str[i] not in string.hexdigits:
|
|
return None # Not all hex digits
|
|
if n == 0:
|
|
return None
|
|
hex_str = self.str[0:n]
|
|
self.str = self.str[n:]
|
|
return hex_str
|
|
|
|
def get_hex_uint(self, byte_order, n=0):
|
|
if byte_order == 'big':
|
|
hex_str = self.get_hex_chars(n)
|
|
if hex_str is None:
|
|
return None
|
|
return int(hex_str, 16)
|
|
else:
|
|
uval = self.get_hex_uint8()
|
|
if uval is None:
|
|
return None
|
|
uval_result = 0
|
|
shift = 0
|
|
while uval is not None:
|
|
uval_result |= (uval << shift)
|
|
shift += 8
|
|
uval = self.get_hex_uint8()
|
|
return uval_result
|
|
|
|
def get_key_value_pairs(self):
|
|
kvp = list()
|
|
if ';' in self.str:
|
|
key_value_pairs = self.str.split(';')
|
|
for key_value_pair in key_value_pairs:
|
|
if len(key_value_pair):
|
|
kvp.append(key_value_pair.split(':', 1))
|
|
return kvp
|
|
|
|
def split(self, ch):
|
|
return string.split(self.str, ch)
|
|
|
|
def split_hex(self, ch, byte_order):
|
|
hex_values = list()
|
|
strings = string.split(self.str, ch)
|
|
for str in strings:
|
|
hex_values.append(Packet(str).get_hex_uint(byte_order))
|
|
return hex_values
|
|
|
|
def __str__(self):
|
|
return self.str
|
|
|
|
def __len__(self):
|
|
return len(self.str)
|
|
|
|
g_thread_suffix_regex = re.compile(';thread:([0-9a-fA-F]+);')
|
|
|
|
|
|
def get_thread_from_thread_suffix(str):
|
|
if str:
|
|
match = g_thread_suffix_regex.match(str)
|
|
if match:
|
|
return int(match.group(1), 16)
|
|
return None
|
|
|
|
|
|
def cmd_qThreadStopInfo(options, cmd, args):
|
|
packet = Packet(args)
|
|
tid = packet.get_hex_uint('big')
|
|
print("get_thread_stop_info (tid = 0x%x)" % (tid))
|
|
|
|
|
|
def cmd_stop_reply(options, cmd, args):
|
|
print("get_last_stop_info()")
|
|
return False
|
|
|
|
|
|
def rsp_stop_reply(options, cmd, cmd_args, rsp):
|
|
global g_byte_order
|
|
packet = Packet(rsp)
|
|
stop_type = packet.get_char()
|
|
if stop_type == 'T' or stop_type == 'S':
|
|
signo = packet.get_hex_uint8()
|
|
key_value_pairs = packet.get_key_value_pairs()
|
|
for key_value_pair in key_value_pairs:
|
|
key = key_value_pair[0]
|
|
if is_hex_byte(key):
|
|
reg_num = Packet(key).get_hex_uint8()
|
|
if reg_num < len(g_register_infos):
|
|
reg_info = g_register_infos[reg_num]
|
|
key_value_pair[0] = reg_info.name()
|
|
key_value_pair[1] = reg_info.get_value_from_hex_string(
|
|
key_value_pair[1])
|
|
elif key == 'jthreads' or key == 'jstopinfo':
|
|
key_value_pair[1] = binascii.unhexlify(key_value_pair[1])
|
|
key_value_pairs.insert(0, ['signal', signo])
|
|
print('stop_reply():')
|
|
dump_key_value_pairs(key_value_pairs)
|
|
elif stop_type == 'W':
|
|
exit_status = packet.get_hex_uint8()
|
|
print('stop_reply(): exit (status=%i)' % exit_status)
|
|
elif stop_type == 'O':
|
|
print('stop_reply(): stdout = "%s"' % packet.str)
|
|
|
|
|
|
def cmd_unknown_packet(options, cmd, args):
|
|
if args:
|
|
print("cmd: %s, args: %s", cmd, args)
|
|
else:
|
|
print("cmd: %s", cmd)
|
|
return False
|
|
|
|
|
|
def cmd_qSymbol(options, cmd, args):
|
|
if args == ':':
|
|
print('ready to serve symbols')
|
|
else:
|
|
packet = Packet(args)
|
|
symbol_addr = packet.get_hex_uint('big')
|
|
if symbol_addr is None:
|
|
if packet.skip_exact_string(':'):
|
|
symbol_name = packet.get_hex_ascii_str()
|
|
print('lookup_symbol("%s") -> symbol not available yet' % (symbol_name))
|
|
else:
|
|
print('error: bad command format')
|
|
else:
|
|
if packet.skip_exact_string(':'):
|
|
symbol_name = packet.get_hex_ascii_str()
|
|
print('lookup_symbol("%s") -> 0x%x' % (symbol_name, symbol_addr))
|
|
else:
|
|
print('error: bad command format')
|
|
|
|
def cmd_QSetWithHexString(options, cmd, args):
|
|
print('%s("%s")' % (cmd[:-1], binascii.unhexlify(args)))
|
|
|
|
def cmd_QSetWithString(options, cmd, args):
|
|
print('%s("%s")' % (cmd[:-1], args))
|
|
|
|
def cmd_QSetWithUnsigned(options, cmd, args):
|
|
print('%s(%i)' % (cmd[:-1], int(args)))
|
|
|
|
def rsp_qSymbol(options, cmd, cmd_args, rsp):
|
|
if len(rsp) == 0:
|
|
print("Unsupported")
|
|
else:
|
|
if rsp == "OK":
|
|
print("No more symbols to lookup")
|
|
else:
|
|
packet = Packet(rsp)
|
|
if packet.skip_exact_string("qSymbol:"):
|
|
symbol_name = packet.get_hex_ascii_str()
|
|
print('lookup_symbol("%s")' % (symbol_name))
|
|
else:
|
|
print('error: response string should start with "qSymbol:": respnse is "%s"' % (rsp))
|
|
|
|
|
|
def cmd_qXfer(options, cmd, args):
|
|
# $qXfer:features:read:target.xml:0,1ffff#14
|
|
print("read target special data %s" % (args))
|
|
return True
|
|
|
|
|
|
def rsp_qXfer(options, cmd, cmd_args, rsp):
|
|
data = cmd_args.split(':')
|
|
if data[0] == 'features':
|
|
if data[1] == 'read':
|
|
filename, extension = os.path.splitext(data[2])
|
|
if extension == '.xml':
|
|
response = Packet(rsp)
|
|
xml_string = response.get_hex_ascii_str()
|
|
if xml_string:
|
|
ch = xml_string[0]
|
|
if ch == 'l':
|
|
xml_string = xml_string[1:]
|
|
xml_root = ET.fromstring(xml_string)
|
|
for reg_element in xml_root.findall("./feature/reg"):
|
|
if not 'value_regnums' in reg_element.attrib:
|
|
reg_info = RegisterInfo([])
|
|
if 'name' in reg_element.attrib:
|
|
reg_info.info[
|
|
'name'] = reg_element.attrib['name']
|
|
else:
|
|
reg_info.info['name'] = 'unspecified'
|
|
if 'encoding' in reg_element.attrib:
|
|
reg_info.info['encoding'] = reg_element.attrib[
|
|
'encoding']
|
|
else:
|
|
reg_info.info['encoding'] = 'uint'
|
|
if 'offset' in reg_element.attrib:
|
|
reg_info.info[
|
|
'offset'] = reg_element.attrib['offset']
|
|
if 'bitsize' in reg_element.attrib:
|
|
reg_info.info[
|
|
'bitsize'] = reg_element.attrib['bitsize']
|
|
g_register_infos.append(reg_info)
|
|
print('XML for "%s":' % (data[2]))
|
|
ET.dump(xml_root)
|
|
|
|
|
|
def cmd_A(options, cmd, args):
|
|
print('launch process:')
|
|
packet = Packet(args)
|
|
while True:
|
|
arg_len = packet.get_number()
|
|
if arg_len == -1:
|
|
break
|
|
if not packet.skip_exact_string(','):
|
|
break
|
|
arg_idx = packet.get_number()
|
|
if arg_idx == -1:
|
|
break
|
|
if not packet.skip_exact_string(','):
|
|
break
|
|
arg_value = packet.get_hex_ascii_str(arg_len)
|
|
print('argv[%u] = "%s"' % (arg_idx, arg_value))
|
|
|
|
|
|
def cmd_qC(options, cmd, args):
|
|
print("query_current_thread_id()")
|
|
|
|
|
|
def rsp_qC(options, cmd, cmd_args, rsp):
|
|
packet = Packet(rsp)
|
|
if packet.skip_exact_string("QC"):
|
|
tid = packet.get_thread_id()
|
|
print("current_thread_id = %#x" % (tid))
|
|
else:
|
|
print("current_thread_id = old thread ID")
|
|
|
|
|
|
def cmd_query_packet(options, cmd, args):
|
|
if args:
|
|
print("%s%s" % (cmd, args))
|
|
else:
|
|
print("%s" % (cmd))
|
|
return False
|
|
|
|
|
|
def rsp_ok_error(rsp):
|
|
print("rsp: ", rsp)
|
|
|
|
|
|
def rsp_ok_means_supported(options, cmd, cmd_args, rsp):
|
|
if rsp == 'OK':
|
|
print("%s%s is supported" % (cmd, cmd_args))
|
|
elif rsp == '':
|
|
print("%s%s is not supported" % (cmd, cmd_args))
|
|
else:
|
|
print("%s%s -> %s" % (cmd, cmd_args, rsp))
|
|
|
|
|
|
def rsp_ok_means_success(options, cmd, cmd_args, rsp):
|
|
if rsp == 'OK':
|
|
print("success")
|
|
elif rsp == '':
|
|
print("%s%s is not supported" % (cmd, cmd_args))
|
|
else:
|
|
print("%s%s -> %s" % (cmd, cmd_args, rsp))
|
|
|
|
|
|
def dump_key_value_pairs(key_value_pairs):
|
|
max_key_len = 0
|
|
for key_value_pair in key_value_pairs:
|
|
key_len = len(key_value_pair[0])
|
|
if max_key_len < key_len:
|
|
max_key_len = key_len
|
|
for key_value_pair in key_value_pairs:
|
|
key = key_value_pair[0]
|
|
value = key_value_pair[1]
|
|
unhex_value = get_hex_string_if_all_printable(value)
|
|
if unhex_value:
|
|
print("%*s = %s (%s)" % (max_key_len, key, value, unhex_value))
|
|
else:
|
|
print("%*s = %s" % (max_key_len, key, value))
|
|
|
|
|
|
def rsp_dump_key_value_pairs(options, cmd, cmd_args, rsp):
|
|
if rsp:
|
|
print('%s response:' % (cmd))
|
|
packet = Packet(rsp)
|
|
key_value_pairs = packet.get_key_value_pairs()
|
|
dump_key_value_pairs(key_value_pairs)
|
|
else:
|
|
print("not supported")
|
|
|
|
|
|
def cmd_c(options, cmd, args):
|
|
print("continue()")
|
|
return False
|
|
|
|
|
|
def cmd_s(options, cmd, args):
|
|
print("step()")
|
|
return False
|
|
|
|
|
|
def cmd_qSpeedTest(options, cmd, args):
|
|
print(("qSpeedTest: cmd='%s', args='%s'" % (cmd, args)))
|
|
|
|
|
|
def rsp_qSpeedTest(options, cmd, cmd_args, rsp):
|
|
print(("qSpeedTest: rsp='%s' cmd='%s', args='%s'" % (rsp, cmd, args)))
|
|
|
|
|
|
def cmd_vCont(options, cmd, args):
|
|
if args == '?':
|
|
print("%s: get supported extended continue modes" % (cmd))
|
|
else:
|
|
got_other_threads = 0
|
|
s = ''
|
|
for thread_action in args[1:].split(';'):
|
|
(short_action, thread) = thread_action.split(':', 1)
|
|
tid = int(thread, 16)
|
|
if short_action == 'c':
|
|
action = 'continue'
|
|
elif short_action == 's':
|
|
action = 'step'
|
|
elif short_action[0] == 'C':
|
|
action = 'continue with signal 0x%s' % (short_action[1:])
|
|
elif short_action == 'S':
|
|
action = 'step with signal 0x%s' % (short_action[1:])
|
|
else:
|
|
action = short_action
|
|
if s:
|
|
s += ', '
|
|
if tid == -1:
|
|
got_other_threads = 1
|
|
s += 'other-threads:'
|
|
else:
|
|
s += 'thread 0x%4.4x: %s' % (tid, action)
|
|
if got_other_threads:
|
|
print("extended_continue (%s)" % (s))
|
|
else:
|
|
print("extended_continue (%s, other-threads: suspend)" % (s))
|
|
return False
|
|
|
|
|
|
def rsp_vCont(options, cmd, cmd_args, rsp):
|
|
if cmd_args == '?':
|
|
# Skip the leading 'vCont;'
|
|
rsp = rsp[6:]
|
|
modes = rsp.split(';')
|
|
s = "%s: supported extended continue modes include: " % (cmd)
|
|
|
|
for i, mode in enumerate(modes):
|
|
if i:
|
|
s += ', '
|
|
if mode == 'c':
|
|
s += 'continue'
|
|
elif mode == 'C':
|
|
s += 'continue with signal'
|
|
elif mode == 's':
|
|
s += 'step'
|
|
elif mode == 'S':
|
|
s += 'step with signal'
|
|
elif mode == 't':
|
|
s += 'stop'
|
|
# else:
|
|
# s += 'unrecognized vCont mode: ', str(mode)
|
|
print(s)
|
|
elif rsp:
|
|
if rsp[0] == 'T' or rsp[0] == 'S' or rsp[0] == 'W' or rsp[0] == 'X':
|
|
rsp_stop_reply(options, cmd, cmd_args, rsp)
|
|
return
|
|
if rsp[0] == 'O':
|
|
print("stdout: %s" % (rsp))
|
|
return
|
|
else:
|
|
print("not supported (cmd = '%s', args = '%s', rsp = '%s')" % (cmd, cmd_args, rsp))
|
|
|
|
|
|
def cmd_vAttach(options, cmd, args):
|
|
(extra_command, args) = string.split(args, ';')
|
|
if extra_command:
|
|
print("%s%s(%s)" % (cmd, extra_command, args))
|
|
else:
|
|
print("attach(pid = %u)" % int(args, 16))
|
|
return False
|
|
|
|
|
|
def cmd_qRegisterInfo(options, cmd, args):
|
|
print('query_register_info(reg_num=%i)' % (int(args, 16)))
|
|
return False
|
|
|
|
|
|
def rsp_qRegisterInfo(options, cmd, cmd_args, rsp):
|
|
global g_max_register_info_name_len
|
|
print('query_register_info(reg_num=%i):' % (int(cmd_args, 16)), end=' ')
|
|
if len(rsp) == 3 and rsp[0] == 'E':
|
|
g_max_register_info_name_len = 0
|
|
for reg_info in g_register_infos:
|
|
name_len = len(reg_info.name())
|
|
if g_max_register_info_name_len < name_len:
|
|
g_max_register_info_name_len = name_len
|
|
print(' DONE')
|
|
else:
|
|
packet = Packet(rsp)
|
|
reg_info = RegisterInfo(packet.get_key_value_pairs())
|
|
g_register_infos.append(reg_info)
|
|
print(reg_info)
|
|
return False
|
|
|
|
|
|
def cmd_qThreadInfo(options, cmd, args):
|
|
if cmd == 'qfThreadInfo':
|
|
query_type = 'first'
|
|
else:
|
|
query_type = 'subsequent'
|
|
print('get_current_thread_list(type=%s)' % (query_type))
|
|
return False
|
|
|
|
|
|
def rsp_qThreadInfo(options, cmd, cmd_args, rsp):
|
|
packet = Packet(rsp)
|
|
response_type = packet.get_char()
|
|
if response_type == 'm':
|
|
tids = packet.split_hex(';', 'big')
|
|
for i, tid in enumerate(tids):
|
|
if i:
|
|
print(',', end=' ')
|
|
print('0x%x' % (tid), end=' ')
|
|
print()
|
|
elif response_type == 'l':
|
|
print('END')
|
|
|
|
|
|
def rsp_hex_big_endian(options, cmd, cmd_args, rsp):
|
|
if rsp == '':
|
|
print("%s%s is not supported" % (cmd, cmd_args))
|
|
else:
|
|
packet = Packet(rsp)
|
|
uval = packet.get_hex_uint('big')
|
|
print('%s: 0x%x' % (cmd, uval))
|
|
|
|
|
|
def cmd_read_mem_bin(options, cmd, args):
|
|
# x0x7fff5fc39200,0x200
|
|
packet = Packet(args)
|
|
addr = packet.get_hex_uint('big')
|
|
comma = packet.get_char()
|
|
size = packet.get_hex_uint('big')
|
|
print('binary_read_memory (addr = 0x%16.16x, size = %u)' % (addr, size))
|
|
return False
|
|
|
|
|
|
def rsp_mem_bin_bytes(options, cmd, cmd_args, rsp):
|
|
packet = Packet(cmd_args)
|
|
addr = packet.get_hex_uint('big')
|
|
comma = packet.get_char()
|
|
size = packet.get_hex_uint('big')
|
|
print('memory:')
|
|
if size > 0:
|
|
dump_hex_memory_buffer(addr, rsp)
|
|
|
|
|
|
def cmd_read_memory(options, cmd, args):
|
|
packet = Packet(args)
|
|
addr = packet.get_hex_uint('big')
|
|
comma = packet.get_char()
|
|
size = packet.get_hex_uint('big')
|
|
print('read_memory (addr = 0x%16.16x, size = %u)' % (addr, size))
|
|
return False
|
|
|
|
|
|
def dump_hex_memory_buffer(addr, hex_byte_str):
|
|
packet = Packet(hex_byte_str)
|
|
idx = 0
|
|
ascii = ''
|
|
uval = packet.get_hex_uint8()
|
|
while uval is not None:
|
|
if ((idx % 16) == 0):
|
|
if ascii:
|
|
print(' ', ascii)
|
|
ascii = ''
|
|
print('0x%x:' % (addr + idx), end=' ')
|
|
print('%2.2x' % (uval), end=' ')
|
|
if 0x20 <= uval and uval < 0x7f:
|
|
ascii += '%c' % uval
|
|
else:
|
|
ascii += '.'
|
|
uval = packet.get_hex_uint8()
|
|
idx = idx + 1
|
|
if ascii:
|
|
print(' ', ascii)
|
|
ascii = ''
|
|
|
|
|
|
def cmd_write_memory(options, cmd, args):
|
|
packet = Packet(args)
|
|
addr = packet.get_hex_uint('big')
|
|
if packet.get_char() != ',':
|
|
print('error: invalid write memory command (missing comma after address)')
|
|
return
|
|
size = packet.get_hex_uint('big')
|
|
if packet.get_char() != ':':
|
|
print('error: invalid write memory command (missing colon after size)')
|
|
return
|
|
print('write_memory (addr = 0x%16.16x, size = %u, data:' % (addr, size))
|
|
dump_hex_memory_buffer(addr, packet.str)
|
|
return False
|
|
|
|
|
|
def cmd_alloc_memory(options, cmd, args):
|
|
packet = Packet(args)
|
|
byte_size = packet.get_hex_uint('big')
|
|
if packet.get_char() != ',':
|
|
print('error: invalid allocate memory command (missing comma after address)')
|
|
return
|
|
print('allocate_memory (byte-size = %u (0x%x), permissions = %s)' % (byte_size, byte_size, packet.str))
|
|
return False
|
|
|
|
|
|
def rsp_alloc_memory(options, cmd, cmd_args, rsp):
|
|
packet = Packet(rsp)
|
|
addr = packet.get_hex_uint('big')
|
|
print('addr = 0x%x' % addr)
|
|
|
|
|
|
def cmd_dealloc_memory(options, cmd, args):
|
|
packet = Packet(args)
|
|
addr = packet.get_hex_uint('big')
|
|
if packet.get_char() != ',':
|
|
print('error: invalid allocate memory command (missing comma after address)')
|
|
else:
|
|
print('deallocate_memory (addr = 0x%x, permissions = %s)' % (addr, packet.str))
|
|
return False
|
|
|
|
|
|
def rsp_memory_bytes(options, cmd, cmd_args, rsp):
|
|
addr = Packet(cmd_args).get_hex_uint('big')
|
|
dump_hex_memory_buffer(addr, rsp)
|
|
|
|
|
|
def get_register_name_equal_value(options, reg_num, hex_value_str):
|
|
if reg_num < len(g_register_infos):
|
|
reg_info = g_register_infos[reg_num]
|
|
value_str = reg_info.get_value_from_hex_string(hex_value_str)
|
|
s = reg_info.name() + ' = '
|
|
if options.symbolicator:
|
|
symbolicated_addresses = options.symbolicator.symbolicate(
|
|
int(value_str, 0))
|
|
if symbolicated_addresses:
|
|
s += options.colors.magenta()
|
|
s += '%s' % symbolicated_addresses[0]
|
|
s += options.colors.reset()
|
|
return s
|
|
s += value_str
|
|
return s
|
|
else:
|
|
reg_value = Packet(hex_value_str).get_hex_uint(g_byte_order)
|
|
return 'reg(%u) = 0x%x' % (reg_num, reg_value)
|
|
|
|
|
|
def cmd_read_one_reg(options, cmd, args):
|
|
packet = Packet(args)
|
|
reg_num = packet.get_hex_uint('big')
|
|
tid = get_thread_from_thread_suffix(packet.str)
|
|
name = None
|
|
if reg_num < len(g_register_infos):
|
|
name = g_register_infos[reg_num].name()
|
|
if packet.str:
|
|
packet.get_char() # skip ;
|
|
thread_info = packet.get_key_value_pairs()
|
|
tid = int(thread_info[0][1], 16)
|
|
s = 'read_register (reg_num=%u' % reg_num
|
|
if name:
|
|
s += ' (%s)' % (name)
|
|
if tid is not None:
|
|
s += ', tid = 0x%4.4x' % (tid)
|
|
s += ')'
|
|
print(s)
|
|
return False
|
|
|
|
|
|
def rsp_read_one_reg(options, cmd, cmd_args, rsp):
|
|
packet = Packet(cmd_args)
|
|
reg_num = packet.get_hex_uint('big')
|
|
print(get_register_name_equal_value(options, reg_num, rsp))
|
|
|
|
|
|
def cmd_write_one_reg(options, cmd, args):
|
|
packet = Packet(args)
|
|
reg_num = packet.get_hex_uint('big')
|
|
if packet.get_char() != '=':
|
|
print('error: invalid register write packet')
|
|
else:
|
|
name = None
|
|
hex_value_str = packet.get_hex_chars()
|
|
tid = get_thread_from_thread_suffix(packet.str)
|
|
s = 'write_register (reg_num=%u' % reg_num
|
|
if name:
|
|
s += ' (%s)' % (name)
|
|
s += ', value = '
|
|
s += get_register_name_equal_value(options, reg_num, hex_value_str)
|
|
if tid is not None:
|
|
s += ', tid = 0x%4.4x' % (tid)
|
|
s += ')'
|
|
print(s)
|
|
return False
|
|
|
|
|
|
def dump_all_regs(packet):
|
|
for reg_info in g_register_infos:
|
|
nibble_size = reg_info.bit_size() / 4
|
|
hex_value_str = packet.get_hex_chars(nibble_size)
|
|
if hex_value_str is not None:
|
|
value = reg_info.get_value_from_hex_string(hex_value_str)
|
|
print('%*s = %s' % (g_max_register_info_name_len, reg_info.name(), value))
|
|
else:
|
|
return
|
|
|
|
|
|
def cmd_read_all_regs(cmd, cmd_args):
|
|
packet = Packet(cmd_args)
|
|
packet.get_char() # toss the 'g' command character
|
|
tid = get_thread_from_thread_suffix(packet.str)
|
|
if tid is not None:
|
|
print('read_all_register(thread = 0x%4.4x)' % tid)
|
|
else:
|
|
print('read_all_register()')
|
|
return False
|
|
|
|
|
|
def rsp_read_all_regs(options, cmd, cmd_args, rsp):
|
|
packet = Packet(rsp)
|
|
dump_all_regs(packet)
|
|
|
|
|
|
def cmd_write_all_regs(options, cmd, args):
|
|
packet = Packet(args)
|
|
print('write_all_registers()')
|
|
dump_all_regs(packet)
|
|
return False
|
|
|
|
g_bp_types = ["software_bp", "hardware_bp", "write_wp", "read_wp", "access_wp"]
|
|
|
|
|
|
def cmd_bp(options, cmd, args):
|
|
if cmd == 'Z':
|
|
s = 'set_'
|
|
else:
|
|
s = 'clear_'
|
|
packet = Packet(args)
|
|
bp_type = packet.get_hex_uint('big')
|
|
packet.get_char() # Skip ,
|
|
bp_addr = packet.get_hex_uint('big')
|
|
packet.get_char() # Skip ,
|
|
bp_size = packet.get_hex_uint('big')
|
|
s += g_bp_types[bp_type]
|
|
s += " (addr = 0x%x, size = %u)" % (bp_addr, bp_size)
|
|
print(s)
|
|
return False
|
|
|
|
|
|
def cmd_mem_rgn_info(options, cmd, args):
|
|
packet = Packet(args)
|
|
packet.get_char() # skip ':' character
|
|
addr = packet.get_hex_uint('big')
|
|
print('get_memory_region_info (addr=0x%x)' % (addr))
|
|
return False
|
|
|
|
|
|
def cmd_kill(options, cmd, args):
|
|
print('kill_process()')
|
|
return False
|
|
|
|
|
|
def cmd_jThreadsInfo(options, cmd, args):
|
|
print('jThreadsInfo()')
|
|
return False
|
|
|
|
|
|
def cmd_jGetLoadedDynamicLibrariesInfos(options, cmd, args):
|
|
print('jGetLoadedDynamicLibrariesInfos()')
|
|
return False
|
|
|
|
|
|
def decode_packet(s, start_index=0):
|
|
# print '\ndecode_packet("%s")' % (s[start_index:])
|
|
index = s.find('}', start_index)
|
|
have_escapes = index != -1
|
|
if have_escapes:
|
|
normal_s = s[start_index:index]
|
|
else:
|
|
normal_s = s[start_index:]
|
|
# print 'normal_s = "%s"' % (normal_s)
|
|
if have_escapes:
|
|
escape_char = '%c' % (ord(s[index + 1]) ^ 0x20)
|
|
# print 'escape_char for "%s" = %c' % (s[index:index+2], escape_char)
|
|
return normal_s + escape_char + decode_packet(s, index + 2)
|
|
else:
|
|
return normal_s
|
|
|
|
|
|
def rsp_json(options, cmd, cmd_args, rsp):
|
|
print('%s() reply:' % (cmd))
|
|
json_tree = json.loads(rsp)
|
|
print(json.dumps(json_tree, indent=4, separators=(',', ': ')))
|
|
|
|
|
|
def rsp_jGetLoadedDynamicLibrariesInfos(options, cmd, cmd_args, rsp):
|
|
if cmd_args:
|
|
rsp_json(options, cmd, cmd_args, rsp)
|
|
else:
|
|
rsp_ok_means_supported(options, cmd, cmd_args, rsp)
|
|
|
|
gdb_remote_commands = {
|
|
'\\?': {'cmd': cmd_stop_reply, 'rsp': rsp_stop_reply, 'name': "stop reply pacpket"},
|
|
'qThreadStopInfo': {'cmd': cmd_qThreadStopInfo, 'rsp': rsp_stop_reply, 'name': "stop reply pacpket"},
|
|
'QStartNoAckMode': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if no ack mode is supported"},
|
|
'QThreadSuffixSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if thread suffix is supported"},
|
|
'QListThreadsInStopReply': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if threads in stop reply packets are supported"},
|
|
'QSetDetachOnError:': {'cmd': cmd_QSetWithUnsigned, 'rsp': rsp_ok_means_success, 'name': "set if we should detach on error"},
|
|
'QSetDisableASLR:': {'cmd': cmd_QSetWithUnsigned, 'rsp': rsp_ok_means_success, 'name': "set if we should disable ASLR"},
|
|
'qLaunchSuccess': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_success, 'name': "check on launch success for the A packet"},
|
|
'A': {'cmd': cmd_A, 'rsp': rsp_ok_means_success, 'name': "launch process"},
|
|
'QLaunchArch:': {'cmd': cmd_QSetWithString, 'rsp': rsp_ok_means_supported, 'name': "set the arch to launch in case the file contains multiple architectures"},
|
|
'qVAttachOrWaitSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "set the launch architecture"},
|
|
'qHostInfo': {'cmd': cmd_query_packet, 'rsp': rsp_dump_key_value_pairs, 'name': "get host information"},
|
|
'qC': {'cmd': cmd_qC, 'rsp': rsp_qC, 'name': "return the current thread ID"},
|
|
'vCont': {'cmd': cmd_vCont, 'rsp': rsp_vCont, 'name': "extended continue command"},
|
|
'qSpeedTest': {'cmd':cmd_qSpeedTest, 'rsp': rsp_qSpeedTest, 'name': 'speed test packdet'},
|
|
'vAttach': {'cmd': cmd_vAttach, 'rsp': rsp_stop_reply, 'name': "attach to process"},
|
|
'c': {'cmd': cmd_c, 'rsp': rsp_stop_reply, 'name': "continue"},
|
|
's': {'cmd': cmd_s, 'rsp': rsp_stop_reply, 'name': "step"},
|
|
'qRegisterInfo': {'cmd': cmd_qRegisterInfo, 'rsp': rsp_qRegisterInfo, 'name': "query register info"},
|
|
'qfThreadInfo': {'cmd': cmd_qThreadInfo, 'rsp': rsp_qThreadInfo, 'name': "get current thread list"},
|
|
'qsThreadInfo': {'cmd': cmd_qThreadInfo, 'rsp': rsp_qThreadInfo, 'name': "get current thread list"},
|
|
'qShlibInfoAddr': {'cmd': cmd_query_packet, 'rsp': rsp_hex_big_endian, 'name': "get shared library info address"},
|
|
'qMemoryRegionInfo': {'cmd': cmd_mem_rgn_info, 'rsp': rsp_dump_key_value_pairs, 'name': "get memory region information"},
|
|
'qProcessInfo': {'cmd': cmd_query_packet, 'rsp': rsp_dump_key_value_pairs, 'name': "get process info"},
|
|
'qSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query supported"},
|
|
'qXfer:': {'cmd': cmd_qXfer, 'rsp': rsp_qXfer, 'name': "qXfer"},
|
|
'qSymbol:': {'cmd': cmd_qSymbol, 'rsp': rsp_qSymbol, 'name': "qSymbol"},
|
|
'QSetSTDIN:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDIN prior to launching with A packet"},
|
|
'QSetSTDOUT:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDOUT prior to launching with A packet"},
|
|
'QSetSTDERR:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDERR prior to launching with A packet"},
|
|
'QEnvironment:' : {'cmd' : cmd_QSetWithString, 'rsp' : rsp_ok_means_success, 'name': "set an environment variable prior to launching with A packet"},
|
|
'QEnvironmentHexEncoded:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set an environment variable prior to launching with A packet"},
|
|
'x': {'cmd': cmd_read_mem_bin, 'rsp': rsp_mem_bin_bytes, 'name': "read memory binary"},
|
|
'X': {'cmd': cmd_write_memory, 'rsp': rsp_ok_means_success, 'name': "write memory binary"},
|
|
'm': {'cmd': cmd_read_memory, 'rsp': rsp_memory_bytes, 'name': "read memory"},
|
|
'M': {'cmd': cmd_write_memory, 'rsp': rsp_ok_means_success, 'name': "write memory"},
|
|
'_M': {'cmd': cmd_alloc_memory, 'rsp': rsp_alloc_memory, 'name': "allocate memory"},
|
|
'_m': {'cmd': cmd_dealloc_memory, 'rsp': rsp_ok_means_success, 'name': "deallocate memory"},
|
|
'p': {'cmd': cmd_read_one_reg, 'rsp': rsp_read_one_reg, 'name': "read single register"},
|
|
'P': {'cmd': cmd_write_one_reg, 'rsp': rsp_ok_means_success, 'name': "write single register"},
|
|
'g': {'cmd': cmd_read_all_regs, 'rsp': rsp_read_all_regs, 'name': "read all registers"},
|
|
'G': {'cmd': cmd_write_all_regs, 'rsp': rsp_ok_means_success, 'name': "write all registers"},
|
|
'z': {'cmd': cmd_bp, 'rsp': rsp_ok_means_success, 'name': "clear breakpoint or watchpoint"},
|
|
'Z': {'cmd': cmd_bp, 'rsp': rsp_ok_means_success, 'name': "set breakpoint or watchpoint"},
|
|
'k': {'cmd': cmd_kill, 'rsp': rsp_stop_reply, 'name': "kill process"},
|
|
'jThreadsInfo': {'cmd': cmd_jThreadsInfo, 'rsp': rsp_json, 'name': "JSON get all threads info"},
|
|
'jGetLoadedDynamicLibrariesInfos:': {'cmd': cmd_jGetLoadedDynamicLibrariesInfos, 'rsp': rsp_jGetLoadedDynamicLibrariesInfos, 'name': 'JSON get loaded dynamic libraries'},
|
|
}
|
|
|
|
|
|
def calculate_mean_and_standard_deviation(floats):
|
|
sum = 0.0
|
|
count = len(floats)
|
|
if count == 0:
|
|
return (0.0, 0.0)
|
|
for f in floats:
|
|
sum += f
|
|
mean = sum / count
|
|
accum = 0.0
|
|
for f in floats:
|
|
delta = f - mean
|
|
accum += delta * delta
|
|
|
|
std_dev = math.sqrt(accum / (count - 1))
|
|
return (mean, std_dev)
|
|
|
|
|
|
def parse_gdb_log_file(path, options):
|
|
f = open(path)
|
|
parse_gdb_log(f, options)
|
|
f.close()
|
|
|
|
|
|
def round_up(n, incr):
|
|
return float(((int(n) + incr) / incr) * incr)
|
|
|
|
|
|
def plot_latencies(sec_times):
|
|
# import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
for (i, name) in enumerate(sec_times.keys()):
|
|
times = sec_times[name]
|
|
if len(times) <= 1:
|
|
continue
|
|
plt.subplot(2, 1, 1)
|
|
plt.title('Packet "%s" Times' % (name))
|
|
plt.xlabel('Packet')
|
|
units = 'ms'
|
|
adj_times = []
|
|
max_time = 0.0
|
|
for time in times:
|
|
time = time * 1000.0
|
|
adj_times.append(time)
|
|
if time > max_time:
|
|
max_time = time
|
|
if max_time < 1.0:
|
|
units = 'us'
|
|
max_time = 0.0
|
|
for i in range(len(adj_times)):
|
|
adj_times[i] *= 1000.0
|
|
if adj_times[i] > max_time:
|
|
max_time = adj_times[i]
|
|
plt.ylabel('Time (%s)' % (units))
|
|
max_y = None
|
|
for i in [5.0, 10.0, 25.0, 50.0]:
|
|
if max_time < i:
|
|
max_y = round_up(max_time, i)
|
|
break
|
|
if max_y is None:
|
|
max_y = round_up(max_time, 100.0)
|
|
plt.ylim(0.0, max_y)
|
|
plt.plot(adj_times, 'o-')
|
|
plt.show()
|
|
|
|
|
|
def parse_gdb_log(file, options):
|
|
'''Parse a GDB log file that was generated by enabling logging with:
|
|
(lldb) log enable --threadsafe --timestamp --file <FILE> gdb-remote packets
|
|
This log file will contain timestamps and this function will then normalize
|
|
those packets to be relative to the first value timestamp that is found and
|
|
show delta times between log lines and also keep track of how long it takes
|
|
for GDB remote commands to make a send/receive round trip. This can be
|
|
handy when trying to figure out why some operation in the debugger is taking
|
|
a long time during a preset set of debugger commands.'''
|
|
|
|
tricky_commands = ['qRegisterInfo']
|
|
timestamp_regex = re.compile('(\s*)([1-9][0-9]+\.[0-9]+)([^0-9].*)$')
|
|
packet_name_regex = re.compile('([A-Za-z_]+)[^a-z]')
|
|
packet_transmit_name_regex = re.compile(
|
|
'(?P<direction>send|read) packet: (?P<packet>.*)')
|
|
packet_contents_name_regex = re.compile('\$([^#]*)#[0-9a-fA-F]{2}')
|
|
packet_checksum_regex = re.compile('.*#[0-9a-fA-F]{2}$')
|
|
packet_names_regex_str = '(' + \
|
|
'|'.join(gdb_remote_commands.keys()) + ')(.*)'
|
|
packet_names_regex = re.compile(packet_names_regex_str)
|
|
|
|
base_time = 0.0
|
|
last_time = 0.0
|
|
min_time = 100000000.0
|
|
packet_total_times = {}
|
|
all_packet_times = []
|
|
packet_times = {}
|
|
packet_counts = {}
|
|
lines = file.read().splitlines()
|
|
last_command = None
|
|
last_command_args = None
|
|
last_command_packet = None
|
|
hide_next_response = False
|
|
num_lines = len(lines)
|
|
skip_count = 0
|
|
for (line_index, line) in enumerate(lines):
|
|
# See if we need to skip any lines
|
|
if skip_count > 0:
|
|
skip_count -= 1
|
|
continue
|
|
m = packet_transmit_name_regex.search(line)
|
|
is_command = False
|
|
direction = None
|
|
if m:
|
|
direction = m.group('direction')
|
|
is_command = direction == 'send'
|
|
packet = m.group('packet')
|
|
sys.stdout.write(options.colors.green())
|
|
if not options.quiet and not hide_next_response:
|
|
print('# ', line)
|
|
sys.stdout.write(options.colors.reset())
|
|
|
|
# print 'direction = "%s", packet = "%s"' % (direction, packet)
|
|
|
|
if packet[0] == '+':
|
|
if is_command:
|
|
print('-->', end=' ')
|
|
else:
|
|
print('<--', end=' ')
|
|
if not options.quiet:
|
|
print('ACK')
|
|
continue
|
|
elif packet[0] == '-':
|
|
if is_command:
|
|
print('-->', end=' ')
|
|
else:
|
|
print('<--', end=' ')
|
|
if not options.quiet:
|
|
print('NACK')
|
|
continue
|
|
elif packet[0] == '$':
|
|
m = packet_contents_name_regex.match(packet)
|
|
if not m and packet[0] == '$':
|
|
multiline_packet = packet
|
|
idx = line_index + 1
|
|
while idx < num_lines:
|
|
if not options.quiet and not hide_next_response:
|
|
print('# ', lines[idx])
|
|
multiline_packet += lines[idx]
|
|
m = packet_contents_name_regex.match(multiline_packet)
|
|
if m:
|
|
packet = multiline_packet
|
|
skip_count = idx - line_index
|
|
break
|
|
else:
|
|
idx += 1
|
|
if m:
|
|
if is_command:
|
|
print('-->', end=' ')
|
|
else:
|
|
print('<--', end=' ')
|
|
contents = decode_packet(m.group(1))
|
|
if is_command:
|
|
hide_next_response = False
|
|
m = packet_names_regex.match(contents)
|
|
if m:
|
|
last_command = m.group(1)
|
|
if last_command == '?':
|
|
last_command = '\\?'
|
|
packet_name = last_command
|
|
last_command_args = m.group(2)
|
|
last_command_packet = contents
|
|
hide_next_response = gdb_remote_commands[last_command][
|
|
'cmd'](options, last_command, last_command_args)
|
|
else:
|
|
packet_match = packet_name_regex.match(contents)
|
|
if packet_match:
|
|
packet_name = packet_match.group(1)
|
|
for tricky_cmd in tricky_commands:
|
|
if packet_name.find(tricky_cmd) == 0:
|
|
packet_name = tricky_cmd
|
|
else:
|
|
packet_name = contents
|
|
last_command = None
|
|
last_command_args = None
|
|
last_command_packet = None
|
|
elif last_command:
|
|
gdb_remote_commands[last_command]['rsp'](
|
|
options, last_command, last_command_args, contents)
|
|
else:
|
|
print('error: invalid packet: "', packet, '"')
|
|
else:
|
|
print('???')
|
|
else:
|
|
print('## ', line)
|
|
match = timestamp_regex.match(line)
|
|
if match:
|
|
curr_time = float(match.group(2))
|
|
if last_time and not is_command:
|
|
delta = curr_time - last_time
|
|
all_packet_times.append(delta)
|
|
delta = 0.0
|
|
if base_time:
|
|
delta = curr_time - last_time
|
|
else:
|
|
base_time = curr_time
|
|
|
|
if not is_command:
|
|
if line.find('read packet: $') >= 0 and packet_name:
|
|
if packet_name in packet_total_times:
|
|
packet_total_times[packet_name] += delta
|
|
packet_counts[packet_name] += 1
|
|
else:
|
|
packet_total_times[packet_name] = delta
|
|
packet_counts[packet_name] = 1
|
|
if packet_name not in packet_times:
|
|
packet_times[packet_name] = []
|
|
packet_times[packet_name].append(delta)
|
|
packet_name = None
|
|
if min_time > delta:
|
|
min_time = delta
|
|
|
|
if not options or not options.quiet:
|
|
print('%s%.6f %+.6f%s' % (match.group(1),
|
|
curr_time - base_time,
|
|
delta,
|
|
match.group(3)))
|
|
last_time = curr_time
|
|
# else:
|
|
# print line
|
|
(average, std_dev) = calculate_mean_and_standard_deviation(all_packet_times)
|
|
if average and std_dev:
|
|
print('%u packets with average packet time of %f and standard deviation of %f' % (len(all_packet_times), average, std_dev))
|
|
if packet_total_times:
|
|
total_packet_time = 0.0
|
|
total_packet_count = 0
|
|
for key, vvv in packet_total_times.items():
|
|
# print ' key = (%s) "%s"' % (type(key), key)
|
|
# print 'value = (%s) %s' % (type(vvv), vvv)
|
|
# if type(vvv) == 'float':
|
|
total_packet_time += vvv
|
|
for key, vvv in packet_counts.items():
|
|
total_packet_count += vvv
|
|
|
|
print('#------------------------------------------------------------')
|
|
print('# Packet timing summary:')
|
|
print('# Totals: time = %6f, count = %6d' % (total_packet_time,
|
|
total_packet_count))
|
|
print('# Min packet time: time = %6f' % (min_time))
|
|
print('#------------------------------------------------------------')
|
|
print('# Packet Time (sec) Percent Count Latency')
|
|
print('#------------------------- ----------- ------- ------ -------')
|
|
if options and options.sort_count:
|
|
res = sorted(
|
|
packet_counts,
|
|
key=packet_counts.__getitem__,
|
|
reverse=True)
|
|
else:
|
|
res = sorted(
|
|
packet_total_times,
|
|
key=packet_total_times.__getitem__,
|
|
reverse=True)
|
|
|
|
if last_time > 0.0:
|
|
for item in res:
|
|
packet_total_time = packet_total_times[item]
|
|
packet_percent = (
|
|
packet_total_time / total_packet_time) * 100.0
|
|
packet_count = packet_counts[item]
|
|
print(" %24s %11.6f %5.2f%% %6d %9.6f" % (
|
|
item, packet_total_time, packet_percent, packet_count,
|
|
float(packet_total_time) / float(packet_count)))
|
|
if options.plot:
|
|
plot_latencies(packet_times)
|
|
|
|
if __name__ == '__main__':
|
|
usage = "usage: gdbremote [options]"
|
|
description = '''The command disassembles a GDB remote packet log.'''
|
|
parser = optparse.OptionParser(
|
|
description=description,
|
|
prog='gdbremote',
|
|
usage=usage)
|
|
parser.add_option(
|
|
'-v',
|
|
'--verbose',
|
|
action='store_true',
|
|
dest='verbose',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'--plot',
|
|
action='store_true',
|
|
dest='plot',
|
|
help='plot packet latencies by packet type',
|
|
default=False)
|
|
parser.add_option(
|
|
'-q',
|
|
'--quiet',
|
|
action='store_true',
|
|
dest='quiet',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'-C',
|
|
'--color',
|
|
action='store_true',
|
|
dest='color',
|
|
help='add terminal colors',
|
|
default=False)
|
|
parser.add_option(
|
|
'-c',
|
|
'--sort-by-count',
|
|
action='store_true',
|
|
dest='sort_count',
|
|
help='display verbose debug info',
|
|
default=False)
|
|
parser.add_option(
|
|
'--crashlog',
|
|
type='string',
|
|
dest='crashlog',
|
|
help='symbolicate using a darwin crash log file',
|
|
default=False)
|
|
try:
|
|
(options, args) = parser.parse_args(sys.argv[1:])
|
|
except:
|
|
print('error: argument error')
|
|
sys.exit(1)
|
|
|
|
options.colors = TerminalColors(options.color)
|
|
options.symbolicator = None
|
|
if options.crashlog:
|
|
import lldb
|
|
lldb.debugger = lldb.SBDebugger.Create()
|
|
import lldb.macosx.crashlog
|
|
options.symbolicator = lldb.macosx.crashlog.CrashLog(options.crashlog)
|
|
print('%s' % (options.symbolicator))
|
|
|
|
# This script is being run from the command line, create a debugger in case we are
|
|
# going to use any debugger functions in our function.
|
|
if len(args):
|
|
for file in args:
|
|
print('#----------------------------------------------------------------------')
|
|
print("# GDB remote log file: '%s'" % file)
|
|
print('#----------------------------------------------------------------------')
|
|
parse_gdb_log_file(file, options)
|
|
if options.symbolicator:
|
|
print('%s' % (options.symbolicator))
|
|
else:
|
|
parse_gdb_log(sys.stdin, options)
|
|
|
|
else:
|
|
import lldb
|
|
if lldb.debugger:
|
|
# This initializer is being run from LLDB in the embedded command interpreter
|
|
# Add any commands contained in this module to LLDB
|
|
lldb.debugger.HandleCommand(
|
|
'command script add -f gdbremote.start_gdb_log start_gdb_log')
|
|
lldb.debugger.HandleCommand(
|
|
'command script add -f gdbremote.stop_gdb_log stop_gdb_log')
|
|
print('The "start_gdb_log" and "stop_gdb_log" commands are now installed and ready for use, type "start_gdb_log --help" or "stop_gdb_log --help" for more information')
|