def check_free_pages(self) -> None:
for order in range(array_size(self.gdb_obj["free_area"])):
area = self.gdb_obj["free_area"][order]
self._check_free_area(area, False, order)
for cpu in for_each_online_cpu():
pageset = get_percpu_var(self.gdb_obj["pageset"], cpu)
self._check_free_area(pageset["pcp"], True, cpu)
def setup_tasks(self):
gdb.execute('set print thread-events 0')
init_task = gdb.lookup_global_symbol('init_task')
task_list = init_task.value()['tasks']
runqueues = gdb.lookup_global_symbol('runqueues')
rqs = get_percpu_var(runqueues)
rqscurrs = {long(x["curr"]): k for (k, x) in rqs.items()}
self.pid_to_task_struct = {}
print("Loading tasks...", end='')
sys.stdout.flush()
task_count = 0
tasks = []
for taskg in list_for_each_entry(task_list,
init_task.type,
'tasks',
include_head=True):
tasks.append(taskg)
for task in list_for_each_entry(taskg['thread_group'],
init_task.type, 'thread_group'):
tasks.append(task)
for task in tasks:
cpu = None
regs = None
active = long(task.address) in rqscurrs
if active:
cpu = rqscurrs[long(task.address)]
regs = self.vmcore.attr.cpu[cpu].reg
ltask = LinuxTask(task, active, cpu, regs)
ptid = (LINUX_KERNEL_PID, task['pid'], 0)
try:
thread = gdb.selected_inferior().new_thread(ptid, ltask)
except gdb.error as e:
print("Failed to setup task @{:#x}".format(long(task.address)))
continue
thread.name = task['comm'].string()
self.target.arch.setup_thread_info(thread)
ltask.attach_thread(thread)
ltask.set_get_stack_pointer(self.target.arch.get_stack_pointer)
crash.cache.tasks.cache_task(ltask)
task_count += 1
if task_count % 100 == 0:
print(".", end='')
sys.stdout.flush()
print(" done. ({} tasks total)".format(task_count))
gdb.selected_inferior().executing = False
def __fill_percpu_caches(self) -> None:
cpu_cache = self.gdb_obj[KmemCache.percpu_name]
for cpu in for_each_online_cpu():
if KmemCache.percpu_cache:
array = get_percpu_var(cpu_cache, cpu)
else:
array = cpu_cache[cpu].dereference()
self.__fill_array_cache(array, AC_PERCPU, -1, cpu)
def get_events(cls) -> List[int]:
nr = cls.nr_event_items
events = [0] * nr
for cpu in for_each_online_cpu():
states = get_percpu_var(cls.symbols.vm_event_states, cpu)
for item in range(0, nr):
events[item] += int(states["event"][item])
return events
def get_events():
states_sym = gdb.lookup_global_symbol("vm_event_states")
nr = VmStat.nr_event_items
events = [0L] * nr
for cpu in for_each_online_cpu():
states = get_percpu_var(states_sym, cpu)
for item in range(0, nr):
events[item] += long(states["event"][item])
return events
def numa_node_id(cpu: int) -> int:
"""
Return the NUMA node ID for a given CPU
Args:
cpu: The CPU number to obtain the NUMA node ID
Returns:
:obj:`int`: The NUMA node ID for the specified CPU.
"""
if crash.current_target().arch.name() == "powerpc:common64":
return int(symvals.numa_cpu_lookup_table[cpu])
return int(get_percpu_var(symbols.numa_node, cpu))
def setup_tasks(self):
init_task = gdb.lookup_global_symbol('init_task')
task_list = init_task.value()['tasks']
runqueues = gdb.lookup_global_symbol('runqueues')
rqs = get_percpu_var(runqueues)
rqscurrs = {long(x["curr"]) : k for (k, x) in rqs.items()}
self.pid_to_task_struct = {}
print("Loading tasks...", end='')
sys.stdout.flush()
task_count = 0
tasks = []
for taskg in list_for_each_entry(task_list, init_task.type, 'tasks'):
tasks.append(taskg)
for task in list_for_each_entry(taskg['thread_group'], init_task.type, 'thread_group'):
tasks.append(task)
for task in tasks:
cpu = None
regs = None
active = long(task.address) in rqscurrs
if active:
cpu = rqscurrs[long(task.address)]
regs = self.kdump.attr.cpu[cpu].reg
ltask = LinuxTask(task, active, cpu, regs)
ptid = (LINUX_KERNEL_PID, task['pid'], 0)
try:
thread = gdb.selected_inferior().new_thread(ptid, ltask)
except gdb.error as e:
print("Failed to setup task @{:#x}".format(long(task.address)))
continue
thread.name = task['comm'].string()
self.arch.setup_thread_info(thread)
ltask.attach_thread(thread)
ltask.set_get_stack_pointer(self.arch.get_stack_pointer)
crash.cache.tasks.cache_task(ltask)
task_count += 1
if task_count % 100 == 0:
print(".", end='')
sys.stdout.flush()
print(" done. ({} tasks total)".format(task_count))
gdb.selected_inferior().executing = False
def print_module_percpu(self, mod: gdb.Value, cpu: int = -1) -> None:
cpu = int(cpu)
addr = int(mod['percpu'])
if addr == 0:
return
if cpu != -1:
addr = int(get_percpu_var(mod['percpu'], cpu))
tabs = "\t\t"
else:
tabs = "\t\t\t"
size = int(mod['percpu_size'])
print("{:16s}\t{:#x}{}{:d}".format(mod['name'].string(), addr, tabs,
size))
def numa_node_id(self, cpu):
if gdb.current_target().arch.ident == "powerpc:common64":
return long(self.numa_cpu_lookup_table[cpu])
else:
return long(get_percpu_var(self.numa_node, cpu))
def check_free_pages(self) -> None:
for area in array_for_each(self.gdb_obj["free_area"]):
self._check_free_area(area, False)
for cpu in for_each_online_cpu():
pageset = get_percpu_var(self.gdb_obj["pageset"], cpu)
self._check_free_area(pageset["pcp"], True)
def add_vmstat_diffs(self, diffs: List[int]) -> None:
for cpu in for_each_online_cpu():
pageset = get_percpu_var(self.gdb_obj["pageset"], cpu)
vmdiff = pageset["vm_stat_diff"]
for item in range(0, VmStat.nr_stat_items):
diffs[item] += int(vmdiff[item])
def test_non_percpu_ptr(self):
var = gdb.lookup_symbol('non_percpu_test', None)[0].value()
self.assertTrue(var is not None)
with self.assertRaises(TypeError):
x = percpu.get_percpu_var(var, 0)
self.assertTrue(var['x'] == 0)
