Debian Codegraph @

tests/linux_kernel/helpers/test_slab.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 from collections import defaultdict
5 from pathlib import Path
6 from typing import NamedTuple
7
8 from drgn import NULL
9 from drgn.helpers.linux.mm import pfn_to_virt
10 from drgn.helpers.linux.slab import (
11 find_containing_slab_cache,
12 find_slab_cache,
13 for_each_slab_cache,
14 get_slab_cache_aliases,
15 slab_cache_for_each_allocated_object,
16 slab_cache_is_merged,
17 slab_cache_objects_per_slab,
18 slab_cache_pages_per_slab,
19 slab_cache_usage,
20 slab_object_info,
21 slab_total_usage,
22 )
23 from tests import slow_test
24 from tests.linux_kernel import (
25 LinuxKernelTestCase,
26 meminfo_field_in_pages,
27 skip_unless_have_full_mm_support,
28 skip_unless_have_test_kmod,
29 )
30
31 SLAB_SYSFS_PATH = Path("/sys/kernel/slab")
32
33
34 class Slabinfo(NamedTuple):
35 name: str
36 active_objs: int
37 num_objs: int
38 objsize: int
39 objperslab: int
40 pagesperslab: int
41 limit: int
42 batchcount: int
43 sharedfactor: int
44 active_slabs: int
45 num_slabs: int
46 sharedavail: int
47
48
49 def iter_slabinfo():
50 with open("/proc/slabinfo", "r") as f:
51 # Skip the version and header.
52 f.readline()
53 f.readline()
54 for line in f:
55 components = line.split(":")
56 statistics = components[0].split()
57 tunables = components[1].split()
58 assert tunables[0] == "tunables"
59 slabdata = components[2].split()
60 assert slabdata[0] == "slabdata"
61 yield Slabinfo(
62 name=statistics[0],
63 active_objs=int(statistics[1]),
64 num_objs=int(statistics[2]),
65 objsize=int(statistics[3]),
66 objperslab=int(statistics[4]),
67 pagesperslab=int(statistics[5]),
68 limit=int(tunables[1]),
69 batchcount=int(tunables[2]),
70 sharedfactor=int(tunables[3]),
71 active_slabs=int(slabdata[1]),
72 num_slabs=int(slabdata[2]),
73 sharedavail=int(slabdata[3]),
74 )
75
76
77 def get_proc_slabinfo_names():
78 with open("/proc/slabinfo", "rb") as f:
79 # Skip the version and header.
80 f.readline()
81 f.readline()
82 return [line.split()[0] for line in f]
83
84
85 _FALLBACK_SLAB_CACHE = "mnt_cache"
86
87
88 def fallback_slab_cache_names(prog):
89 # SLOB does not provide /proc/slabinfo. It is also disabled for SLUB if
90 # CONFIG_SLUB_DEBUG=n. Before Linux kernel commit 5b36577109be ("mm:
91 # slabinfo: remove CONFIG_SLABINFO") (in v4.15), it could also be disabled
92 # for SLAB. So, pick a few slab caches which we know exist to test against.
93 # In case they were merged into other caches, get their names from the
94 # structs rather than just returning the names.
95 return {
96 prog[_FALLBACK_SLAB_CACHE].name.string_(),
97 prog["mm_cachep"].name.string_(),
98 prog["uid_cachep"].name.string_(),
99 }
100
101
102 class TestSlab(LinuxKernelTestCase):
103 @skip_unless_have_test_kmod
104 def test_slab_cache_objects_per_slab(self):
105 if self.prog["drgn_test_slob"]:
106 self.assertRaisesRegex(
107 ValueError,
108 "SLOB is not supported",
109 slab_cache_objects_per_slab,
110 self.prog[_FALLBACK_SLAB_CACHE],
111 )
112 return
113
114 try:
115 for slabinfo in iter_slabinfo():
116 if slabinfo.objperslab > 1:
117 # Prefer testing a slab cache with more than one object per
118 # slab.
119 break
120 except FileNotFoundError:
121 self.skipTest("/proc/slabinfo does not exist")
122 self.assertEqual(
123 slab_cache_objects_per_slab(find_slab_cache(self.prog, slabinfo.name)),
124 slabinfo.objperslab,
125 )
126
127 @skip_unless_have_test_kmod
128 def test_slab_cache_pages_per_slab(self):
129 if self.prog["drgn_test_slob"]:
130 self.assertRaisesRegex(
131 ValueError,
132 "SLOB is not supported",
133 slab_cache_pages_per_slab,
134 self.prog[_FALLBACK_SLAB_CACHE],
135 )
136 return
137
138 try:
139 for slabinfo in iter_slabinfo():
140 if slabinfo.pagesperslab > 1:
141 # Prefer testing a slab cache with more than one page per
142 # slab.
143 break
144 except FileNotFoundError:
145 self.skipTest("/proc/slabinfo does not exist")
146 self.assertEqual(
147 slab_cache_pages_per_slab(find_slab_cache(self.prog, slabinfo.name)),
148 slabinfo.pagesperslab,
149 )
150
151 def _slab_cache_aliases(self):
152 if not SLAB_SYSFS_PATH.exists():
153 self.skipTest(f"{str(SLAB_SYSFS_PATH)} does not exist")
154 aliases = defaultdict(list)
155 for child in SLAB_SYSFS_PATH.iterdir():
156 if not child.name.startswith(":"):
157 aliases[child.stat().st_ino].append(child.name)
158 return aliases
159
160 def test_slab_cache_is_merged_false(self):
161 for aliases in self._slab_cache_aliases().values():
162 if len(aliases) == 1:
163 break
164 else:
165 self.skipTest("no unmerged slab caches")
166 self.assertFalse(slab_cache_is_merged(find_slab_cache(self.prog, aliases[0])))
167
168 def test_slab_cache_is_merged_true(self):
169 for aliases in self._slab_cache_aliases().values():
170 if len(aliases) > 1:
171 break
172 else:
173 self.skipTest("no merged slab caches")
174 for alias in aliases:
175 slab_cache = find_slab_cache(self.prog, alias)
176 if slab_cache is not None:
177 break
178 else:
179 self.fail("couldn't find slab cache")
180 self.assertTrue(slab_cache_is_merged(slab_cache))
181
182 def test_get_slab_cache_aliases(self):
183 if not SLAB_SYSFS_PATH.exists():
184 # A SLOB or SLAB kernel, or one without SYSFS. Test that the
185 # helper fails as expected.
186 self.assertRaisesRegex(
187 LookupError, "CONFIG_SYSFS", get_slab_cache_aliases, self.prog
188 )
189 return
190 # Otherwise, the helper should work, test functionality.
191 alias_to_name = get_slab_cache_aliases(self.prog)
192 for aliases in self._slab_cache_aliases().values():
193 # Alias groups of size 1 are either non-mergeable slabs, or
194 # mergeable slabs which haven't actually been merged. Either way,
195 # they should not be present in the dictionary.
196 if len(aliases) == 1:
197 self.assertNotIn(aliases[0], alias_to_name)
198 continue
199
200 # Find out which cache in the group is target -- it won't be
201 # included in the alias dict.
202 for alias in aliases:
203 if alias not in alias_to_name:
204 target_alias = alias
205 aliases.remove(alias)
206 break
207 else:
208 self.fail("could not find target slab cache name")
209
210 # All aliases should map to the same name
211 for alias in aliases:
212 self.assertEqual(alias_to_name[alias], target_alias)
213 self.assertNotIn(target_alias, alias_to_name)
214
215 def test_for_each_slab_cache(self):
216 try:
217 slab_cache_names = get_proc_slabinfo_names()
218 except FileNotFoundError:
219 # The found names should be a superset of the fallback names.
220 self.assertGreaterEqual(
221 {s.name.string_() for s in for_each_slab_cache(self.prog)},
222 fallback_slab_cache_names(self.prog),
223 )
224 else:
225 self.assertCountEqual(
226 [s.name.string_() for s in for_each_slab_cache(self.prog)],
227 slab_cache_names,
228 )
229
230 def test_find_slab_cache(self):
231 try:
232 slab_cache_names = get_proc_slabinfo_names()
233 except FileNotFoundError:
234 slab_cache_names = fallback_slab_cache_names(self.prog)
235 for name in slab_cache_names:
236 slab = find_slab_cache(self.prog, name)
237 self.assertEqual(name, slab.name.string_())
238
239 @skip_unless_have_full_mm_support
240 @skip_unless_have_test_kmod
241 def test_slab_cache_usage(self):
242 for size in ("small", "big"):
243 with self.subTest(size=size):
244 cache = self.prog[f"drgn_test_{size}_kmem_cache"]
245 if self.prog["drgn_test_slob"]:
246 self.assertRaisesRegex(
247 ValueError, "SLOB is not supported", slab_cache_usage, cache
248 )
249 return
250
251 name = f"drgn_test_{size}"
252 try:
253 for slabinfo in iter_slabinfo():
254 if slabinfo.name == name:
255 break
256 else:
257 self.fail(f"couldn't find {name} in slabinfo")
258 except FileNotFoundError:
259 self.skipTest("/proc/slabinfo does not exist")
260
261 usage = slab_cache_usage(cache)
262 self.assertEqual(
263 usage.active_objs,
264 len(self.prog[f"drgn_test_{size}_slab_objects"]),
265 )
266 self.assertEqual(usage.num_objs, slabinfo.num_objs)
267 self.assertEqual(usage.num_slabs, slabinfo.num_slabs)
268
269 @skip_unless_have_full_mm_support
270 @skip_unless_have_test_kmod
271 @slow_test
272 def test_slab_cache_for_each_allocated_object(self):
273 for size in ("small", "big"):
274 with self.subTest(size=size):
275 cache = self.prog[f"drgn_test_{size}_kmem_cache"]
276 objects = self.prog[f"drgn_test_{size}_slab_objects"]
277 if self.prog["drgn_test_slob"]:
278 with self.assertRaisesRegex(ValueError, "SLOB is not supported"):
279 next(
280 slab_cache_for_each_allocated_object(
281 cache, f"struct drgn_test_{size}_slab_object"
282 )
283 )
284 else:
285 self.assertEqual(
286 sorted(
287 slab_cache_for_each_allocated_object(
288 cache, f"struct drgn_test_{size}_slab_object"
289 ),
290 key=lambda obj: obj.value.value_(),
291 ),
292 list(objects),
293 )
294
295 @skip_unless_have_full_mm_support
296 @skip_unless_have_test_kmod
297 def test_slab_object_info(self):
298 for size in ("small", "big"):
299 with self.subTest(size=size):
300 cache = self.prog[f"drgn_test_{size}_kmem_cache"]
301 objects = self.prog[f"drgn_test_{size}_slab_objects"]
302 if self.prog["drgn_test_slob"]:
303 info = slab_object_info(objects[0])
304 if size == "small":
305 self.assertFalse(info.slab_cache)
306 self.assertTrue(info.slab)
307 self.assertFalse(info.address)
308 self.assertIsNone(info.allocated)
309 else:
310 self.assertIsNone(info)
311 else:
312 info = slab_object_info(objects[0])
313 self.assertEqual(info.slab_cache, cache)
314 self.assertEqual(info.address, objects[0].value_())
315 self.assertTrue(info.allocated)
316
317 info = slab_object_info(objects[0].value.address_of_())
318 self.assertEqual(info.slab_cache, cache)
319 self.assertEqual(info.address, objects[0].value_())
320 self.assertTrue(info.allocated)
321
322 @skip_unless_have_full_mm_support
323 @skip_unless_have_test_kmod
324 def test_find_containing_slab_cache(self):
325 for size in ("small", "big"):
326 with self.subTest(size=size):
327 cache = self.prog[f"drgn_test_{size}_kmem_cache"]
328 if self.prog["drgn_test_slob"]:
329 cache = NULL(self.prog, "struct kmem_cache *")
330 objects = self.prog[f"drgn_test_{size}_slab_objects"]
331 for obj in objects:
332 self.assertEqual(
333 find_containing_slab_cache(self.prog, obj.value_()), cache
334 )
335 self.assertEqual(find_containing_slab_cache(obj), cache)
336
337 @skip_unless_have_full_mm_support
338 @skip_unless_have_test_kmod
339 def test_find_containing_slab_cache_invalid(self):
340 start_addr = pfn_to_virt(self.prog["min_low_pfn"])
341 end_addr = pfn_to_virt(self.prog["max_pfn"]) + self.prog["PAGE_SIZE"]
342
343 self.assertEqual(
344 find_containing_slab_cache(self.prog, start_addr - 1),
345 NULL(self.prog, "struct kmem_cache *"),
346 )
347 self.assertEqual(
348 find_containing_slab_cache(self.prog, end_addr),
349 NULL(self.prog, "struct kmem_cache *"),
350 )
351
352 self.assertEqual(
353 find_containing_slab_cache(self.prog, self.prog.symbol("jiffies").address),
354 NULL(self.prog, "struct kmem_cache *"),
355 )
356
357 self.assertEqual(
358 find_containing_slab_cache(self.prog, self.prog["drgn_test_va"]),
359 NULL(self.prog, "struct kmem_cache *"),
360 )
361
362 def test_slab_total_usage(self):
363 slab_usage = slab_total_usage(self.prog)
364 self.assertAlmostEqual(
365 slab_usage.reclaimable_pages,
366 meminfo_field_in_pages("SReclaimable"),
367 delta=1024 * 1024 * 1024,
368 )
369 self.assertAlmostEqual(
370 slab_usage.unreclaimable_pages,
371 meminfo_field_in_pages("SUnreclaim"),
372 delta=1024 * 1024 * 1024,
373 )