| #!/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. |
| # ---------------------------------------------------------------------- |
| |
| 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( |
| "--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( |
| "-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 self.str.split(ch) |
| |
| def split_hex(self, ch, byte_order): |
| hex_values = list() |
| strings = self.str.split(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) = args.split(";") |
| 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)) |
| if not rsp: |
| return |
| try: |
| json_tree = json.loads(rsp) |
| print(json.dumps(json_tree, indent=4, separators=(",", ": "))) |
| except json.JSONDecodeError: |
| return |
| |
| |
| 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 and 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( |
| "-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) |
| |
| |
| def __lldb_init_module(debugger, internal_dict): |
| # This initializer is being run from LLDB in the embedded command interpreter |
| # Add any commands contained in this module to LLDB |
| debugger.HandleCommand( |
| "command script add -o -f gdbremote.start_gdb_log start_gdb_log" |
| ) |
| debugger.HandleCommand( |
| "command script add -o -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' |
| ) |