def createWatch(inf):
debugMsg('hit createWatch with inf ' + str(inf))
wdata = ''
addr = ''
leng = ''
lab = ''
filename = 'inf' + str(inf) + '.watch'
f = None
try:
f = open(filename, 'r')
try:
wdata = f.read()
finally:
f.close()
except IOError:
raise gdb.error('*****Error opening file: ' + filename)
match = re.match(r"[*]+checkAddr:(\w+)\n[*]+checkLen:(\w+)\n" +
"[*]+checkLab:(\w+)\n",
wdata)
if match is not None:
addr = match.group(1).strip()
leng = match.group(2).strip()
lab = match.group(3).strip()
else:
raise gdb.error('*****Error matching re in watch file: ' + filename)
watches.append(qdWatchpoint(addr, lab, leng, inf))
def __call__(self, obj, row_idx, col_idx):
n_rows = obj["n_rows"]
n_cols = obj["n_cols"]
if row_idx < 0 or row_idx >= n_rows:
raise gdb.error(
"Row index out of bounds -> It must be between 0 and {}".
format(n_rows - 1))
if col_idx < 0 or col_idx >= n_cols:
raise gdb.error(
"Column index out of bounds -> It must be between 0 and {}".
format(n_cols - 1))
return obj["mem"][col_idx * n_rows + row_idx]
def invoke(self, obj: gdb.Value, type: gdb.Value) -> gdb.Value:
try:
type_string = type.string()
except gdb.error:
raise gdb.error('the second argument must be literal string')
try:
dispatch = self._dispatch[parse_type(obj)]
except KeyError:
raise gdb.error(
'the first argument must be of supported types: interface, literal address, void*'
)
return dispatch(obj, type_string)
def hex_dump(address_str, size=16):
'''Output memory region in hex.'''
if size <= 0:
raise gdb.error('Size must be positive')
address = gdb_eval(address_str, uint_t)
start_address = address & ~0xf
end_address = (address + size + 0xf) & ~0xf
chars = ''
for cur_address in range(start_address, end_address):
if cur_address & 0xf == 0:
gdb.write('0x%08x: ' % cur_address)
elif cur_address & 0xf == 0x4 or cur_address & 0xf == 0xc:
gdb.write(' ')
elif cur_address & 0xf == 0x8:
gdb.write('- ')
if cur_address < int(address) or cur_address >= int(address + size):
gdb.write('** ')
chars += ' '
else:
byte = int(gdb.Value(cur_address).cast(byteptr_t).dereference())
gdb.write('%02x ' % byte)
if byte >= 32 and byte < 128:
chars += chr(byte)
else:
chars += '.'
if cur_address & 0xf == 0xf:
gdb.write(' | %s\n' % chars)
chars = ''
def tagged_field(tagged_value, field_name, reinterpret=True):
"""
Look for a field in a tagged record's own and all its inherited fields.
This is useful because we see tagged records in GDB as a record that
contains another record (for fields from the parent type) that contains
another record, etc.
:param gdb.Value tagged_value: Can be either a tagged record or an access
to a tagged record.
:param str field_name: Name of the field to look up.
:param bool reinterpret: If True, re-interpret `tagged_value` according to
its dynamic type.
:rtype: gdb.Value
"""
tagged_value = (reinterpret_tagged(tagged_value)
if reinterpret else auto_deref_tagged(tagged_value))
if tagged_value.type.code != gdb.TYPE_CODE_STRUCT:
raise TypeError('Input type is not tagged')
while True:
try:
return tagged_value[field_name]
except gdb.error:
pass
try:
tagged_value = tagged_value['_parent']
except gdb.error:
raise gdb.error('There is no member {}'.format(field_name))
def __init__(self, hp):
super().__init__()
ahp = hp.split(":")
host = "0.0.0.0"
lport = 0
if (len(ahp) == 1):
lport = int(ahp[0])
elif (len(ahp) == 2):
host = ahp[0]
lport = int(ahp[1])
else:
raise gdb.error("Invalid host:lport/lport argument %s" % hp)
# open a listen lport, find a way to accept it asynchronously (threading??) and output to all of them
# host None means 0.0.0.0
# print("host = '%s'" % host )
# print("lport = '%s'" % lport )
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((host, lport))
sock.listen(1)
self.sock = sock
self.host = host
self.port = lport
self.enabled = False
self.targets = []
self.start()
def _vector_item(self, vector, index):
last = int(vector['size'])
if index < 1 or last < index:
raise gdb.error('Out of bounds index')
array = vector['e'].dereference()
return array[index]
def csum( argv ):
key = argv[0]
cs = argv[1]
if( key.find(":") == -1 ):
raise gdb.error("ssh csum <key> <csum> : the key parameter must have the form host:file but we found no ':'")
global csum_cache
csum_cache[key] = (cs,None)
def __call__(self, obj, row_idx, col_idx, slice_idx):
n_rows = obj["n_rows"]
n_cols = obj["n_cols"]
n_slices = obj["n_slices"]
num_elem_per_slice = n_rows * n_cols
if row_idx < 0 or row_idx >= n_rows:
raise gdb.error(
"Row index out of bounds -> It must be between 0 and {}".
format(n_rows - 1))
if col_idx < 0 or col_idx >= n_cols:
raise gdb.error(
"Column index out of bounds -> It must be between 0 and {}".
format(n_cols - 1))
if slice_idx < 0 or slice_idx >= n_slices:
raise gdb.error(
"Slice index out of bounds -> It must be between 0 and {}".
format(n_slices - 1))
return obj["mem"][slice_idx * num_elem_per_slice + col_idx * n_rows +
row_idx]
def __init__(self, tty_name):
super().__init__()
self.tty = tty_name
f = self.try_open(tty_name)
if (f is None):
f = self.try_open("/dev/" + tty_name)
if (f is None):
raise gdb.error(f"Could not open {tty_name} ({fn})")
self.file = f
def call_dashboard(argv):
# type: tmux,port,tty
# subcommands: list,enable,disable,erase
if (len(argv) == 0):
raise gdb.error(cmd_dashboard.__doc__)
# print("argv = '%s'" % argv )
if ("tty".startswith(argv[0])):
if (len(argv) < 3):
raise gdb.error("dashboard tty, need at least 2 parameters")
tgt = tty(argv[1])
add_board(tgt, argv[2:])
elif ("null".startswith(argv[0])):
tgt = null()
add_board(tgt, argv[1:])
elif ("tmux".startswith(argv[0])):
if (len(argv) < 3):
raise gdb.error("dashboard tmux, need at least 2 parameters")
tgt = tmux(argv[1])
add_board(tgt, argv[2:])
elif ("port".startswith(argv[0])):
if (len(argv) < 3):
raise gdb.error("dashboard port, need at least 2 parameters")
tgt = port(argv[1])
add_board(tgt, argv[2:])
elif ("delete".startswith(argv[0])):
del_board(argv[1])
elif ("show".startswith(argv[0])):
show_dashboard()
elif ("enable".startswith(argv[0])):
trigger_dashboard(argv[1], True)
elif ("disable".startswith(argv[0])):
trigger_dashboard(argv[1], False)
elif ("modify".startswith(argv[0])):
modify_board(argv[1:])
elif ("cls".startswith(argv[0])):
trigger_cls(argv[1], True)
elif ("nocls".startswith(argv[0])):
trigger_cls(argv[1], False)
else:
print("%s? What do you mean?" % argv[0])
def invoke(self, thread, argument, from_tty=False):
sections = gdb.execute('info target', to_string=True)
address = None
for match in self._text_exp.finditer(sections):
if match.group('section') == '.text':
address = abs(long(match.group('start'), 16))
break
if address is not None:
gdb.Breakpoint('*0x%x' % address)
else:
raise gdb.error('Unable to locate .text section!')
def invoke(self, thread, argument, from_tty=False):
sections = gdb.execute('info target', to_string=True)
address = None
for match in self._text_exp.finditer(sections):
if match.group('section') == '.text':
address = abs(long(match.group('start'), 16))
break
if address is not None:
gdb.Breakpoint('*0x%x' % address)
else:
raise gdb.error('Unable to locate .text section!')
def token(self, token_no):
"""
Retreive the token number "token_no" in this TDH.
:rtype: Token
"""
last_token = int(self.value['tokens']['size'])
if token_no < 1 or last_token < token_no:
raise gdb.error('Out of bounds token number')
tokens_array = self.value['tokens']['e'].dereference()
return Token(self, tokens_array[token_no])
def _update(self):
val = self.val
arr_type = str(val.type.unqualified().strip_typedefs())
if re.search('(?:\[\])+', arr_type):
raise gdb.error("Missing array dimensions. "
"All array dimensions must be "
"declared as const. ")
match = self.pattern.search(arr_type)
bounds = match.group()[1:-1]
bounds = bounds.split('][')
bounds = bounds[0]
self.bounds = [int(bounds)]
self.val = self.deref(val, [0])
def _update(self):
val = self.val
arr_type = str(val.type.unqualified().strip_typedefs())
if re.search('(?:\[\])+',arr_type):
raise gdb.error("Missing array dimensions. "
"All array dimensions must be "
"declared as const. ")
match = self.pattern.search(arr_type)
bounds = match.group()[1:-1]
bounds = bounds.split('][')
bounds = bounds[0]
self.bounds = [int(bounds)]
self.val = self.deref(val,[0])
def __call__(self, obj, slice_idx):
n_rows = obj["n_rows"]
n_cols = obj["n_cols"]
n_slices = obj["n_slices"]
num_elem_per_slice = n_rows * n_cols
if slice_idx < 0 or slice_idx >= n_slices:
raise gdb.error(
"Slice index out of bounds -> It must be between 0 and {}".
format(n_slices - 1))
slice_type = self.get_slice_type(obj)
return (obj["mem"][slice_idx * num_elem_per_slice]).cast(slice_type)
def invoke(self, arg, from_tty):
if not gdb_running_under_rr():
raise gdb.error('reverse-callback requires debugging under rr: ' +
'https://rr-project.org/')
# Find the stack frame which extracts the bind state from the task.
bind_state_frame = find_nearest_frame_matching(
gdb.selected_frame(), lambda frame: frame.function() and re.match(
'^base::internal::Invoker<base::internal::BindState<.*>' +
'::RunOnce\(base::internal::BindStateBase\*\)$',
frame.function().name))
if bind_state_frame is None:
raise Exception(
'base::internal::Invoker frame not found; are you in a callback?'
)
bind_state_frame.select()
# Disable all existing breakpoints.
was_enabled = []
for breakpoint in gdb.breakpoints():
was_enabled.append(breakpoint.enabled)
breakpoint.enabled = False
# Break on the initialization of the BindState.
storage_address = gdb.parse_and_eval('storage')
watchpoint = gdb.Breakpoint('*' + str(storage_address),
gdb.BP_WATCHPOINT)
# Find the construction.
gdb.execute('reverse-continue')
# Restore breakpoints
watchpoint.delete()
for breakpoint, enabled in zip(gdb.breakpoints(), was_enabled):
breakpoint.enabled = enabled
# Find the stack frame which created the BindState.
def in_bindstate(frame):
return frame.function() and frame.function().name.startswith(
'base::internal::BindState<')
creation_frame = find_nearest_frame_matching(
find_nearest_frame_matching(gdb.selected_frame(), in_bindstate),
lambda frame: not in_bindstate(frame))
# The callback creates the bindstate, step up once more to get the creator
# of the callback.
creation_frame.older().select()
def tagged_field(record_value, field_name):
"""
Helper to look for a field in a tagged record.
This is useful because we see tagged records in GDB as a record that
contains another record (for fields from the parent type) that contains
another record, etc.
"""
while True:
try:
return record_value[field_name]
except gdb.error:
pass
try:
record_value = record_value['_parent']
except gdb.error:
raise gdb.error('There is no member {}'.format(field_name))
def gdbserver( s, argv ):
print("Searching for port to tunnel over ssh … ",end="")
s.call("netstat -naput | egrep \"VERBUNDEN|LISTEN|TIME_WAIT\" | awk '{ print $4}'")
s.fill(0.5)
ports = s.read()
ports = ports.splitlines()
lports = subprocess.check_output(["sh","-c","netstat -npatu | egrep \"VERBUNDEN|LISTEN|TIME_WAIT\" | awk '{print $4}'"])
lports = lports.decode("utf-8")
lports = lports.splitlines()
ports += lports
# candports = set(range(6000,6020))
candports = set(valid_ports.elements)
# print("ports = '%s'" % ports )
for port in ports:
try:
p = int(port.split(":")[-1])
# print("p = '%s'" % p )
candports.remove(p)
except:
pass
# print("candports = '%s'" % candports )
if( len(candports) == 0 ):
raise gdb.error("No suitable port found among the candidates of %s" % valid_ports.elements )
gport = candports.pop()
print(f"using port {gport}")
gs = ssh_connection(s.host,[ "-L" f"{gport}:localhost:{gport}" ] )
argv = [ f"localhost:{gport}" ] + argv
# print("gdbserver " + " ".join(argv))
gs.call(f"{gdbserver_cmd.value} " + " ".join(argv) )
gs.fill(0.5)
r=gs.read()
print("r = '%s'" % r )
# print(f"target remote localhost:{gport}")
# time.sleep(2)
print("Setting target remote…")
gdb.execute(f"target remote localhost:{gport}")
# gdb.execute(f"target extended-remote localhost:{gport}")
print("Attached to remote process. Use 'detach' to end debugging.")
return gs
def _get_current_language():
'''
We have some C files we want to compile. However, this doesn't
work if we're getting checkpoints for a fortran benchmark. So, we
need to retrieve the original language so we can change it to C
temporarily for our purposes. We promise we'll set it back as soon
as we're done.
'''
import gdb
lang_raw = gdb.execute('show language', to_string=True)
lang = lang_raw.split()[-1].split('"')[0]
if not lang:
lang = lang_raw.split('"')[1]
if not lang:
raise gdb.error('"show language" command returned nothing! Raw: ',
gdb.execute('show language', to_string=True))
return lang
def __call__(self, obj):
"""Invoke the xmethod
Args:
args: Arguments to the method. Each element of the tuple is a
gdb.Value object. The first element is the 'this' pointer
value.
Returns:
A gdb.Value corresponding to the value returned by the xmethod.
Returns 'None' if the method does not return anything.
"""
num_elem = obj['n_elem']
mem = obj["mem"]
try:
max_value = max((mem + i).dereference() for i in range(num_elem))
except gdb.error:
raise gdb.error(
"Error in gdb xmethod implementation for 'max' method")
return max_value
def __init__(self, pane_name):
p = subprocess.run(
["tmux", "list-panes", "-a", "-F", "#{pane_title}{|}#{pane_tty}"],
encoding="utf-8",
stdout=subprocess.PIPE)
# print("p = '%s'" % p )
output = p.stdout.splitlines()
tty = None
self.pane = pane_name
for line in output:
line = line.split("{|}")
# print("line = '%s'" % line )
# or regex?
# if( line[0] == pane_name ):
if (re.match(pane_name, line[0])):
tty = line[1]
break
if (tty is None):
raise gdb.error("Could not find tmux pane named %s" % pane_name)
# print("tty = '%s'" % tty )
super().__init__(tty)
def __call__(self, obj, index):
if index < 0 or index >= obj["n_elem"]:
raise gdb.error(
"Cannot get element with index {} from {} with {} elements".
format(index, obj.type.target(), obj['n_elem']))
return obj["mem"][index]
def getmod():
#following code is get from ../getmod.py
#use the code directly because sys.argv = [''] inside GDB
def format_file(name):
tmp = ""
for c in name:
if c == "_":
c = "-"
tmp += c
return tmp
#Check if the target is available
if str(gdb.selected_thread()) == "None":
raise gdb.error(
"Please connect to Linux Kernel before use the script.")
#Output the help
print "Use GDB command \"set $mod_search_dir=dir\" to set an directory for search the modules."
ignore_gtp_ko = gdb.parse_and_eval("$ignore_gtp_ko")
if ignore_gtp_ko.type.code == gdb.TYPE_CODE_INT:
ignore_gtp_ko = int(ignore_gtp_ko)
else:
ignore_gtp_ko = 1
#Get the mod_search_dir
mod_search_dir_list = []
#Get dir from $mod_search_dir
tmp_dir = gdb.parse_and_eval("$mod_search_dir")
if tmp_dir.type.code == gdb.TYPE_CODE_ARRAY:
tmp_dir = str(tmp_dir)
tmp_dir = tmp_dir[1:len(tmp_dir)]
tmp_dir = tmp_dir[0:tmp_dir.index("\"")]
mod_search_dir_list.append(tmp_dir)
#Get dir that same with current vmlinux
tmp_dir = str(gdb.execute("info files", False, True))
tmp_dir = tmp_dir[tmp_dir.index("Symbols from \"") +
len("Symbols from \""):len(tmp_dir)]
tmp_dir = tmp_dir[0:tmp_dir.index("\"")]
tmp_dir = tmp_dir[0:tmp_dir.rindex("/")]
mod_search_dir_list.append(tmp_dir)
#Get the dir of current Kernel
tmp_dir = "/lib/modules/" + str(os.uname()[2])
if os.path.isdir(tmp_dir):
mod_search_dir_list.append(tmp_dir)
#Let user choice dir
mod_search_dir = ""
while mod_search_dir == "":
for i in range(0, len(mod_search_dir_list)):
print str(i) + ". " + mod_search_dir_list[i]
try:
s = input('Select a directory for search the modules [0]:')
except SyntaxError:
s = 0
except:
continue
if s < 0 or s >= len(mod_search_dir_list):
continue
mod_search_dir = mod_search_dir_list[s]
mod_list_offset = long(
gdb.parse_and_eval("((size_t) &(((struct module *)0)->list))"))
mod_list = long(gdb.parse_and_eval("(&modules)"))
mod_list_current = mod_list
while 1:
mod_list_current = long(
gdb.parse_and_eval("((struct list_head *) " +
str(mod_list_current) + ")->next"))
#check if need break the loop
if mod_list == mod_list_current:
break
mod = mod_list_current - mod_list_offset
#get mod_name
mod_name = str(
gdb.parse_and_eval("((struct module *)" + str(mod) + ")->name"))
mod_name = mod_name[mod_name.index("\"") + 1:len(mod_name)]
mod_name = mod_name[0:mod_name.index("\"")]
if mod_name == "fglrx":
contiue
mod_name += ".ko"
mod_name = format_file(mod_name)
#get mod_dir_name
mod_dir_name = ""
for root, dirs, files in os.walk(mod_search_dir):
for afile in files:
tmp_file = format_file(afile)
if tmp_file == mod_name:
mod_dir_name = os.path.join(root, afile)
break
if mod_dir_name != "":
break
command = " "
#Add module_core to command
command += str(
gdb.parse_and_eval("((struct module *)" + str(mod) +
")->module_core"))
#Add each sect_attrs->attrs to command
#get nsections
nsections = int(
gdb.parse_and_eval("((struct module *)" + str(mod) +
")->sect_attrs->nsections"))
sect_attrs = long(
gdb.parse_and_eval("(u64)((struct module *)" + str(mod) +
")->sect_attrs"))
for i in range(0, nsections):
command += " -s"
tmp = str(
gdb.parse_and_eval("((struct module_sect_attrs *)" +
str(sect_attrs) + ")->attrs[" + str(i) +
"].name"))
tmp = tmp[tmp.index("\"") + 1:len(tmp)]
tmp = tmp[0:tmp.index("\"")]
command += " " + tmp
tmp = str(
gdb.parse_and_eval("((struct module_sect_attrs *)" +
str(sect_attrs) + ")->attrs[" + str(i) +
"].address"))
command += " " + tmp
if mod_dir_name == "":
print "Cannot find out", mod_name, "from directory."
print "Please use following command load the symbols from it:"
print "add-symbol-file some_dir/" + mod_name + command
else:
if ignore_gtp_ko and mod_name == "gtp.ko":
pass
else:
#print "add-symbol-file "+mod_dir_name+command
gdb.execute("add-symbol-file " + mod_dir_name + command, False,
False)
print("Drop one entry because:")
for file, lineno, function, text in traceback.extract_tb(
sys.exc_info()[2]):
print file, lineno, function, text
try:
gdb.execute("tfind 1", False, True)
except:
pass
else:
while 1:
try:
gdb.execute("tfind 0", False, True)
is_user = False
pid = long(gdb.parse_and_eval("$current_task_pid"))
if not pid in task_list:
raise gdb.error("Cannot find inferior for pid " + str(pid) +
", drop one entry.")
if trace_user and (not trace_kernel or long(
gdb.parse_and_eval("regs->cs & 3")) == 3):
is_user = True
ip = long(gdb.parse_and_eval("regs->ip - 1"))
gdb.execute("inferior " + str(task_list[pid].fid), False, True)
sym = gdb.execute("info line *" + str(ip), True, True)
else:
sym = gdb.execute("info line *(regs->ip - 1)", True, True)
line = get_line_from_sym(sym)
if is_user:
gdb.execute("inferior 1", False, True)
task_list_add_line(is_user, pid, line)
except gdb.error, x:
print("Drop one entry because:")
for file, lineno, function, text in traceback.extract_tb(
#Make sure this is connect gdbframe or not, if not, gtpframe_pipe = 1
gtpframe_pipe = 0;
if str(gdb.selected_thread()) == "None":
gtpframe_pipe = 1
gdb.execute("target tfile /sys/kernel/debug/gtpframe_pipe");
signal.setitimer(signal.ITIMER_REAL, 1, 1);
keep_running = 1;
while keep_running:
try:
tfind_done = 0;
if gtpframe_pipe:
tid = tfind_entry(0);
if tid < 0:
raise gdb.error("tfind");
else:
tid = tfind_entry(-1);
if tid < 0:
break;
tfind_done = 1;
cpu_id = str(gdb.parse_and_eval("$cpu_id"));
clock += long(gdb.parse_and_eval("$pc_pe_val_00_"+cpu_id));
time += 1;
except gdb.error, x:
#print("Drop one entry because", x);
pass;
except gdb.MemoryError, x:
print("Drop one entry because", x);
def __call__(self, obj, index):
if index < 0 or index >= obj["n_elem"]:
raise gdb.error(
f"Cannot get element with index {index} from {obj.type.target()} with {obj['n_elem']} elements"
)
return obj["mem"][index]
def getmod():
#following code is get from ../getmod.py
#use the code directly because sys.argv = [''] inside GDB
def format_file(name):
tmp = ""
for c in name:
if c == "_":
c = "-"
tmp += c
return tmp
#Check if the target is available
if str(gdb.selected_thread()) == "None":
raise gdb.error("Please connect to Linux Kernel before use the script.")
#Output the help
print "Use GDB command \"set $mod_search_dir=dir\" to set an directory for search the modules."
ignore_gtp_ko = gdb.parse_and_eval("$ignore_gtp_ko")
if ignore_gtp_ko.type.code == gdb.TYPE_CODE_INT:
ignore_gtp_ko = int(ignore_gtp_ko)
else:
ignore_gtp_ko = 1
#Get the mod_search_dir
mod_search_dir_list = []
#Get dir from $mod_search_dir
tmp_dir = gdb.parse_and_eval("$mod_search_dir")
if tmp_dir.type.code == gdb.TYPE_CODE_ARRAY:
tmp_dir = str(tmp_dir)
tmp_dir = tmp_dir[1:len(tmp_dir)]
tmp_dir = tmp_dir[0:tmp_dir.index("\"")]
mod_search_dir_list.append(tmp_dir)
#Get dir that same with current vmlinux
tmp_dir = str(gdb.execute("info files", False, True))
tmp_dir = tmp_dir[tmp_dir.index("Symbols from \"")+len("Symbols from \""):len(tmp_dir)]
tmp_dir = tmp_dir[0:tmp_dir.index("\"")]
tmp_dir = tmp_dir[0:tmp_dir.rindex("/")]
mod_search_dir_list.append(tmp_dir)
#Get the dir of current Kernel
tmp_dir = "/lib/modules/" + str(os.uname()[2])
if os.path.isdir(tmp_dir):
mod_search_dir_list.append(tmp_dir)
#Let user choice dir
mod_search_dir = ""
while mod_search_dir == "":
for i in range(0, len(mod_search_dir_list)):
print str(i)+". "+mod_search_dir_list[i]
try:
s = input('Select a directory for search the modules [0]:')
except SyntaxError:
s = 0
except:
continue
if s < 0 or s >= len(mod_search_dir_list):
continue
mod_search_dir = mod_search_dir_list[s]
mod_list_offset = long(gdb.parse_and_eval("((size_t) &(((struct module *)0)->list))"))
mod_list = long(gdb.parse_and_eval("(&modules)"))
mod_list_current = mod_list
while 1:
mod_list_current = long(gdb.parse_and_eval("((struct list_head *) "+str(mod_list_current)+")->next"))
#check if need break the loop
if mod_list == mod_list_current:
break
mod = mod_list_current - mod_list_offset
#get mod_name
mod_name = str(gdb.parse_and_eval("((struct module *)"+str(mod)+")->name"))
mod_name = mod_name[mod_name.index("\"")+1:len(mod_name)]
mod_name = mod_name[0:mod_name.index("\"")]
if mod_name == "fglrx":
contiue
mod_name += ".ko"
mod_name = format_file(mod_name)
#get mod_dir_name
mod_dir_name = ""
for root, dirs, files in os.walk(mod_search_dir):
for afile in files:
tmp_file = format_file(afile)
if tmp_file == mod_name:
mod_dir_name = os.path.join(root,afile)
break
if mod_dir_name != "":
break
command = " "
#Add module_core to command
command += str(gdb.parse_and_eval("((struct module *)"+str(mod)+")->module_core"))
#Add each sect_attrs->attrs to command
#get nsections
nsections = int(gdb.parse_and_eval("((struct module *)"+str(mod)+")->sect_attrs->nsections"))
sect_attrs = long(gdb.parse_and_eval("(u64)((struct module *)"+str(mod)+")->sect_attrs"))
for i in range(0, nsections):
command += " -s"
tmp = str(gdb.parse_and_eval("((struct module_sect_attrs *)"+str(sect_attrs)+")->attrs["+str(i)+"].name"))
tmp = tmp[tmp.index("\"")+1:len(tmp)]
tmp = tmp[0:tmp.index("\"")]
command += " "+tmp
tmp = str(gdb.parse_and_eval("((struct module_sect_attrs *)"+str(sect_attrs)+")->attrs["+str(i)+"].address"))
command += " "+tmp
if mod_dir_name == "":
print "Cannot find out",mod_name,"from directory."
print "Please use following command load the symbols from it:"
print "add-symbol-file some_dir/"+mod_name+command
else:
if ignore_gtp_ko and mod_name == "gtp.ko":
pass
else:
#print "add-symbol-file "+mod_dir_name+command
gdb.execute("add-symbol-file "+mod_dir_name+command, False, False)
except gdb.MemoryError, x:
print("Drop one entry because:")
for file, lineno, function, text in traceback.extract_tb(sys.exc_info()[2]):
print file, lineno, function, text
try:
gdb.execute("tfind 1", False, True)
except:
pass
else:
while 1:
try:
gdb.execute("tfind 0", False, True)
is_user = False
pid = long(gdb.parse_and_eval("$current_task_pid"))
if not pid in task_list:
raise gdb.error ("Cannot find inferior for pid "+ str(pid) +", drop one entry.")
if trace_user and (not trace_kernel or long(gdb.parse_and_eval("regs->cs & 3")) == 3):
is_user = True
ip = long(gdb.parse_and_eval("regs->ip - 1"))
gdb.execute("inferior "+str(task_list[pid].fid), False, True)
sym = gdb.execute("info line *"+str(ip), True, True)
else:
sym = gdb.execute("info line *(regs->ip - 1)", True, True)
line = get_line_from_sym(sym)
if is_user:
gdb.execute("inferior 1", False, True)
task_list_add_line(is_user, pid, line)
except gdb.error, x:
print("Drop one entry because:")
for file, lineno, function, text in traceback.extract_tb(sys.exc_info()[2]):
print file, lineno, function, text
#Make sure this is connect gdbframe or not, if not, gtpframe_pipe = 1
gtpframe_pipe = 0
if str(gdb.selected_thread()) == "None":
gtpframe_pipe = 1
gdb.execute("target tfile /sys/kernel/debug/gtpframe_pipe")
exit_count = 0
increase_list(1)
while keep_running:
try:
tfind_done = 0
if gtpframe_pipe:
tid = tfind_entry(0)
if tid < 0:
raise gdb.error("tfind")
else:
tid = tfind_entry(-1)
if tid < 0:
break
tfind_done = 1
if tid == schedule_id or tid == do_exit_id:
cpu_id = int(gdb.parse_and_eval("$cpu_id"))
if cpu_id >= len(pid_list):
increase_list(cpu_id + 1 - len(pid_list))
pid = long(gdb.parse_and_eval("$pc_pid_" + str(cpu_id)))
clock = long(gdb.parse_and_eval("$pc_begin_" + str(cpu_id)))
if pid in pid_list[cpu_id]:
pid_list[cpu_id][pid]["clock"] += clock
pid_list[cpu_id][pid]["count"] += 1
def handleEventError(e, f):
raise gdb.error('*****unhandled event ' + str(e) + ' passed to ' + str(f))
def seekS(e):
debugMsg('hit ' + str(inspect.stack()[0][3]) + ' with event: ' + str(e))
raise gdb.error('seekS not implemented')
pagination = get_pagination()
gdb.execute("set pagination off", False, False)
def format_file(name):
tmp = ""
for c in name:
if c == "_":
c = "-"
tmp += c
return tmp
#Check if the target is available
if str(gdb.selected_thread()) == "None":
raise gdb.error("Please connect to Linux Kernel before use the script.")
#Output the help
print "Use GDB command \"set $mod_search_dir=dir\" to set an directory for search the modules."
ignore_gtp_ko = gdb.parse_and_eval("$ignore_gtp_ko")
if ignore_gtp_ko.type.code == gdb.TYPE_CODE_INT:
ignore_gtp_ko = int(ignore_gtp_ko)
else:
ignore_gtp_ko = 1
#Get the mod_search_dir
mod_search_dir_list = []
#Get dir from $mod_search_dir
tmp_dir = gdb.parse_and_eval("$mod_search_dir")
if tmp_dir.type.code == gdb.TYPE_CODE_ARRAY:
def get_mod_dir_name(name, search_dir):
#get mod_dir_name
full_name = ""
for root, dirs, files in os.walk(search_dir):
for afile in files:
tmp_file = format_file(afile)
if tmp_file == name:
full_name = os.path.join(root,afile)
break
if full_name != "":
break
return full_name
#Check if the target is available
if str(gdb.selected_thread()) == "None":
raise gdb.error("Please connect to Linux Kernel before use the script.")
#Output the help
print "Use GDB command \"set $mod_search_dir=dir\" to set an directory for search the modules."
ignore_gtp_ko = gdb.parse_and_eval("$ignore_gtp_ko")
if ignore_gtp_ko.type.code == gdb.TYPE_CODE_INT:
ignore_gtp_ko = int(ignore_gtp_ko)
else:
ignore_gtp_ko = 1
#Get the mod_search_dir
mod_search_dir_list = []
#Get dir from $mod_search_dir
tmp_dir = gdb.parse_and_eval("$mod_search_dir")
if tmp_dir.type.code == gdb.TYPE_CODE_ARRAY:
#Make sure this is connect gdbframe or not, if not, gtpframe_pipe = 1
gtpframe_pipe = 0;
if str(gdb.selected_thread()) == "None":
gtpframe_pipe = 1
gdb.execute("target tfile /sys/kernel/debug/gtpframe_pipe");
exit_count = 0;
increase_list(1);
while keep_running:
try:
tfind_done = 0;
if gtpframe_pipe:
tid = tfind_entry(0);
if tid < 0:
raise gdb.error("tfind");
else:
tid = tfind_entry(-1);
if tid < 0:
break;
tfind_done = 1;
if tid == schedule_id or tid == do_exit_id:
cpu_id = int(gdb.parse_and_eval("$cpu_id"));
if cpu_id >= len(pid_list):
increase_list(cpu_id + 1 - len(pid_list));
pid = long(gdb.parse_and_eval("$pc_pid_"+str(cpu_id)));
clock = long(gdb.parse_and_eval("$pc_begin_"+str(cpu_id)));
if pid in pid_list[cpu_id]:
pid_list[cpu_id][pid]["clock"] += clock;
pid_list[cpu_id][pid]["count"] += 1;
#Make sure this is connect gdbframe or not, if not, gtpframe_pipe = 1
gtpframe_pipe = 0
if str(gdb.selected_thread()) == "None":
gtpframe_pipe = 1
gdb.execute("target tfile /sys/kernel/debug/gtpframe_pipe")
signal.setitimer(signal.ITIMER_REAL, 1, 1)
keep_running = 1
while keep_running:
try:
tfind_done = 0
if gtpframe_pipe:
tid = tfind_entry(0)
if tid < 0:
raise gdb.error("tfind")
else:
tid = tfind_entry(-1)
if tid < 0:
break
tfind_done = 1
cpu_id = str(gdb.parse_and_eval("$cpu_id"))
clock += long(gdb.parse_and_eval("$pc_pe_val_00_" + cpu_id))
time += 1
except gdb.error, x:
#print("Drop one entry because", x);
pass
except gdb.MemoryError, x:
print("Drop one entry because", x)
