Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326# SPDX-License-Identifier: GPL-2.0## Copyright (c) 2023 MediaTek Inc.## Authors:# Kuan-Ying Lee <Kuan-Ying.Lee@mediatek.com>#
import gdbimport reimport tracebackfrom linux import lists, utils, stackdepot, constants, mm
SLAB_RED_ZONE = constants.LX_SLAB_RED_ZONESLAB_POISON = constants.LX_SLAB_POISONSLAB_KMALLOC = constants.LX_SLAB_KMALLOCSLAB_HWCACHE_ALIGN = constants.LX_SLAB_HWCACHE_ALIGNSLAB_CACHE_DMA = constants.LX_SLAB_CACHE_DMASLAB_CACHE_DMA32 = constants.LX_SLAB_CACHE_DMA32SLAB_STORE_USER = constants.LX_SLAB_STORE_USERSLAB_PANIC = constants.LX_SLAB_PANIC
OO_SHIFT = 16OO_MASK = (1 << OO_SHIFT) - 1
if constants.LX_CONFIG_SLUB_DEBUG: slab_type = utils.CachedType("struct slab") slab_ptr_type = slab_type.get_type().pointer() kmem_cache_type = utils.CachedType("struct kmem_cache") kmem_cache_ptr_type = kmem_cache_type.get_type().pointer() freeptr_t = utils.CachedType("freeptr_t") freeptr_t_ptr = freeptr_t.get_type().pointer()
track_type = gdb.lookup_type('struct track') track_alloc = int(gdb.parse_and_eval('TRACK_ALLOC')) track_free = int(gdb.parse_and_eval('TRACK_FREE'))
def slab_folio(slab): return slab.cast(gdb.lookup_type("struct folio").pointer())
def slab_address(slab): p_ops = mm.page_ops().ops folio = slab_folio(slab) return p_ops.folio_address(folio)
def for_each_object(cache, addr, slab_objects): p = addr if cache['flags'] & SLAB_RED_ZONE: p += int(cache['red_left_pad']) while p < addr + (slab_objects * cache['size']): yield p p = p + int(cache['size'])
def get_info_end(cache): if (cache['offset'] >= cache['inuse']): return cache['inuse'] + gdb.lookup_type("void").pointer().sizeof else: return cache['inuse']
def get_orig_size(cache, obj): if cache['flags'] & SLAB_STORE_USER and cache['flags'] & SLAB_KMALLOC: p = mm.page_ops().ops.kasan_reset_tag(obj) p += get_info_end(cache) p += gdb.lookup_type('struct track').sizeof * 2 p = p.cast(utils.get_uint_type().pointer()) return p.dereference() else: return cache['object_size']
def get_track(cache, object_pointer, alloc): p = object_pointer + get_info_end(cache) p += (alloc * track_type.sizeof) return p
def oo_objects(x): return int(x['x']) & OO_MASK
def oo_order(x): return int(x['x']) >> OO_SHIFT
def reciprocal_divide(a, R): t = (a * int(R['m'])) >> 32 return (t + ((a - t) >> int(R['sh1']))) >> int(R['sh2'])
def __obj_to_index(cache, addr, obj): return reciprocal_divide(int(mm.page_ops().ops.kasan_reset_tag(obj)) - addr, cache['reciprocal_size'])
def swab64(x): result = (((x & 0x00000000000000ff) << 56) | \ ((x & 0x000000000000ff00) << 40) | \ ((x & 0x0000000000ff0000) << 24) | \ ((x & 0x00000000ff000000) << 8) | \ ((x & 0x000000ff00000000) >> 8) | \ ((x & 0x0000ff0000000000) >> 24) | \ ((x & 0x00ff000000000000) >> 40) | \ ((x & 0xff00000000000000) >> 56)) return result
def freelist_ptr_decode(cache, ptr, ptr_addr): if constants.LX_CONFIG_SLAB_FREELIST_HARDENED: return ptr['v'] ^ cache['random'] ^ swab64(int(ptr_addr)) else: return ptr['v']
def get_freepointer(cache, obj): obj = mm.page_ops().ops.kasan_reset_tag(obj) ptr_addr = obj + cache['offset'] p = ptr_addr.cast(freeptr_t_ptr).dereference() return freelist_ptr_decode(cache, p, ptr_addr)
def loc_exist(loc_track, addr, handle, waste): for loc in loc_track: if loc['addr'] == addr and loc['handle'] == handle and loc['waste'] == waste: return loc return None
def add_location(loc_track, cache, track, orig_size): jiffies = gdb.parse_and_eval("jiffies_64") age = jiffies - track['when'] handle = 0 waste = cache['object_size'] - int(orig_size) pid = int(track['pid']) cpuid = int(track['cpu']) addr = track['addr'] if constants.LX_CONFIG_STACKDEPOT: handle = track['handle']
loc = loc_exist(loc_track, addr, handle, waste) if loc: loc['count'] += 1 if track['when']: loc['sum_time'] += age loc['min_time'] = min(loc['min_time'], age) loc['max_time'] = max(loc['max_time'], age) loc['min_pid'] = min(loc['min_pid'], pid) loc['max_pid'] = max(loc['max_pid'], pid) loc['cpus'].add(cpuid) else: loc_track.append({ 'count' : 1, 'addr' : addr, 'sum_time' : age, 'min_time' : age, 'max_time' : age, 'min_pid' : pid, 'max_pid' : pid, 'handle' : handle, 'waste' : waste, 'cpus' : {cpuid} } )
def slabtrace(alloc, cache_name):
def __fill_map(obj_map, cache, slab): p = slab['freelist'] addr = slab_address(slab) while p != gdb.Value(0): index = __obj_to_index(cache, addr, p) obj_map[index] = True # free objects p = get_freepointer(cache, p)
# process every slab page on the slab_list (partial and full list) def process_slab(loc_track, slab_list, alloc, cache): for slab in lists.list_for_each_entry(slab_list, slab_ptr_type, "slab_list"): obj_map[:] = [False] * oo_objects(cache['oo']) __fill_map(obj_map, cache, slab) addr = slab_address(slab) for object_pointer in for_each_object(cache, addr, slab['objects']): if obj_map[__obj_to_index(cache, addr, object_pointer)] == True: continue p = get_track(cache, object_pointer, alloc) track = gdb.Value(p).cast(track_type.pointer()) if alloc == track_alloc: size = get_orig_size(cache, object_pointer) else: size = cache['object_size'] add_location(loc_track, cache, track, size) continue
slab_caches = gdb.parse_and_eval("slab_caches") if mm.page_ops().ops.MAX_NUMNODES > 1: nr_node_ids = int(gdb.parse_and_eval("nr_node_ids")) else: nr_node_ids = 1
target_cache = None loc_track = []
for cache in lists.list_for_each_entry(slab_caches, kmem_cache_ptr_type, 'list'): if cache['name'].string() == cache_name: target_cache = cache break
obj_map = [False] * oo_objects(target_cache['oo'])
if target_cache['flags'] & SLAB_STORE_USER: for i in range(0, nr_node_ids): cache_node = target_cache['per_node']['node'][i] if cache_node['nr_slabs']['counter'] == 0: continue process_slab(loc_track, cache_node['partial'], alloc, target_cache) process_slab(loc_track, cache_node['full'], alloc, target_cache) else: raise gdb.GdbError("SLAB_STORE_USER is not set in %s" % target_cache['name'].string())
for loc in sorted(loc_track, key=lambda x:x['count'], reverse=True): if loc['addr']: addr = loc['addr'].cast(utils.get_ulong_type().pointer()) gdb.write("%d %s" % (loc['count'], str(addr).split(' ')[-1])) else: gdb.write("%d <not-available>" % loc['count'])
if loc['waste']: gdb.write(" waste=%d/%d" % (loc['count'] * loc['waste'], loc['waste']))
if loc['sum_time'] != loc['min_time']: gdb.write(" age=%d/%d/%d" % (loc['min_time'], loc['sum_time']/loc['count'], loc['max_time'])) else: gdb.write(" age=%d" % loc['min_time'])
if loc['min_pid'] != loc['max_pid']: gdb.write(" pid=%d-%d" % (loc['min_pid'], loc['max_pid'])) else: gdb.write(" pid=%d" % loc['min_pid'])
if constants.LX_NR_CPUS > 1: nr_cpu = gdb.parse_and_eval('__num_online_cpus')['counter'] if nr_cpu > 1: gdb.write(" cpus=") gdb.write(','.join(str(cpu) for cpu in loc['cpus'])) gdb.write("\n") if constants.LX_CONFIG_STACKDEPOT: if loc['handle']: stackdepot.stack_depot_print(loc['handle']) gdb.write("\n")
def help(): t = """Usage: lx-slabtrace --cache_name [cache_name] [Options] Options: --alloc print information of allocation trace of the allocated objects --free print information of freeing trace of the allocated objects Example: lx-slabtrace --cache_name kmalloc-1k --alloc lx-slabtrace --cache_name kmalloc-1k --free\n""" gdb.write("Unrecognized command\n") raise gdb.GdbError(t)
class LxSlabTrace(gdb.Command): """Show specific cache slabtrace"""
def __init__(self): super(LxSlabTrace, self).__init__("lx-slabtrace", gdb.COMMAND_DATA)
def invoke(self, arg, from_tty): if not constants.LX_CONFIG_SLUB_DEBUG: raise gdb.GdbError("CONFIG_SLUB_DEBUG is not enabled")
argv = gdb.string_to_argv(arg) alloc = track_alloc # default show alloc_traces
if len(argv) == 3: if argv[2] == '--alloc': alloc = track_alloc elif argv[2] == '--free': alloc = track_free else: help() if len(argv) >= 2 and argv[0] == '--cache_name': slabtrace(alloc, argv[1]) else: help()LxSlabTrace()
def slabinfo(): nr_node_ids = None
if not constants.LX_CONFIG_SLUB_DEBUG: raise gdb.GdbError("CONFIG_SLUB_DEBUG is not enabled")
def count_free(slab): total_free = 0 for slab in lists.list_for_each_entry(slab, slab_ptr_type, 'slab_list'): total_free += int(slab['objects'] - slab['inuse']) return total_free
gdb.write("{:^18} | {:^20} | {:^12} | {:^12} | {:^8} | {:^11} | {:^13}\n".format('Pointer', 'name', 'active_objs', 'num_objs', 'objsize', 'objperslab', 'pagesperslab')) gdb.write("{:-^18} | {:-^20} | {:-^12} | {:-^12} | {:-^8} | {:-^11} | {:-^13}\n".format('', '', '', '', '', '', ''))
slab_caches = gdb.parse_and_eval("slab_caches") if mm.page_ops().ops.MAX_NUMNODES > 1: nr_node_ids = int(gdb.parse_and_eval("nr_node_ids")) else: nr_node_ids = 1
for cache in lists.list_for_each_entry(slab_caches, kmem_cache_ptr_type, 'list'): nr_objs = 0 nr_free = 0 nr_slabs = 0 for i in range(0, nr_node_ids): cache_node = cache['per_node']['node'][i] try: nr_slabs += cache_node['nr_slabs']['counter'] nr_objs = int(cache_node['total_objects']['counter']) nr_free = count_free(cache_node['partial']) except: raise gdb.GdbError(traceback.format_exc()) active_objs = nr_objs - nr_free num_objs = nr_objs active_slabs = nr_slabs objects_per_slab = oo_objects(cache['oo']) cache_order = oo_order(cache['oo']) gdb.write("{:18s} | {:20.19s} | {:12} | {:12} | {:8} | {:11} | {:13}\n".format(hex(cache), cache['name'].string(), str(active_objs), str(num_objs), str(cache['size']), str(objects_per_slab), str(1 << cache_order)))
class LxSlabInfo(gdb.Command): """Show slabinfo"""
def __init__(self): super(LxSlabInfo, self).__init__("lx-slabinfo", gdb.COMMAND_DATA)
def invoke(self, arg, from_tty): slabinfo()LxSlabInfo()