def __compound_head(self) -> int:
return self._compound_head()
def compound_head(self) -> 'Page':
if not self.is_tail():
return self
return self.__class__.from_page_addr(self.__compound_head())
type_cbs = TypeCallbacks([('struct page', Page.setup_page_type),
('enum pageflags', Page.setup_pageflags),
('enum zone_type', Page.setup_zone_type),
('struct mem_section', Page.setup_mem_section)])
msymbol_cbs = MinimalSymbolCallbacks([('kernel_config_data',
Page.setup_nodes_width)])
# TODO: this should better be generalized to some callback for
# "config is available" without refering to the symbol name here
symbol_cbs = SymbolCallbacks([('vmemmap_base', Page.setup_vmemmap_base),
('page_offset_base', Page.setup_directmap_base)])
def pfn_to_page(pfn: int) -> 'Page':
return Page(Page.pfn_to_page(pfn), pfn)
def page_from_addr(addr: int) -> 'Page':
pfn = (addr - Page.directmap_base) // Page.PAGE_SIZE
return pfn_to_page(pfn)
if nr_cpus is None:
nr_cpus = self._nr_cpus
if nr_cpus <= 0:
raise ValueError("nr_cpus must be > 0")
vals = dict()
var = self._resolve_percpu_var(var)
for cpu in range(0, nr_cpus):
vals[cpu] = self._get_percpu_var(var, cpu)
return vals
msym_cbs = MinimalSymbolCallbacks([
('__per_cpu_start', PerCPUState.setup_per_cpu_size),
('__per_cpu_end', PerCPUState.setup_per_cpu_size)
])
symbol_cbs = SymbolCallbacks([('__per_cpu_offset', PerCPUState.setup_nr_cpus),
('modules', PerCPUState.setup_module_ranges)])
_state = PerCPUState()
def is_percpu_var(var: SymbolOrValue) -> bool:
"""
Returns whether the provided value or symbol falls within
any of the percpu ranges
Args:
var: The symbol or value to query
def setup_thread_info(self, thread: gdb.InferiorThread) -> None:
task = thread.info.task_struct
thread_info = task['stack'].cast(types.thread_info_p_type)
thread.info.set_thread_info(thread_info)
@classmethod
# pylint: disable=unused-argument
def setup_inactive_task_frame_handler(cls, inactive: gdb.Type) -> None:
cls.set_fetch_registers(_FRC_inactive_task_frame)
@classmethod
# pylint: disable=unused-argument
def setup_thread_return_handler(cls, inactive: gdb.Type) -> None:
cls.set_fetch_registers(_FRC_thread_return)
@classmethod
def get_stack_pointer(cls, thread_struct: gdb.Value) -> int:
return int(thread_struct['sp'])
type_cbs = TypeCallbacks([
('struct inactive_task_frame',
x86_64Architecture.setup_inactive_task_frame_handler)
])
msymbol_cbs = MinimalSymbolCallbacks([
('thread_return', x86_64Architecture.setup_thread_return_handler)
])
register_arch(x86_64Architecture)