def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
gdb.write('usage: qemu coroutine <coroutine-pointer>\n')
return
bt_jmpbuf(coroutine_to_jmpbuf(gdb.parse_and_eval(argv[0])))
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 2:
raise gdb.GdbError('hex-dump takes exactly 2 arguments.')
addr = gdb.parse_and_eval(argv[0]).cast(
gdb.lookup_type('void').pointer())
try:
bytes = int(gdb.parse_and_eval(argv[1]))
except ValueError:
raise gdb.GdbError('Byte count numst be an integer value.')
inferior = gdb.selected_inferior()
align = gdb.parameter('hex-dump-align')
width = gdb.parameter('hex-dump-width')
if width == 0:
width = 16
mem = inferior.read_memory(addr, bytes)
pr_addr = int(str(addr), 16)
pr_offset = width
if align:
pr_offset = width - (pr_addr % width)
pr_addr -= pr_addr % width
for group in groups_of(mem, width, pr_offset):
print '0x%x: ' % (pr_addr,) + ' '*(width - pr_offset),
print ' '.join(['%02X' % (ord(g),) for g in group]) + \
' ' * (width - len(group) if pr_offset == width else 0) + ' ',
print ' '*(width - pr_offset) + ''.join(
[g if isgraph(g) or g == ' ' else '.' for g in group])
pr_addr += width
pr_offset = width
def invoke (self, arg_str, from_tty):
argv = gdb.string_to_argv(arg_str)
if len (argv) == 0:
raise gdb.GdbError ("Provide at least one parameter with the "
+ "breakpoint specification");
self.bspec = argv[0]
if "clones" in argv:
self.clones = True
pass
else:
self.clones = False
pass
if "nonames" in argv:
self.only_orders = True
pass
else:
self.only_orders = False
pass
if "onlyreftof" in argv:
self.only_ref_to_f = True
pass
else:
self.only_ref_to_f = False
pass
bp = self.SnapshotBreakpoint (self.bspec)
bp.cmd = self
def invoke(self, args, isatty):
if not self.repeat:
self.dont_repeat()
self.parser.set_defaults(isatty=isatty)
# Not sure we trust gdb to split the line as we want it, but
# until there are problems we'll let him give it a shot.
args = gdb.string_to_argv(args)
try:
args = self.parser.parse_args(args)
self.run(args)
except KeyboardInterrupt as e:
pass
except SystemExit as e:
if isinstance(e.code, int):
raise gdb.GdbError("command exited with status %s." % e.code)
elif e.code:
raise gdb.GdbError(str(e))
except gdb.GdbError:
# This type of error can be used to repport failure to gdb.
# We let is pass through so that applications can print errors.
# Still, the prefered way for an extension to do this
# would be to simply use exit().
raise
except BaseException as e:
if getattr(args, "isatty", True):
# Gdb can't give us a full traceback. If this is a tty
# or if error occured during argument parsing we do it.
print("%s" % (traceback.format_exc(),), end="")
else:
raise gdb.GdbError(e)
def invoke (self, args, from_tty):
argv = gdb.string_to_argv(args)
newestFrame = gdb.newest_frame()
print ("the newest frame is : " + newestFrame.name())
architecture = newestFrame.architecture()
print ("this architecture is : " + architecture.name())
def invoke(self, args, from_tty):
# Prepare
flash_prepare_and_show()
# param
argv = gdb.string_to_argv(args)
if len(argv) == 0:
begin = 0
length = flash_size - flash_sector_size # last is CPFT data
elif len(argv) == 2:
begin = int(argv[0]) * 1024
length = int(argv[1]) * 1024
else:
raise gdb.GdbError('Invalid params, "help flash_erase" for more infomation')
# Info
print("Erase begin={}kB length={}kB".format(begin/1024, length/1024))
# Erase
print(" Erase...")
gdb.execute('set $res=flash_erase({}, {}, 0)'.format(begin, length))
# Finish
print("Finish")
flash_finish()
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
state.restore()
#gdb.execute("thread 15", False, True)
#cur_os_thread = gdb.selected_thread().num
frame = gdb.newest_frame()
handle_attach = False
count = 0
while True:
function = frame.function()
if function and function.name == "hpx::util::command_line_handling::handle_attach_debugger()":
handle_attach = True
break
frame = frame.older()
if not frame or count > 5:
break
count = count + 1
if handle_attach:
frame.select()
gdb.execute("set var i = 1", True)
#gdb.execute("thread %d" % cur_os_thread, False, True)
if len(argv) == 0:
print "Continuing..."
gdb.execute("continue")
else:
if argv[0] != "hook":
print "wrong argument ..."
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
if len(argv) != 1:
raise gdb.GdbError('solib takes 1 arg')
Strongdb.run_cmd('set solib-search-path %s' % (argv[0]))
def parse_xm_command_args(arg):
"""Parses the arguments passed to a xmethod command.
Arguments:
arg: The argument string passed to a xmethod command.
Returns:
A 3-tuple: (<locus matching regular expression>,
<matcher matching regular expression>,
<name matching regular experession>)
"""
argv = gdb.string_to_argv(arg)
argc = len(argv)
if argc > 2:
raise SyntaxError("Too many arguments to command.")
locus_regexp = ""
matcher_name_regexp = ""
xm_name_regexp = None
if argc >= 1:
locus_regexp = argv[0]
if argc == 2:
parts = argv[1].split(";", 1)
matcher_name_regexp = parts[0]
if len(parts) > 1:
xm_name_regexp = parts[1]
if xm_name_regexp:
name_re = validate_xm_regexp("xmethod name", xm_name_regexp)
else:
name_re = None
return (validate_xm_regexp("locus", locus_regexp),
validate_xm_regexp("matcher name", matcher_name_regexp),
name_re)
def invoke(self, argument, from_tty):
# parse arguments
args = gdb.string_to_argv(argument)
if not args:
print "Error: Missing arguments"
return
else:
if issm.jp_data is not None:
tab_name = args[0]
tabs = issm.jp_data['Tabs']
for tab in tabs:
if tab['name'] == tab_name:
if 'command' in tab:
json_string = gdb.execute(tab['command'], True, True)
# TODO: get nice way to display data to user in CMD
json_list = ast.literal_eval(json_string)
issm.json_printer(json_list)
# print json.dumps(json_list, sort_keys=False, indent=4, separators=(',',': '))
return
else:
print "Error: No 'command' tag found for tab '" + tab_name + "'"
return
else:
print "Error: Tab not found"
else:
print "Error: Invalid layout file"
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
# generally, we type "plot someimage" in the GDB commandline
# where "someimage" is an instance of cv::Mat
v = gdb.parse_and_eval(args[0])
# the value v is a gdb.Value object of C++
# code's cv::Mat, we need to translate to
# a python object under cv2.cv
image_size = (v['cols'],v['rows'])
# print v
# these two below lines do not work. I don't know why
# channel = gdb.execute("call "+ args[0] + ".channels()", False, True)
# channel = v.channels();
CV_8U =0
CV_8S =1
CV_16U=2
CV_16S=3
CV_32S=4
CV_32F=5
CV_64F=6
CV_USRTYPE1=7
CV_CN_MAX = 512
CV_CN_SHIFT = 3
CV_MAT_CN_MASK = (CV_CN_MAX - 1) << CV_CN_SHIFT
flags = v['flags']
channel = (((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1
CV_DEPTH_MAX = (1 << CV_CN_SHIFT)
CV_MAT_DEPTH_MASK = CV_DEPTH_MAX - 1
depth = (flags) & CV_MAT_DEPTH_MASK
IPL_DEPTH_SIGN = 0x80000000
cv_elem_size = (((4<<28)|0x8442211) >> depth*4) & 15
if (depth == CV_8S or depth == CV_16S or depth == CV_32S):
mask = IPL_DEPTH_SIGN
else:
mask = 0
ipl_depth = cv_elem_size*8 | mask
img = cv.CreateImageHeader(image_size, ipl_depth, channel)
# conver the v['data'] type to "char*" type
char_type = gdb.lookup_type("char")
char_pointer_type =char_type.pointer()
buffer = v['data'].cast(char_pointer_type)
# read bytes from inferior's memory, because
# we run the opencv-python module in GDB's own process
# otherwise, we use memory corss processes
buf = v['step']['buf']
bytes = buf[0] * v['rows'] # buf[0] is the step? Not quite sure.
inferior = gdb.selected_inferior()
mem = inferior.read_memory(buffer, bytes)
# set the img's raw data
cv.SetData(img, mem)
mat = np.asarray(img[:,:])
print ("Type: {}".format(mat.dtype))
print (mat)
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
v = gdb.parse_and_eval(args[0])
strType = gdb.execute("print "+ args[0] + ".type()", False, True)
# strType contains gdb answers as a string of the form "$2 = 42"
img = cv.CreateMat(v['rows'], v['cols'], int(strType.split(" ")[2]))
# convert v['data'] to char*
char_type = gdb.lookup_type("char")
char_pointer_type = char_type.pointer()
buffer = v['data'].cast(char_pointer_type)
# read bytes from inferior's process memory
buf = v['step']['buf']
bytes = buf[0] * v['rows']
inferior = gdb.selected_inferior()
mem = inferior.read_memory(buffer, bytes)
# set the matrix raw data
cv.SetData(img, mem)
# save matrix as an xml file and open it with matrix viewer
cv.Save("/tmp/dump.xml", img, "matrix")
call(["matrix-viewer", "/tmp/dump.xml"])
def invoke(self, arg, from_tty):
ports = False
wanted = False
arg_list = gdb.string_to_argv(arg)
if len(arg_list) > 1 or \
(len(arg_list) == 1 and arg_list[0] != "ports" and
arg_list[0] != "wanted"):
print("usage: ovs_dump_bridge {ports|wanted}")
return
elif len(arg_list) == 1:
if arg_list[0] == "ports":
ports = True
else:
wanted = True
all_bridges = get_global_variable('all_bridges')
if all_bridges is None:
return
for node in ForEachHMAP(all_bridges,
"struct bridge", "node"):
print("(struct bridge *) {}: name = {}, type = {}".
format(node, node['name'].string(),
node['type'].string()))
if ports:
for port in ForEachHMAP(node['ports'],
"struct port", "hmap_node"):
CmdDumpBridgePorts.display_single_port(port, 4)
if wanted:
for port in ForEachSHASH(node['wanted_ports'],
typeobj="struct ovsrec_port"):
print(" (struct ovsrec_port *) {}: name = {}".
format(port, port['name'].string()))
def invoke(self, arg, from_tty):
arg_list = gdb.string_to_argv(arg)
all_udpifs = get_global_variable('all_udpifs')
if all_udpifs is None:
return
udpifs = dict()
for udpif in ForEachLIST(all_udpifs, "struct udpif", "list_node"):
udpifs[udpif['dpif']['full_name'].string()] = udpif
if len(arg_list) == 0:
print("(struct udpif *) {}: name = {}, total keys = {}".
format(udpif, udpif['dpif']['full_name'].string(),
self.count_all_ukeys(udpif)))
if len(arg_list) == 0:
return
if arg_list[0] in udpifs:
udpif = udpifs[arg_list[0]]
else:
try:
udpif = gdb.parse_and_eval(arg_list[0]).cast(
gdb.lookup_type('struct udpif').pointer())
except Exception:
udpif = None
if udpif is None:
print("Can't find provided udpif address!")
return
self.dump_all_ukeys(udpif, 0, "short" in arg_list[1:])
def invoke(self, argument, from_tty):
# parse arguments
args = gdb.string_to_argv(argument)
if not args:
print "Error: Missing arguments"
print help(self)
return
# check for valid layout data
if issm.jp_data is not None:
tab_name = args[0]
tabs = issm.jp_data['Tabs']
for tab in tabs:
if tab['name'] == tab_name:
if 'command' in tab:
json_string = gdb.execute(tab['command'], False, True)
print json_string
return
else:
print "Error: No 'command' tag found for tab '" + tab_name + "'"
return
else:
print "Error: Tab not found"
else:
print "Error: Invalid layout file"
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
qTypes = []
if( len(argv) > 0 ):
for a in argv:
try:
qType = QueueMode.Map[a]
qTypes.append(qType)
except KeyError:
print("Arg %s does not map to a Queue Type!" % a)
reg = HandleRegistry()
qToShow = []
if ( len(qTypes) > 0 ):
# We will only print info about queues
for qType in qTypes:
qObjs = reg.FilterBy(qType)
qToShow.extend(qObjs)
else:
qToShow = reg.FilterBy(None)
print("Num Queues: %d" % len(qToShow))
print("%20s %4s %16s %16s" % ("NAME", "CNT", "SEND", "RECEIVE") )
for q in qToShow:
self.PrintQueueInfo(q)
def invoke(self, _args, from_tty):
args = gdb.string_to_argv(_args)
start_node = args[0]
if len(args) > 1:
max_iter = int(args[1])
else:
max_iter = self.MAX_ITER
if len(args) > 2:
lvl = int(args[2])
else:
lvl = 0
p_node_t = gdb.lookup_type('node_t').pointer()
long_t = gdb.lookup_type('long')
node = gdb.parse_and_eval(start_node)
print node
for i in xrange(max_iter):
nexts = node['next']
nxt = gdb.Value(nexts[lvl]).cast(long_t)
nxt = nxt & ~1
node = gdb.Value(nxt).cast(p_node_t).dereference()
nexts = node['next']
print node['k'], node['level'], node['inserting'],
k = 0
while k < node['level']:
print(nexts[k]),
k+=1
print("")
def parse_unwinder_command_args(arg):
"""Internal utility to parse unwinder command argv.
Arguments:
arg: The arguments to the command. The format is:
[locus-regexp [name-regexp]]
Returns:
A 2-tuple of compiled regular expressions.
Raises:
SyntaxError: an error processing ARG
"""
argv = gdb.string_to_argv(arg)
argc = len(argv)
if argc > 2:
raise SyntaxError("Too many arguments.")
locus_regexp = ""
name_regexp = ""
if argc >= 1:
locus_regexp = argv[0]
if argc >= 2:
name_regexp = argv[1]
return (validate_regexp(locus_regexp, "locus"),
validate_regexp(name_regexp, "unwinder"))
def invoke (self, args, from_tty):
argv = gdb.string_to_argv(args)
if len(argv) > 1:
err("Usage: lvmst [L]")
if len(argv) == 1:
L = gdbutils.parse_ptr(argv[0], "lua_State*")
if not L or str(L) == "void":
raise gdb.GdbError("L empty")
else:
L = get_cur_L()
#print "g: ", hex(int(L['glref']['ptr32']))
g = G(L)
vmstate = int(g['vmstate'])
if vmstate >= 0:
out("Compiled (trace #%d)\n" % vmstate)
elif ~vmstate >= LJ_VMST__MAX:
raise gdb.GdbError("Invalid VM state: ", ~vmstate)
else:
#print "vmstate = %d" % vmstate
out("current VM state: %s\n" % vmstates[~vmstate])
def invoke(self, argument, from_tty):
parser = self.NoexitArgumentParser(prog=self._command,
description=self.__doc__)
parser.add_argument('limit', metavar='limit', type=int, nargs='?',
default=sys.maxsize, help='Only consider [limit] stack frames')
parser.add_argument('--skip', metavar='N', nargs='?', type=int,
default=0, help='Skip first [N] stack frames')
parser.add_argument('--ignore-pc', action='store_true', default=False,
help='Ignore program counter for frame equivalence')
parser.add_argument('--show-source', action='store_true', default=False,
help='Show source file and line info, if available')
args = parser.parse_args(gdb.string_to_argv(argument))
traces = []
for thread in gdb.inferiors()[0].threads():
traces.append(stacks.StackTrace(thread, args.skip, args.limit,
args.ignore_pc, args.show_source))
uniq = {}
for stack in traces:
uniq.setdefault(stack,[]).append(stack.gdb_thread_id)
sorter = lambda d: sorted(d.items(), key=lambda item: len(item[1]),
reverse=True)
gdb.write("\n== Printing {} unique stacks from {} threads\n\n".format(
len(uniq), len(traces)))
for k, v in sorter(uniq):
gdb.write("Stack for thread ids {}\n".format(sorted(v)))
gdb.write(str(k))
gdb.write("\n\n")
gdb.flush()
def invoke(self, argument, from_tty):
# parse arguments
args = gdb.string_to_argv(argument)
if not args:
print "Error: Missing arguments"
print help(self)
return
expr = args[0]
follow_key = args[1]
print_keys = args[2::]
# initialize list of elements in linked list
elements_container = []
gdb_value_llist = gdb.parse_and_eval(expr)
# walk linked list
if is_pointer_init(gdb_value_llist):
follow_link_list(gdb_value_llist, follow_key, print_keys, elements_container)
if from_tty:
print elements_container
else:
print ISSM_START + json.dumps(elements_container) + ISSM_END
else:
error = "Error: No initialized pointer"
if from_tty:
print error
else:
print ISSM_START + json.dumps([error]) + ISSM_END
def invoke(self, argstr, from_tty):
argv = gdb.string_to_argv(argstr)
try:
args = self.parser.parse_args(argv)
self.execute(args)
except SystemExit:
return
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
redmagic_info = gdb.execute('info shared redmagic', to_string=True).split('\n')[-2].split()
redmagic_start = int(redmagic_info[0], 16)
redmagic_end = int(redmagic_info[1], 16)
search = argv[0]
verbose = False
gdb.execute('break red_asm_resume_eval_block')
while True:
rip = int(gdb.parse_and_eval('$rip'))
if redmagic_start < rip < redmagic_end:
li = gdb.execute('x/i {}'.format(rip), to_string=True)
if 'red_asm_resume_eval_block' in li:
gdb.execute('si', to_string=True)
else:
gdb.execute('n', to_string=True)
else:
regs_info = gdb.execute('info all-registers', to_string=True)
if search in regs_info:
stack = gdb.execute('bt', to_string=True)
# filter out methods that are called from the tracer such as memcpy etc
if 'red_asm_begin_block' not in stack:
sr = '\n\t'.join([r for r in regs_info.split('\n') if search in r])
gdb.write('search pattern found in: \n\t{}'.format(sr))
return
gdb.execute('si', to_string=True)
def invoke(self, arg, from_tty):
arg_list = gdb.string_to_argv(arg)
typeobj = None
member = None
dump = False
if len(arg_list) != 1 and len(arg_list) != 3 and len(arg_list) != 4:
print("usage: ovs_dump_ovs_list <struct ovs_list *> "
"{[<structure>] [<member>] {dump}]}")
return
header = gdb.parse_and_eval(arg_list[0]).cast(
gdb.lookup_type('struct ovs_list').pointer())
if len(arg_list) >= 3:
typeobj = arg_list[1]
member = arg_list[2]
if len(arg_list) == 4 and arg_list[3] == "dump":
dump = True
for node in ForEachLIST(header.dereference()):
if typeobj is None or member is None:
print("(struct ovs_list *) {}".format(node))
else:
print("({} *) {} =".format(
typeobj,
container_of(node,
gdb.lookup_type(typeobj).pointer(), member)))
if dump:
print(" {}\n".format(container_of(
node,
gdb.lookup_type(typeobj).pointer(),
member).dereference()))
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
zero = 0
if len(args) < 1:
print 'Usage: kgraph <object> [zeropoint]'
return
x = gdb.parse_and_eval(args[0])
if len(args) > 1:
zero = int(gdb.parse_and_eval(args[1]))
data = self.kk.crunch(x)
(rms, maxi, mini) = self.kk.calcrms(data, zero)
fig = plot.figure()
ax = fig.add_subplot(111)
ax.grid(True)
label = "%s RMS=%f" % (args[0], rms)
ax.plot(data, '.', label=label)
ax.plot((maxi, mini), (data[maxi], data[mini]), "kD", label="max-min")
plot.figtext(0.01,0.01, "RMS=%f max:%d, min:%d, start=%d" % (rms, max(data), min(data), zero))
print("rms: %f max:%d, min:%d" % (rms, max(data), min(data)))
print("maxi/mini at ", maxi, mini)
leg = ax.legend()#label, 'upper right', shadow=False)
leg.get_frame().set_alpha(0.5)
plot.show()
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
v = gdb.parse_and_eval(args[0])
cols, rows = int(v['cols']), int(v['rows'])
channel, depth = self.decode_flag(v['flags'])
if depth != CV_8U:
print("support CV_8U only")
return
# conver the v['data'] type to "char*" type
char_type = gdb.lookup_type("char")
char_pointer_type = char_type.pointer()
buffer_ptr = v['data'].cast(char_pointer_type)
# read bytes from inferior's memory, because
# we run the opencv-python module in GDB's own process
# otherwise, we use memory corss processes
buf = v['step']['buf']
bytes_cnt = buf[0] * v['rows']
inferior = gdb.selected_inferior()
mem = inferior.read_memory(buffer_ptr, bytes_cnt)
img = np.frombuffer(mem, dtype='uint8', count=int(bytes_cnt))
img = img.reshape(rows, cols, channel)
# cv2.startWindowThread()
cv2.namedWindow('viewer')
cv2.imshow('viewer', img)
cv2.waitKey(0)
cv2.destroyWindow('viewer')
def _enable_parse_arg(cmd_name, arg):
""" Internal worker function to take an argument from
enable/disable and return a tuple of arguments.
Arguments:
cmd_name: Name of the command invoking this function.
args: The argument as a string.
Returns:
A tuple containing the dictionary, and the argument, or just
the dictionary in the case of "all".
"""
argv = gdb.string_to_argv(arg);
argc = len(argv)
if argc == 0:
raise gdb.GdbError(cmd_name + " requires an argument")
if argv[0] == "all":
if argc > 1:
raise gdb.GdbError(cmd_name + ": with 'all' " \
"you may not specify a filter.")
elif argc != 2:
raise gdb.GdbError(cmd_name + " takes exactly two arguments.")
return argv
def invoke(self, arg, from_tty):
arg_list = gdb.string_to_argv(arg)
all_ofproto_dpifs_by_name = get_global_variable(
'all_ofproto_dpifs_by_name')
if all_ofproto_dpifs_by_name is None:
return
all_name = dict()
max_name_len = 0
for node in ForEachHMAP(all_ofproto_dpifs_by_name,
"struct ofproto_dpif",
"all_ofproto_dpifs_by_name_node"):
all_name[node['up']['name'].string()] = node
if len(node['up']['name'].string()) > max_name_len:
max_name_len = len(node['up']['name'].string())
if len(arg_list) == 0:
for name in sorted(all_name.iterkeys()):
print("{}: (struct mac_learning *) {}".
format(name.ljust(max_name_len),
all_name[name]['ml']))
self.display_ml_summary(all_name[name]['ml'], 4)
else:
if not arg_list[0] in all_name:
print("ERROR: Given bridge name is not known!")
return
ml = all_name[arg_list[0]]['ml']
self.display_ml_summary(ml, 0, "dbg" in arg_list[1:])
self.display_ml_entries(ml, 0, "hash" in arg_list[1:],
"dbg" in arg_list[1:])
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) != 1:
print 'Usage: rblog <object>'
return
rblog = gdb.parse_and_eval(args[0])
num_entries = rblog['num_entries']
num_arguments = rblog['num_arguments']
entries = rblog['entries']
index = rblog['index']
if entries[index]['string']:
r = range(index, num_entries) + range(index)
else:
r = range(index)
for i in r:
entry = entries[i]
timestamp = int(entry['timestamp'])
if not entry['string']:
break
string = entry['string'].string()
arguments = [int(entry['arguments'][i]) for i in range(num_arguments)]
try:
string = string % tuple(arguments[:string.count('%') - 2 * string.count('%%')])
except:
pass
print '%8d %-80s %s' % (timestamp, string, ' '.join('%08x' % a for a in arguments))
def invoke(self, arg, from_tty):
arg = gdb.string_to_argv(arg)
if len(arg) != 2:
raise gdb.GdbError("Usage: sol_flow print options <node> <options>")
type = get_node_type_from_exp(arg[0])
options = gdb.parse_and_eval(arg[1])
gdb.write(get_type_options_string(type, options))
def complete(self, text, word):
args = gdb.string_to_argv(text)
if text.endswith(" "):
args.append("")
num_args = len(args)
comp = []
if (num_args == 0):
comp.append("help")
for p in self.svd_file.peripherals:
comp.append(p)
elif (num_args == 1):
for p in self.file.peripherals():
if (p.startswith(args[0].upper())):
comp.append(p)
else:
for r in self.register_list(args[0].upper()):
if r.upper().startswith(args[1].upper()):
comp.append(r)
return comp
def _enable_parse_arg(cmd_name, arg):
""" Internal worker function to take an argument from
enable/disable and return a tuple of arguments.
Arguments:
cmd_name: Name of the command invoking this function.
args: The argument as a string.
Returns:
A tuple containing the dictionary, and the argument, or just
the dictionary in the case of "all".
"""
argv = gdb.string_to_argv(arg)
argc = len(argv)
if argv[0] == "all" and argc > 1:
raise gdb.GdbError(cmd_name + ": with 'all' " \
"you may not specify a filter.")
else:
if argv[0] != "all" and argc != 2:
raise gdb.GdbError(cmd_name + " takes exactly two arguments.")
return argv
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
print(args)
signed = False
if len(args) < 2:
print("Usage: %s <object> <length in elements> [signed]" %
(self.name))
return
# This is ugly, but so be it.
source = gdb.parse_and_eval(args[0])
addr = int(str(source), 0)
length = int(args[1], 0)
if len(args) > 2 and args[2] == "signed":
signed = True
elem_size = source.dereference().type.sizeof
print("address = %#x, length = %d, signed = %s, size of each :%d" %
(addr, length, signed, elem_size))
q = gdb.selected_inferior().read_memory(addr, length * elem_size)
fmt = "<%d%s" % (length, make_format_string_numeric(elem_size, signed))
undone = struct.unpack(fmt, q)
for qq in undone:
print("%#x (%d)" % (qq, qq))
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
print(
"Error: You need to supply at least one argument. See help hpx thread"
)
return
if argv[0] == "restore":
state.restore()
return
if argv[0][0] == '0' and argv[0][1] == 'x':
thread_id = gdb.Value(int(argv[0], 16))
else:
thread_id = gdb.Value(int(argv[0]))
thread = HPXThread(thread_id)
print("Switched to HPX Thread 0x%x" % thread_id)
print(thread.pc_string)
state.save_context(thread.context.switch())
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
global curunit
if len(argv) == 0:
if curunit is None:
print('unit: No Unit set.')
else:
gdbprint(curunit)
return
if len(argv) > 1:
print('Usage: unit [Unit*|none]')
return
if argv[0] == 'none':
curunit = None
return
else:
unit_type = T('HPHP::Unit').const().pointer()
curunit = gdb.parse_and_eval(argv[0]).cast(unit_type)
gdbprint(curunit)
def invoke(self, arg, from_tty):
try:
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
raise Exception("Invalide parameter")
pathfile = argv[0]
gdb.write("Svd Loading {} ".format(pathfile))
parser = SVDParser.for_xml_file(pathfile)
device = parser.get_device()
peripherals = dict((peripheral.name, peripheral)
for peripheral in device.peripherals)
GdbSvdGetCmd(device, peripherals)
GdbSvdSetCmd(device, peripherals)
GdbSvdInfoCmd(device, peripherals)
except Exception as inst:
gdb.write("\n{}\n".format(inst))
gdb.execute("help svd")
except IOError:
gdb.write("\nFailed to load SVD file\n")
else:
gdb.write("Done\n")
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if args[0] == "set" or args[0] == "s":
newBreak = CounterBreakpoint(args[1])
self.breakpoints[newBreak.number] = newBreak
self.show()
elif args[0] == "clear" or args[0] == "c":
if (len(args) == 2):
bid = int(args[1])
print(bid)
self.clear(bid)
elif len(args) == 1 or args[1] == "all":
self.clear()
elif args[0] == "show":
self.show()
elif args[0] == "stop":
if (len(args) == 3):
bid = int(args[1])
count = int(args[2])
self.setGoal(bid, count)
elif (len(args) == 2):
bid = int(args[1])
self.setGoal(bid)
def invokeHelper(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
print("Malformed arguments; see help")
return
hdrPtr = gdb.parse_and_eval('(ElmHdr *) ' + argv[0])
hdr = hdrPtr.dereference()
grArgs = gdb.parse_and_eval("grArgs")
maxAllocFrames = int(grArgs['maxTrackFrames'])
maxFreeFrames = int(grArgs['maxTrackFreeFrames'])
if self.isValid(hdr['magic']):
print("Address %s is a header" % argv[0])
else:
hdrPtr = gdb.parse_and_eval('*(ElmHdr **)((char *)' + argv[0] + ' - sizeof(void *))')
hdr = hdrPtr.dereference()
if self.isValid(hdr['magic']):
print("Address %s is a user address" % argv[0])
else:
print("Address %s doesn't look valid" % argv[0])
return
if hdr['magic'] == MAGIC_INUSE:
print("Address %s is in-use" % argv[0])
elif hdr['magic'] == MAGIC_FREE:
print("Address %s is free" % argv[0])
print("Header:")
print(hdr)
trace = hdr['allocBt']
print("================ Allocation Trace: ================")
self.dumpSymTrace(trace, 0, maxAllocFrames)
print("================ Free Trace: ================")
self.dumpSymTrace(trace, maxAllocFrames + 1, maxFreeFrames)
def invoke(self, arg, from_tty):
arg_list = gdb.string_to_argv(arg)
all_udpifs = get_global_variable('all_udpifs')
no_count = "no_count" in arg_list
if all_udpifs is None:
return
udpifs = dict()
for udpif in ForEachLIST(all_udpifs, "struct udpif", "list_node"):
udpifs[udpif['dpif']['full_name'].string()] = udpif
if len(arg_list) == 0 or (len(arg_list) == 1
and arg_list[0] == "no_count"):
print("(struct udpif *) {}: name = {}, total keys = {}".format(
udpif, udpif['dpif']['full_name'].string(),
self.count_all_ukeys(udpif)
if not no_count else "<not counted!>"))
if len(arg_list) == 0 or (len(arg_list) == 1
and arg_list[0] == "no_count"):
return
if arg_list[0] in udpifs:
udpif = udpifs[arg_list[0]]
else:
try:
udpif = gdb.parse_and_eval(arg_list[0]).cast(
gdb.lookup_type('struct udpif').pointer())
except Exception:
udpif = None
if udpif is None:
print("Can't find provided udpif address!")
return
self.dump_all_ukeys(udpif, 0, "short" in arg_list[1:])
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
redmagic_info = gdb.execute('info shared redmagic', to_string=True).split('\n')[-2].split()
redmagic_start = int(redmagic_info[0], 16)
redmagic_end = int(redmagic_info[1], 16)
verbose = False
branches_taken = []
def get_rip():
return int(gdb.parse_and_eval('$rip'))
# so that we can determine where it is resuming the trace
gdb.execute('break red_asm_resume_eval_block')
current_rip = get_rip()
while True:
last_rip = current_rip
if not verbose and redmagic_start < last_rip < redmagic_end:
li = gdb.execute('x/i {}'.format(last_rip), to_string=True)
if 'red_asm_resume_eval_block' in li:
gdb.execute('si', to_string=True)
else:
gdb.execute('n', to_string=True)
current_rip = get_rip()
else:
gdb.execute('si', to_string=True)
current_rip = get_rip()
if not (0 < current_rip - last_rip < 15):
# then we probably have taken a branch or something
li = gdb.execute('x/i {}'.format(last_rip), to_string=True)
if verbose or ('__tls_get_addr' not in li and '_dl_addr' not in li):
#branches_taken.append(li)
gdb.write(li)
class InfoEpcCommand(gdb.Command):
"""For debugging EPC data structue
Just calling "info epc" prints address of all epc page.
To print specific epc page, pass its index as a parameter
e.g.) info epc 0 """
epcType = 0
def __init__(self):
super(InfoEpcCommand, self).__init__("info epc", gdb.COMMAND_STATUS,
gdb.COMPLETE_NONE)
def invoke(self, arg, from_tty):
# EPC symbol check
try:
self.epcType = gdb.lookup_type('epc_t')
except RuntimeError, e:
print "type epc_t nof found"
return
# get args, arg_list[0] indicate index
arg_list = gdb.string_to_argv(arg)
# get epc first & end page
epcBase = gdb.parse_and_eval("EPC_BaseAddr")
epcEnd = gdb.parse_and_eval("EPC_EndAddr")
if (epcBase == 0 and epcEnd == 0):
print "EPC is not allocated yet"
return
epcBase += 1
# print epc info
if (len(arg_list) == 1):
self._print_epc(epcBase, arg_list[0])
else:
self._print_epc_list(epcBase, epcEnd)
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
try:
variable = gdb.parse_and_eval(argv[0])
except gdb.error as e:
print(e)
return
point = variable
if len(argv) > 3:
raise gdb.GdbError('Usage: pnext [head] [next] [length]')
next_p = 'next'
if len(argv) > 1:
next_p = argv[1]
try:
check = point[next_p].dereference()
except gdb.error as e:
print("Oops! ", e)
return
count = 50
if len(argv) > 2:
try:
count = int(argv[2])
except ValueError:
print("Oops! That was no valid number", argv[2])
return
while point:
if count == 0:
break
print(point.dereference())
point = point[next_p]
count -= 1
def invoke(arg, from_tty):
"""
arg is:
<start_bbcount> <end_bbcount> <bbcount_interval>
E.g. 0 1000 1
means sample every basic block from 1 to 1000.
"""
with udb.time.auto_reverting():
functions = defaultdict(lambda: 0)
args = gdb.string_to_argv(arg)
start_bbcount = int(args[0])
end_bbcount = int(args[1])
interval = int(args[2])
with debugger_utils.temporary_parameter("print address", False):
for current_bbcount in range(start_bbcount, end_bbcount + 1,
interval):
udb.time.goto(current_bbcount)
frame = gdb.newest_frame()
# Create list of functions in the backtrace
trace_functions = []
while frame is not None:
if frame.name() is not None:
trace_functions.append(frame.name())
else:
# If no symbol for function use pc
trace_functions.append(str(frame.pc()))
frame = frame.older()
# Concatenate functions in backtrace to create key
key = "->".join(reversed(trace_functions))
functions[key] += 1
# Now print what we've found...
for function in functions:
print("{} {}".format(function, str(functions[function])))
def invoke(self, arg, from_tty):
ports = False
arg_list = gdb.string_to_argv(arg)
if len(arg_list) > 1 or \
(len(arg_list) == 1 and arg_list[0] != "ports"):
print("usage: ovs_dump_dp_netdev [ports]")
return
elif len(arg_list) == 1:
ports = True
dp_netdevs = get_global_variable('dp_netdevs')
if dp_netdevs is None:
return
for dp in ForEachSHASH(dp_netdevs, typeobj=('struct dp_netdev')):
print("(struct dp_netdev *) {}: name = {}, class = "
"(struct dpif_class *) {}".format(dp, dp['name'].string(),
dp['class']))
if ports:
for node in ForEachHMAP(dp['ports'], "struct dp_netdev_port",
"node"):
CmdDumpDpNetdevPorts.display_single_port(node, 4)
def invokeHelper(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 0:
print("Malformed arguments; see help")
return
grArgs = gdb.parse_and_eval("grArgs")
numSlots = int(grArgs['numSlots'])
maxAllocFrames = int(grArgs['maxTrackFrames'])
maxFreeFrames = int(grArgs['maxTrackFreeFrames'])
memSlots = gdb.parse_and_eval("memSlots")
print("===== START TRACES =====")
for slotNum in range(0, numSlots):
memBins = memSlots[slotNum]['memBins']
numBins = int(gdb.parse_and_eval('sizeof(((MemSlot *)0x0)->memBins)/sizeof(((MemSlot *)0x0)->memBins)[0]'))
for binNum in range(0, numBins):
memBin = memBins[binNum]
hdr = memBin['headInUse']
while hdr != 0x0:
csvTrace = self.getTraceCsv(hdr['allocBt'], 0, maxAllocFrames)
elmSize = hdr['usrDataSize']
print(str(elmSize) + "," + csvTrace)
hdr = hdr['next']
def invoke(self, arg, from_tty):
self.__repeat_count_hack(arg, from_tty)
args = gdb.string_to_argv(arg)
size = 16
if args:
size = int(args[0])
typ = gdb.lookup_type("void").pointer()
#with clippy() as clp:
fmtdbg = FmtDbg()
idx = 1 + size * self.repeat_count
for i in range(idx, idx + size):
arg_s, arg_v = fmtdbg.fmtstr_arg(i, typ, pad=3)
line = f"{GREEN}\"%{i:03}$p\"{RESET}: "
line += f"{BLUE}{arg_s}{RESET}"
if arg_v.address:
line += f" (*{hex(arg_v.address)})"
line += f": {YELLOW}{int(arg_v):#0{typ.sizeof*2+2}x}{RESET}"
if fmt_get_location_from_symbol(int(arg_v)):
symb, offset = fmt_get_location_from_symbol(int(arg_v))
line += f" {PURPLE}<&{symb}"
if offset:
line += f"+{offset}"
line += f">{RESET}"
print(line)
def complete(self, text, word):
args = gdb.string_to_argv(text)
num_args = len(args)
if text.endswith(" "):
num_args += 1
if not text:
num_args = 1
# "svd_load <tab>" or "svd_load ST<tab>"
if num_args == 1:
prefix = word.lower()
return [
vendor for vendor in self.vendors
if vendor.lower().startswith(prefix)
]
# "svd_load STMicro<tab>" or "svd_load STMicro STM32F1<tab>"
elif num_args == 2 and args[0] in self.vendors:
prefix = word.lower()
filenames = self.vendors[args[0]]
return [
fname for fname in filenames
if fname.lower().startswith(prefix)
]
return gdb.COMPLETE_NONE
def complete(self, text, word):
if not self.device:
return gdb.COMPLETE_NONE
args = gdb.string_to_argv(text)
# Skip over the /x in "svd_show/x"
if text.startswith("/"):
options = args[0][1:]
args = args[1:]
if text.startswith("/"+options):
text = text[1+len(options):]
if word.startswith(options):
word = ""
num_args = len(args)
if text.endswith(" "):
num_args += 1
if not text:
num_args = 1
if num_args == 1:
peripheral_names = [peripheral.name.upper() for peripheral in self.device.peripherals]
if word:
prefix = word.upper()
return [name for name in peripheral_names if name.startswith(prefix)]
else:
return peripheral_names
elif num_args == 2 and args[0].upper() in self.peripherals:
periph_name = args[0].upper()
periph = self.peripherals[periph_name]
register_names = [register.name for register in periph.registers]
if word:
prefix = word.upper()
return [name for name in register_names if name.upper().startswith(prefix)]
return register_names
return gdb.COMPLETE_NONE
def invoke (self, arg, from_tty):
try:
if not self.device:
raise gdb.GdbError("Use svd_load to load an SVD file first")
return
args = gdb.string_to_argv(arg)
# Extract formatting options
options = ""
if args and args[0].startswith("/"):
options = args[0]
args = args[1:]
if len(args) >= 1:
if args[0] not in self.peripherals:
raise gdb.GdbError("Invalid peripheral name")
return
peripheral = self.peripherals[args[0]]
if len(args) == 1:
print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))
if peripheral.registers:
width = max(len(reg.name) for reg in peripheral.registers)
for register in peripheral.registers:
self.dump_register(peripheral, register, width, options)
elif len(args) == 2:
for register in peripheral.registers:
if register.name == args[1]:
self.dump_register(peripheral, register, 0, options)
break
else:
raise gdb.GdbError("Invalid register name")
else:
raise gdb.GdbError("Usage: svd_show[/[x|b]fi] peripheral-name [register-name]")
except KeyboardInterrupt:
pass
class InfoEpcmCommand (gdb.Command):
"""For debugging EPCM data structue
Calling info epcm prints EPCM address and its contents.
To designate start and end index, type "info epcm start end".
e.g.) info epcm 0 3 will print epcm[0]~ epcm[3]. """
def __init__ (self):
super (InfoEpcmCommand, self).__init__ ("info epcm",
gdb.COMMAND_STATUS,
gdb.COMPLETE_NONE)
def invoke (self, arg, from_tty):
# EPCM symbol check
try:
epcmType = gdb.lookup_type('epcm_entry_t')
except RuntimeError, e:
print "type epcm_entry_t nof found"
return
# get args
arg_list = gdb.string_to_argv(arg)
if len(arg_list) < 2:
start = 0
end = numEpcm
else:
start = int(arg_list[0], 10)
end = int(arg_list[1], 10)
if end > numEpcm:
end = numEpcm
if start < 0:
start = 0
# get epcm object
epcmObj = gdb.parse_and_eval("epcm")
# print epcm info
self._print_epcm(epcmObj, start, end)
def invoke(self, args, from_tty):
argv = gdb.string_to_argv(args)
if len(argv) == 0:
raise gdb.GdbError('输入参数数目不对，help print-array 以获得用法')
self.type_lookup()
m = re.match('0[xX][0-9a-fA-F]+', argv[0])
if m:
a = gdb.Value(int(argv[0], 16)).cast(self.array_pointer_type)
else:
a = gdb.parse_and_eval(argv[0])
if not a:
print("ngx_array_t point empty")
return
print("ngx_array_t alloc size: %d" % int(a['nalloc']))
print("ngx_array_t used size: %d" % int(a['nelts']))
print("ngx_array_t elts size: %d" % int(a['size']))
print("ngx_array_t every elts:")
if len(argv) == 1:
print("ngx_array_t just first elts pointer: %s" % str(a['elts']))
elif len(argv) == 2:
# elt_type = gdb.lookup_type(argv[1])
# e = gdb.Value(int(a['elts'], 16)).cast(elt_type)
e = a['elts'].cast(gdb.lookup_type('u_char').point())
elt_type = argv[1]
elt_size = int(a['size'])
for i in xrange(a['nelts']):
comm = 'p ' + argv[0] + '(' + str(e + i * elt_size) + ')'
print(comm)
gdb.execute(comm)
def invoke(self, arg, from_tty):
""" Parsing arguments, invoking printing.
You can print all theeads of current task (no argument to command),
All threads of current task xnu-threads current
All user threads - xnu-threads user
All threads whithin the system - xnu-threads
All threads of specific task - xnu-threads ${task_ptr}
"""
if sys_info.is_in_kernel_space() is False:
gdb.write("\nYou are currently in user space, "
"this functionality is not available here.\n\n")
return
try:
argv = gdb.string_to_argv(arg)
if len(argv) == 0:
self.print_all_threads(is_global=True)
elif len(argv) == 1:
if argv[0] == "user":
self.print_all_threads(user_only=True, is_global=True)
elif argv[0] == "current":
task = sys_info.get_current_task_ptr()
self.print_all_threads(task=task)
else:
try:
requested_task = int(argv[0], 0)
if sys_info.is_valid_ptr(requested_task):
if not types.is_task_exist(requested_task):
gdb.write(f"\nRequested task {argv[0]} do not exist"
f" in the tasks list of the system!\n\n\n")
self.print_all_threads(task=requested_task)
except Exception:
gdb.write("\nUsage: xnu-threads ${TASK_PTR}\n")
else:
gdb.write("\nUsage: xnu-threads ${TASK_PTR}\n")
except Exception:
raise gdb.GdbError(traceback.format_exc())
def invoke(self, arg, from_tty):
if self.init == False:
self.lazy_init()
argv = gdb.string_to_argv(arg)
args = None
try:
args = self.parser.parse_args(argv)
except:
return None
saved_stdout = None
if args.o:
saved_stdout = sys.stdout
sys.stdout = open(args.o[0], "w+")
try:
self.handle_command(args)
except Exception as e:
print(f"Exception: {str(e)}")
finally:
if saved_stdout:
sys.stdout.close()
sys.stdout = saved_stdout
def invoke(self, args, from_tty):
print(repr(args))
arg_list = gdb.string_to_argv(args)
chars_only = True
if len(arg_list) == 2:
addr_arg = arg_list[0]
chars_only = True if args[1] == '-c' else False
else:
addr_arg = args
if addr_arg.startswith('0x'):
addr = int(addr_arg, 16)
else:
addr = int(addr_arg)
# assume that paging will cut in and the user will quit at some point:
size = 32
while True:
hd = hexdump_as_bytes(addr, size, chars_only=chars_only)
print('%s -> %s %s' %
(fmt_addr(addr), fmt_addr(addr + size - 1), hd))
addr += size
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
frame = "$rbp"
if len(args) > 0:
frame = args[0]
depth = 30
if len(args) > 1:
depth = int(args[1])
for i in range(depth-1, -1, -1):
ret = gdb.parse_and_eval(f"*(uint64_t*)({frame} + 8)")
frame = gdb.parse_and_eval(f"*(uint64_t*)({frame})")
name = ""
block = gdb.block_for_pc(int(ret))
if block:
name = block.function or ""
print("{:016x} {}".format(int(ret), name))
if frame == 0 or ret == 0:
return
def invoke(self, args, from_tty):
self.dont_repeat()
argv = gdb.string_to_argv(args)
argc = len(argv)
if not (0 <= argc <= 2):
message.error("Invalid number of arguments")
return None
if argc == 0:
print(message.titlify("PWNGEF configuration settings"))
self.print_settings()
return None
if argc == 1:
prefix = argv[0]
names = list(
filter(lambda x: x.startswith(prefix),
pwngef.config.__config__.keys()))
if names:
if len(names) == 1:
print(
message.titlify(
"PWNGEF configuration setting: {:s}".format(
names[0])))
self.print_setting(names[0], verbose=True)
else:
print(
message.titlify(
"PWNGEF configuration settings matching '{:s}'".
format(argv[0])))
for name in names:
self.print_setting(name)
return None
self.set_setting(argc, argv)
return None
def invoke(self, argv_str, _from_tty):
args = gdb.string_to_argv(argv_str)
if len(args) not in (1, 2):
print('usage: print-avs-list expr [limit=10]\n'
' expr - an expression that avaluates to a valid AVS_LIST element pointer\n'
' limit - number of elements to display; a value <= 0 means no limit')
return
expr = args[0]
limit = int(args[1]) if len(args) > 1 else 0
if limit <= 0:
limit = None
val = gdb.parse_and_eval(expr)
if val is None:
print('cannot evaluate expression: ' + expr)
return
if val == 0:
print('(empty list)')
else:
self._print_list(val, limit)
def invoke(self, args, from_tty):
argv = [gdb.parse_and_eval(arg) for arg in gdb.string_to_argv(args)]
if len(argv) == 0:
if not self.bcpos:
print 'hhx: No bytecode specified.'
return
elif len(argv) == 1:
if argv[0] > 0xffffffff:
self.bcpos = argv[0]
self.bcoff = 0
self.count = 1
else:
self.count = int(argv[0])
else:
self.bcpos = argv[0]
self.bcoff = 0
self.count = int(argv[1])
bctype = gdb.lookup_type('HPHP::Op').const().pointer()
self.bcpos = self.bcpos.cast(bctype)
op_names = gdb.parse_and_eval(
"(char **)*(uint32_t*)('HPHP::opcodeToName(HPHP::Op)' + 10)")
for i in xrange(0, self.count):
instr = HHBC.instr_info(self.bcpos)
idx = as_idx(self.bcpos.dereference())
out = "[%d] %s" % (self.bcoff, op_names[idx].string())
for imm in instr['imms']:
out += ' <' + str(imm) + '>'
print out
self.bcpos += instr['len']
self.bcoff += instr['len']
def invoke(self, argument, from_tty):
self.dont_repeat()
period = 0.1
args = gdb.string_to_argv(argument)
if len(args) > 0:
try:
period = int(args[0])
except ValueError:
print("Invalid number \"%s\"." % args[0])
return
def breaking_continue_handler(event):
sleep(period)
os.kill(gdb.selected_inferior().pid, signal.SIGINT)
# call_chain_frequencies = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
top = Function("Top", 2)
sleeps = 0
threads = {}
for i in range(0, 200):
gdb.events.cont.connect(breaking_continue_handler)
gdb.execute("continue", to_string=True)
gdb.events.cont.disconnect(breaking_continue_handler)
for inf in gdb.inferiors():
inum = inf.num
for th in inf.threads():
thn = th.num
th.switch()
# call_chain_frequencies[inum][thn][get_call_chain()] += 1
frame = gdb.newest_frame()
while (frame.older() != None):
frame = frame.older()
# top.inverse_add_frame(frame);
# top.add_frame(gdb.newest_frame())
if thn not in threads:
threads[thn] = Function(str(thn), 2)
threads[thn].inverse_add_frame(frame)
sleeps += 1
gdb.write(".")
gdb.flush(gdb.STDOUT)
print("")
for thn, function in sorted(threads.items()):
print("")
print("Thread: %s" % thn)
print("")
function.print_percent("", function.get_samples())
# top.print_percent("", top.get_samples())
# print("\nProfiling complete with %d samples." % sleeps)
# for inum, i_chain_frequencies in sorted(call_chain_frequencies.iteritems()):
# print ""
# print "INFERIOR NUM: %s" % inum
# print ""
# for thn, t_chain_frequencies in sorted (i_chain_frequencies.iteritems()):
# print ""
# print "THREAD NUM: %s" % thn
# print ""
#
# for call_chain, frequency in sorted(t_chain_frequencies.iteritems(), key=lambda x: x[1], reverse=True):
# print("%d\t%s" % (frequency, '->'.join(str(i) for i in call_chain)))
#
# for call_chain, frequency in sorted(call_chain_frequencies.iteritems(), key=lambda x: x[1], reverse=True):
# print("%d\t%s" % (frequency, '->'.join(str(i) for i in call_chain)))
pid = gdb.selected_inferior().pid
os.kill(pid,
signal.SIGSTOP) # Make sure the process does nothing until
# it's reattached.
gdb.execute("detach", to_string=True)
gdb.execute("attach %d" % pid, to_string=True)
os.kill(pid, signal.SIGCONT)
gdb.execute("continue", to_string=True)
def invoke(self, argstr, from_tty):
'''
Called when this Command is invoked from GDB. Prints classification of
Inferior to GDB's STDOUT.
Note that sys.stdout is automatically redirected to GDB's STDOUT.
See GDB Python API documentation for details
'''
# Note that OptionParser is configured to work without
# sys.argv and to minimize the cases where OptionParser
# calls sys.exit(), which kills the parent GDB process
op = OptionParser(prog=self._cmdstr,
add_help_option=False,
description="type 'help exploitable' for "
"description. WARNING: typing an invalid "
"option string may cause GDB to exit.")
op.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="print analysis info from the Inferior")
op.add_option("-p",
"--pkl-file",
dest="pkl_file",
help="pickle exploitability classification object and "
"store to PKL_FILE")
op.add_option("-h",
"--help",
action="store_true",
dest="help",
default=False,
help="Print this message")
(opts, args) = op.parse_args(gdb.string_to_argv(argstr))
if opts.help:
# Print help manually b/c Default OptionParser help calls sys.exit
op.print_help()
return
self._options = opts
try:
target = gdb_wrapper.getTarget()
except gdb_wrapper.GdbWrapperError as e:
raise gdb.GdbError(e)
c = classifier.getClassification(target)
if self._options.pkl_file:
path = os.path.expanduser(self._options.pkl_file)
pickle.dump(c, file(path, "wb"))
return
if self._options.verbose:
print "'exploitable' version %s" % versions.exploitable_version
print " ".join([str(i) for i in os.uname()])
print "Signal si_signo: %s Signal si_addr: %s" % \
(target.si_signo(), target.si_addr())
print "Nearby code:"
self.print_disassembly()
print "Stack trace:"
print target.backtrace()
print "Faulting frame: %s" % target.faulting_frame()
print c