def next(self): t = self.curr_task if not t or t == self.curr_group: self.curr_group = \ utils.container_of(self.curr_group['tasks']['next'], self.task_ptr_type, "tasks") if self.curr_group == self.init_task.address: raise StopIteration t = self.curr_task = self.curr_group else: self.curr_task = \ utils.container_of(t['thread_group']['next'], self.task_ptr_type, "thread_group") return t
def print_timer(rb_node, idx): timerqueue = utils.container_of(rb_node, timerqueue_node_type.pointer(), "node") timer = utils.container_of(timerqueue, hrtimer_type.pointer(), "node") function = str(timer['function']).split(" ")[1].strip("<>") softexpires = timer['_softexpires'] expires = timer['node']['expires'] now = ktime_get() text = " #{}: <{}>, {}, ".format(idx, timer, function) text += "S:{:02x}\n".format(int(timer['state'])) text += " # expires at {}-{} nsecs [in {} to {} nsecs]\n".format( softexpires, expires, softexpires - now, expires - now) return text
def invoke(self, arg, from_tty): gdb.write( "Address{0} Module Size Used by\n".format( " " if utils.get_long_type().sizeof == 8 else "")) for module in module_list(): ref = 0 module_refptr = module['refptr'] for cpu in cpus.cpu_list("cpu_possible_mask"): refptr = cpus.per_cpu(module_refptr, cpu) ref += refptr['incs'] ref -= refptr['decs'] gdb.write("{address} {name:<19} {size:>8} {ref}".format( address=str(module['module_core']).split()[0], name=module['name'].string(), size=str(module['core_size']), ref=str(ref))) source_list = module['source_list'] t = self._module_use_type.get_type().pointer() entry = source_list['next'] first = True while entry != source_list.address: use = utils.container_of(entry, t, "source_list") gdb.write("{separator}{name}".format( separator=" " if first else ",", name=use['source']['name'].string())) first = False entry = entry['next'] gdb.write("\n")
def invoke(self, arg, from_tty): gdb.write( "Address{0} Module Size Used by\n".format( " " if utils.get_long_type().sizeof == 8 else "")) for module in module_list(): layout = module['core_layout'] gdb.write("{address} {name:<19} {size:>8} {ref}".format( address=str(layout['base']).split()[0], name=module['name'].string(), size=str(layout['size']), ref=str(module['refcnt']['counter']))) source_list = module['source_list'] t = self._module_use_type.get_type().pointer() entry = source_list['next'] first = True while entry != source_list.address: use = utils.container_of(entry, t, "source_list") gdb.write("{separator}{name}".format( separator=" " if first else ",", name=use['source']['name'].string())) first = False entry = entry['next'] gdb.write("\n")
def next(self): entry = self.curr_entry if entry != self.end_of_list: self.curr_entry = entry['next'] return utils.container_of(entry, self.module_ptr_type, "list") else: raise StopIteration
def task_lists(): task_ptr_type = task_type.get_type().pointer() init_task = gdb.parse_and_eval("init_task").address t = g = init_task while True: while True: yield t t = utils.container_of(t['thread_group']['next'], task_ptr_type, "thread_group") if t == g: break t = g = utils.container_of(g['tasks']['next'], task_ptr_type, "tasks") if t == init_task: return
def module_list(): global module_type module_ptr_type = module_type.get_type().pointer() modules = gdb.parse_and_eval("modules") entry = modules['next'] end_of_list = modules.address while entry != end_of_list: yield utils.container_of(entry, module_ptr_type, "list") entry = entry['next']
def mm_lists(): mm_ptr_type = mm_type.get_type().pointer() init_mm = gdb.parse_and_eval("init_mm").address mm = init_mm while True: yield mm mm = container_of(mm['mmlist']['next'], mm_ptr_type, "mmlist") if mm == init_mm: return
def hlist_for_each_entry(head, gdbtype, member): for node in hlist_for_each(head): yield utils.container_of(node, gdbtype, member)
def device_for_each_child(dev): for kn in klist_for_each(dev['p']['klist_children']): dp = container_of(kn, device_private_type.get_type().pointer(), 'knode_parent') yield dp['device']
def class_for_each_device(cls): for kn in klist_for_each(cls['p']['klist_devices']): dp = container_of(kn, device_private_type.get_type().pointer(), 'knode_class') yield dp['device']
def list_for_each_entry(head, gdbtype, member): for node in list_for_each(head): if node.type != list_head.get_type().pointer(): raise TypeError("Type {} found. Expected struct list_head *." .format(node.type)) yield utils.container_of(node, gdbtype, member)
def for_each_class(): for kobj in kset_for_each_object(gdb.parse_and_eval('class_kset')): subsys = container_of(kobj, kset_type.get_type().pointer(), 'kobj') subsys_priv = container_of(subsys, subsys_private_type.get_type().pointer(), 'subsys') yield subsys_priv['class']