memcg_slabinfo.py 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  1. #!/usr/bin/env drgn
  2. #
  3. # Copyright (C) 2020 Roman Gushchin <guro@fb.com>
  4. # Copyright (C) 2020 Facebook
  5. from os import stat
  6. import argparse
  7. import sys
  8. from drgn.helpers.linux import list_for_each_entry, list_empty
  9. from drgn.helpers.linux import for_each_page
  10. from drgn.helpers.linux.cpumask import for_each_online_cpu
  11. from drgn.helpers.linux.percpu import per_cpu_ptr
  12. from drgn import container_of, FaultError, Object
  13. DESC = """
  14. This is a drgn script to provide slab statistics for memory cgroups.
  15. It supports cgroup v2 and v1 and can emulate memory.kmem.slabinfo
  16. interface of cgroup v1.
  17. For drgn, visit https://github.com/osandov/drgn.
  18. """
  19. MEMCGS = {}
  20. OO_SHIFT = 16
  21. OO_MASK = ((1 << OO_SHIFT) - 1)
  22. def err(s):
  23. print('slabinfo.py: error: %s' % s, file=sys.stderr, flush=True)
  24. sys.exit(1)
  25. def find_memcg_ids(css=prog['root_mem_cgroup'].css, prefix=''):
  26. if not list_empty(css.children.address_of_()):
  27. for css in list_for_each_entry('struct cgroup_subsys_state',
  28. css.children.address_of_(),
  29. 'sibling'):
  30. name = prefix + '/' + css.cgroup.kn.name.string_().decode('utf-8')
  31. memcg = container_of(css, 'struct mem_cgroup', 'css')
  32. MEMCGS[css.cgroup.kn.id.value_()] = memcg
  33. find_memcg_ids(css, name)
  34. def is_root_cache(s):
  35. try:
  36. return False if s.memcg_params.root_cache else True
  37. except AttributeError:
  38. return True
  39. def cache_name(s):
  40. if is_root_cache(s):
  41. return s.name.string_().decode('utf-8')
  42. else:
  43. return s.memcg_params.root_cache.name.string_().decode('utf-8')
  44. # SLUB
  45. def oo_order(s):
  46. return s.oo.x >> OO_SHIFT
  47. def oo_objects(s):
  48. return s.oo.x & OO_MASK
  49. def count_partial(n, fn):
  50. nr_pages = 0
  51. for page in list_for_each_entry('struct page', n.partial.address_of_(),
  52. 'lru'):
  53. nr_pages += fn(page)
  54. return nr_pages
  55. def count_free(page):
  56. return page.objects - page.inuse
  57. def slub_get_slabinfo(s, cfg):
  58. nr_slabs = 0
  59. nr_objs = 0
  60. nr_free = 0
  61. for node in range(cfg['nr_nodes']):
  62. n = s.node[node]
  63. nr_slabs += n.nr_slabs.counter.value_()
  64. nr_objs += n.total_objects.counter.value_()
  65. nr_free += count_partial(n, count_free)
  66. return {'active_objs': nr_objs - nr_free,
  67. 'num_objs': nr_objs,
  68. 'active_slabs': nr_slabs,
  69. 'num_slabs': nr_slabs,
  70. 'objects_per_slab': oo_objects(s),
  71. 'cache_order': oo_order(s),
  72. 'limit': 0,
  73. 'batchcount': 0,
  74. 'shared': 0,
  75. 'shared_avail': 0}
  76. def cache_show(s, cfg, objs):
  77. if cfg['allocator'] == 'SLUB':
  78. sinfo = slub_get_slabinfo(s, cfg)
  79. else:
  80. err('SLAB isn\'t supported yet')
  81. if cfg['shared_slab_pages']:
  82. sinfo['active_objs'] = objs
  83. sinfo['num_objs'] = objs
  84. print('%-17s %6lu %6lu %6u %4u %4d'
  85. ' : tunables %4u %4u %4u'
  86. ' : slabdata %6lu %6lu %6lu' % (
  87. cache_name(s), sinfo['active_objs'], sinfo['num_objs'],
  88. s.size, sinfo['objects_per_slab'], 1 << sinfo['cache_order'],
  89. sinfo['limit'], sinfo['batchcount'], sinfo['shared'],
  90. sinfo['active_slabs'], sinfo['num_slabs'],
  91. sinfo['shared_avail']))
  92. def detect_kernel_config():
  93. cfg = {}
  94. cfg['nr_nodes'] = prog['nr_online_nodes'].value_()
  95. if prog.type('struct kmem_cache').members[1].name == 'flags':
  96. cfg['allocator'] = 'SLUB'
  97. elif prog.type('struct kmem_cache').members[1].name == 'batchcount':
  98. cfg['allocator'] = 'SLAB'
  99. else:
  100. err('Can\'t determine the slab allocator')
  101. cfg['shared_slab_pages'] = False
  102. try:
  103. if prog.type('struct obj_cgroup'):
  104. cfg['shared_slab_pages'] = True
  105. except:
  106. pass
  107. return cfg
  108. def for_each_slab_page(prog):
  109. PGSlab = 1 << prog.constant('PG_slab')
  110. PGHead = 1 << prog.constant('PG_head')
  111. for page in for_each_page(prog):
  112. try:
  113. if page.flags.value_() & PGSlab:
  114. yield page
  115. except FaultError:
  116. pass
  117. def main():
  118. parser = argparse.ArgumentParser(description=DESC,
  119. formatter_class=
  120. argparse.RawTextHelpFormatter)
  121. parser.add_argument('cgroup', metavar='CGROUP',
  122. help='Target memory cgroup')
  123. args = parser.parse_args()
  124. try:
  125. cgroup_id = stat(args.cgroup).st_ino
  126. find_memcg_ids()
  127. memcg = MEMCGS[cgroup_id]
  128. except KeyError:
  129. err('Can\'t find the memory cgroup')
  130. cfg = detect_kernel_config()
  131. print('# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab>'
  132. ' : tunables <limit> <batchcount> <sharedfactor>'
  133. ' : slabdata <active_slabs> <num_slabs> <sharedavail>')
  134. if cfg['shared_slab_pages']:
  135. obj_cgroups = set()
  136. stats = {}
  137. caches = {}
  138. # find memcg pointers belonging to the specified cgroup
  139. obj_cgroups.add(memcg.objcg.value_())
  140. for ptr in list_for_each_entry('struct obj_cgroup',
  141. memcg.objcg_list.address_of_(),
  142. 'list'):
  143. obj_cgroups.add(ptr.value_())
  144. # look over all slab pages, belonging to non-root memcgs
  145. # and look for objects belonging to the given memory cgroup
  146. for page in for_each_slab_page(prog):
  147. objcg_vec_raw = page.memcg_data.value_()
  148. if objcg_vec_raw == 0:
  149. continue
  150. cache = page.slab_cache
  151. if not cache:
  152. continue
  153. addr = cache.value_()
  154. caches[addr] = cache
  155. # clear the lowest bit to get the true obj_cgroups
  156. objcg_vec = Object(prog, 'struct obj_cgroup **',
  157. value=objcg_vec_raw & ~1)
  158. if addr not in stats:
  159. stats[addr] = 0
  160. for i in range(oo_objects(cache)):
  161. if objcg_vec[i].value_() in obj_cgroups:
  162. stats[addr] += 1
  163. for addr in caches:
  164. if stats[addr] > 0:
  165. cache_show(caches[addr], cfg, stats[addr])
  166. else:
  167. for s in list_for_each_entry('struct kmem_cache',
  168. memcg.kmem_caches.address_of_(),
  169. 'memcg_params.kmem_caches_node'):
  170. cache_show(s, cfg, None)
  171. main()