Debian Codegraph @

tests/linux_kernel/crash_commands/test_kmem.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import os
5 from pathlib import Path
6 import re
7 import tempfile
8
9 from drgn import Object
10 from drgn.commands import CommandArgumentError
11 from drgn.commands._crash.common import CRASH_COMMAND_NAMESPACE
12 from drgn.helpers.linux.mm import PageUsage
13 from drgn.helpers.linux.slab import SlabTotalUsage
14 from tests import with_default_prog
15 from tests.linux_kernel import (
16 HAVE_FULL_MM_SUPPORT,
17 possible_cpus,
18 skip_unless_have_full_mm_support,
19 skip_unless_have_test_kmod,
20 )
21 from tests.linux_kernel.crash_commands import CrashCommandTestCase
22 from tests.linux_kernel.helpers.test_slab import fallback_slab_cache_names
23 from util import KernelVersion
24
25 # Good enough approximation for full kmem -s support.
26 have_full_kmem_s_support = Path("/proc/slabinfo").exists()
27
28
29 class TestKmem(CrashCommandTestCase):
30 def _test_free_common(self, flag):
31 cmd = self.check_crash_command(f"kmem -{flag}")
32 expected = set(
33 re.findall(
34 r"^Node\s+([0-9]+)\s*,\s*zone\s+(\w+)",
35 Path("/proc/zoneinfo").read_text(),
36 flags=re.MULTILINE,
37 )
38 )
39 actual = set()
40 header = 0
41 for line in cmd.stdout.splitlines():
42 if header == 0:
43 match = re.match(r"(NODE\s+)?ZONE", line)
44 if match:
45 header = 2 if match.group(1) else 1
46 else:
47 if header == 1:
48 actual.add(("0", re.match(r"\s*[0-9]+\s+(\w+)", line).group(1)))
49 else:
50 actual.add(re.match(r"\s*([0-9]+)\s+[0-9]+\s+(\w+)", line).groups())
51 header = 0
52 # Since Linux kernel commit b2bd8598195f ("mm, vmstat: print
53 # non-populated zones in zoneinfo") (in v4.12), these should be equal,
54 # but before that, /proc/zoneinfo doesn't include all zones.
55 self.assertGreaterEqual(actual, expected)
56 self.assertRegex(cmd.stdout, r"nr_free_pages: [0-9]+")
57
58 for variable in (
59 "zone",
60 "name",
61 "size",
62 "free",
63 "mem_map",
64 "start_paddr",
65 "start_pfn",
66 "order",
67 "block_size",
68 "migrate_type",
69 "num_blocks",
70 "num_pages",
71 ):
72 self.assertIn(variable, cmd.drgn_option.globals)
73 for variable in (
74 "expected_free_pages",
75 "actual_free_pages",
76 ):
77 self.assertIsInstance(cmd.drgn_option.globals[variable], int)
78 if flag == "F":
79 self.assertRegex(cmd.stdout, r"(?m)^[0-9a-f]+$")
80 self.assertIsInstance(cmd.drgn_option.globals["page"], Object)
81
82 def test_f(self):
83 self._test_free_common("f")
84
85 def test_F(self):
86 self._test_free_common("F")
87
88 def test_i(self):
89 cmd = self.check_crash_command("kmem -i")
90 for label in (
91 "TOTAL MEM",
92 "FREE",
93 "USED",
94 "BUFFERS",
95 "CACHED",
96 "SLAB",
97 "TOTAL HUGE",
98 "HUGE FREE",
99 "TOTAL SWAP",
100 "SWAP USED",
101 "SWAP FREE",
102 "COMMIT LIMIT",
103 "COMMITTED",
104 ):
105 self.assertRegex(label, rf"(?m)^{label}\b")
106 for variable in (
107 "total_mem",
108 "free",
109 "used",
110 "buffers",
111 "cached",
112 "commit_limit",
113 "committed",
114 ):
115 self.assertIsInstance(cmd.drgn_option.globals[variable], int)
116 self.assertIsInstance(cmd.drgn_option.globals["slab_usage"], SlabTotalUsage)
117 for variable in (
118 "hugetlb_usage",
119 "swap_usage",
120 ):
121 self.assertIsInstance(cmd.drgn_option.globals[variable], PageUsage)
122
123 @skip_unless_have_test_kmod
124 def test_v(self):
125 cmd = self.check_crash_command("kmem -v")
126 self.assertIn(f"{self.prog['drgn_test_vmalloc_va'].value_():x}", cmd.stdout)
127 self.assertIn("for_each_vmap_area(", cmd.drgn_option.stdout)
128 self.assertEqual(
129 cmd.drgn_option.globals["va"].type_.type_name(), "struct vmap_area *"
130 )
131 self.assertEqual(
132 cmd.drgn_option.globals["vm"].type_.type_name(), "struct vm_struct *"
133 )
134 for variable in ("start", "end", "size"):
135 self.assertIn(variable, cmd.drgn_option.globals)
136
137 def test_V(self):
138 cmd = self.check_crash_command("kmem -V")
139 labels = ["VM_ZONE_STAT", "VM_NODE_STAT"]
140 vmstat_contents = Path("/proc/vmstat").read_text()
141 # Before Linux kernel commit 3a321d2a3dde ("mm: change the call sites
142 # of numa statistics items") (in v4.14), NUMA events are zone
143 # statistics.
144 if KernelVersion(os.uname().release) >= KernelVersion("4.14") and re.search(
145 r"^numa_hit\b", vmstat_contents, flags=re.M
146 ):
147 labels.append(r"VM_NUMA_(EVENT|STAT)")
148 if re.search(r"^pgmajfault\b", vmstat_contents, flags=re.M):
149 labels.append("VM_EVENT_STATES")
150 for label in labels:
151 self.assertRegex(cmd.stdout, rf"(?m)^{label}:")
152
153 for helper in (
154 "global_zone_page_state",
155 "global_node_page_state",
156 "global_numa_event_state",
157 "global_vm_event_state",
158 ):
159 self.assertIn(helper, cmd.drgn_option.stdout)
160 for variable in ("name", "item", "value"):
161 self.assertIn(variable, cmd.drgn_option.globals)
162
163 @skip_unless_have_test_kmod
164 def test_n(self):
165 cmd = self.check_crash_command("kmem -n")
166
167 expected = set(
168 re.findall(
169 r"^Node\s+([0-9]+)\s*,\s*zone\s+(\w+)",
170 Path("/proc/zoneinfo").read_text(),
171 flags=re.MULTILINE,
172 )
173 )
174 actual = set()
175 state = None
176 for line in cmd.stdout.splitlines():
177 if state is None:
178 if re.match(r"\s*NODE\b", line):
179 state = "found_node_header"
180 elif state == "found_node_header":
181 match = re.match(r"\s*([0-9]+)", line)
182 if match:
183 node = match.group(1)
184 state = "found_node"
185 else:
186 state = None
187 elif state == "found_node":
188 if re.match(r"\s*ZONE\b", line):
189 state = "found_zone_header"
190 elif state == "found_zone_header":
191 match = re.match(r"\s*[0-9]+\s*(\w+)", line)
192 if match:
193 actual.add((node, match.group(1)))
194 else:
195 state = None
196 # Since Linux kernel commit b2bd8598195f ("mm, vmstat: print
197 # non-populated zones in zoneinfo") (in v4.12), these should be equal,
198 # but before that, /proc/zoneinfo doesn't include all zones.
199 self.assertGreaterEqual(actual, expected)
200
201 for variable in (
202 "node",
203 "pgdat",
204 "size",
205 "start_pfn",
206 "mem_map",
207 "start_paddr",
208 "zone",
209 "zone_name",
210 "zone_size",
211 "zone_start_pfn",
212 "zone_mem_map",
213 "zone_start_paddr",
214 ):
215 self.assertIn(variable, cmd.drgn_option.globals)
216
217 # Memory hotplug depends on SPARSEMEM, so this check is close enough
218 # for both.
219 if Path("/sys/bus/memory").exists():
220 expected_section = (
221 str(self.prog["drgn_test_section_nr"].value_()),
222 f'{self.prog["drgn_test_mem_section"].value_():x}',
223 )
224 found_section_header = False
225 found_section = False
226 for line in cmd.stdout.splitlines():
227 if found_section_header:
228 match = re.match(r"\s*([0-9]+)\s+([0-9a-f]+)", line)
229 if not match:
230 break
231 if match.groups() == expected_section:
232 found_section = True
233 break
234 elif re.match(r"\s*NR\s+SECTION", line):
235 found_section_header = True
236 self.assertTrue(found_section)
237
238 expected = os.listdir("/sys/bus/memory/devices")
239 actual = []
240 found_memory_block_header = False
241 for line in cmd.stdout.splitlines():
242 if found_memory_block_header:
243 match = re.match(r"\s*[0-9a-f]+\s+(\S+)", line)
244 if not match:
245 break
246 actual.append(match.group(1))
247 elif re.match(r"\s*MEMORY_BLOCK\b", line):
248 found_memory_block_header = True
249 self.assertCountEqual(actual, expected)
250
251 for variable in (
252 "nr",
253 "section",
254 "coded_mem_map",
255 "state",
256 "pfn",
257 "block_size",
258 "mem",
259 "name",
260 "start_section_no",
261 "physical_start",
262 "physical_end",
263 "node",
264 ):
265 self.assertIn(variable, cmd.drgn_option.globals)
266
267 def test_z(self):
268 cmd = self.check_crash_command("kmem -z")
269
270 expected = set(
271 re.findall(
272 r"^Node\s+([0-9]+)\s*,\s*zone\s+(\w+)",
273 Path("/proc/zoneinfo").read_text(),
274 flags=re.MULTILINE,
275 )
276 )
277 actual = set(
278 re.findall(
279 r'^NODE: ([0-9]+).*NAME: "([^"]+)"',
280 cmd.stdout,
281 flags=re.MULTILINE,
282 )
283 )
284 # Since Linux kernel commit b2bd8598195f ("mm, vmstat: print
285 # non-populated zones in zoneinfo") (in v4.12), these should be equal,
286 # but before that, /proc/zoneinfo doesn't include all zones.
287 self.assertGreaterEqual(actual, expected)
288
289 for variable in (
290 "node",
291 "zone",
292 "size",
293 "present",
294 "min_watermark",
295 "low_watermark",
296 "high_watermark",
297 "stat_name",
298 "stat_item",
299 "stat_value",
300 ):
301 self.assertIn(variable, cmd.drgn_option.globals)
302
303 def test_o(self):
304 cmd = self.check_crash_command("kmem -o")
305 for cpu in possible_cpus():
306 self.assertRegex(cmd.stdout, rf"CPU {cpu}:\s*[0-9a-f]+")
307 self.assertIn("for_each_possible_cpu(", cmd.drgn_option.stdout)
308 self.assertIn("per_cpu_ptr(", cmd.drgn_option.stdout)
309 self.assertIn("offset", cmd.drgn_option.globals)
310
311 def test_h(self):
312 cmd = self.check_crash_command("kmem -h")
313 try:
314 names = os.listdir("/sys/kernel/mm/hugepages")
315 except FileNotFoundError:
316 names = []
317 for name in names:
318 self.assertIn(name, cmd.stdout)
319 self.assertIn("for_each_hstate(", cmd.drgn_option.stdout)
320 if names:
321 self.assertEqual(
322 cmd.drgn_option.globals["hstate"].type_.type_name(), "struct hstate *"
323 )
324 for variable in ("size", "free", "total", "name"):
325 self.assertIn(variable, cmd.drgn_option.globals)
326
327 # For kmem -p and kmem -m, printing every page is too slow. Just get the
328 # first few.
329 @skip_unless_have_full_mm_support
330 def test_p(self):
331 with tempfile.TemporaryDirectory() as temp_dir:
332 path = Path(temp_dir) / "file"
333 CRASH_COMMAND_NAMESPACE.run(self.prog, f"kmem -p | head > {path}")
334 for line in path.read_text().splitlines()[1:]:
335 self.assertRegex(
336 line,
337 # PAGE
338 r"^[0-9a-f]+\s+"
339 # PHYSICAL
340 r"[0-9a-f]+\s+"
341 # MAPPING
342 r"[0-9a-f]+\s+"
343 # INDEX
344 r"[0-9a-f]+\s+"
345 # CNT
346 r"-?[0-9]+\s+"
347 # FLAGS
348 r"[0-9a-f]+( [\w,]+)?$",
349 )
350
351 drgn_option = self.run_crash_command_drgn_option("kmem -p", mode="capture")
352 drgn_option_globals = {"prog": self.prog}
353 with with_default_prog(self.prog):
354 exec(drgn_option.stdout + "\n break", drgn_option_globals)
355 for variable in ("physical", "mapping", "index", "cnt", "flags"):
356 self.assertIsInstance(drgn_option_globals[variable], Object)
357 self.assertIsInstance(drgn_option_globals["decoded_flags"], str)
358
359 @skip_unless_have_full_mm_support
360 def test_m(self):
361 members = "mapping,private,_refcount,lru,flags"
362 with tempfile.TemporaryDirectory() as temp_dir:
363 path = Path(temp_dir) / "file"
364 CRASH_COMMAND_NAMESPACE.run(self.prog, f"kmem -m {members} | head > {path}")
365 for line in path.read_text().splitlines()[1:]:
366 self.assertRegex(
367 line,
368 # PAGE
369 r"^[0-9a-f]+\s+"
370 # mapping
371 r"[0-9a-f]+\s+"
372 # private
373 r"-?[0-9]+\s+"
374 # _refcount
375 r"-?[0-9]+\s+"
376 # lru
377 r"[0-9a-f]+,[0-9a-f]+\s+"
378 # flags
379 r"[0-9a-f]+$",
380 )
381
382 drgn_option = self.run_crash_command_drgn_option(
383 f"kmem -m {members}", mode="capture"
384 )
385 drgn_option_globals = {"prog": self.prog}
386 with with_default_prog(self.prog):
387 exec(drgn_option.stdout + "\n break", drgn_option_globals)
388 for variable in ("mapping", "private", "_refcount", "lru", "flags"):
389 self.assertIsInstance(drgn_option_globals[variable], Object)
390
391 def check_kmem_s(self, options, check_common=True):
392 cmd = self.check_crash_command("kmem -s " + options)
393 self.assertEqual(
394 cmd.drgn_option.globals["cache"].type_.type_name(), "struct kmem_cache *"
395 )
396 if check_common:
397 for variable in (
398 "objsize",
399 "name",
400 ):
401 self.assertIn(variable, cmd.drgn_option.globals)
402 if have_full_kmem_s_support:
403 for variable in (
404 "usage",
405 "allocated",
406 "total",
407 "slabs",
408 "ssize",
409 "name",
410 ):
411 self.assertIn(variable, cmd.drgn_option.globals)
412 return cmd
413
414 def test_s(self):
415 cmd = self.check_kmem_s("")
416
417 for name in fallback_slab_cache_names(self.prog):
418 if have_full_kmem_s_support:
419 self.assertRegex(cmd.stdout, rf"[0-9]+k\s+{re.escape(name.decode())}\b")
420 else:
421 self.assertRegex(cmd.stdout, rf"\b{re.escape(name.decode())}\b")
422
423 self.assertIn("for_each_slab_cache(", cmd.drgn_option.stdout)
424
425 def test_s_match_one(self):
426 names = sorted(name.decode() for name in fallback_slab_cache_names(self.prog))
427 cmd = self.check_kmem_s(names[0])
428
429 if have_full_kmem_s_support:
430 self.assertRegex(cmd.stdout, rf"[0-9]+k\s+{re.escape(names[0])}\b")
431 else:
432 self.assertRegex(cmd.stdout, rf"\b{re.escape(names[0])}\b")
433 self.assertNotRegex(cmd.stdout, rf"\b{re.escape(names[1])}\b")
434
435 self.assertIn('find_slab_cache("', cmd.drgn_option.stdout)
436
437 def test_s_match_multiple(self):
438 names = sorted(name.decode() for name in fallback_slab_cache_names(self.prog))
439 cmd = self.check_kmem_s(" ".join(names))
440
441 for name in names:
442 if have_full_kmem_s_support:
443 self.assertRegex(cmd.stdout, rf"[0-9]+k\s+{re.escape(name)}\b")
444 else:
445 self.assertRegex(cmd.stdout, rf"\b{re.escape(name)}\b")
446
447 self.assertIn("find_slab_cache(search_name)", cmd.drgn_option.stdout)
448
449 def test_s_ignore_one(self):
450 ignore = min(fallback_slab_cache_names(self.prog)).decode()
451 cmd = self.check_kmem_s(f"-I {ignore}")
452
453 self.assertRegex(cmd.stdout, rf"\[IGNORED\].*\b{re.escape(ignore)}\b")
454
455 self.assertIn("for_each_slab_cache(", cmd.drgn_option.stdout)
456 self.assertRegex(cmd.drgn_option.stdout, rf"== .*\b{re.escape(ignore)}\b")
457
458 def test_s_ignore_multiple(self):
459 names = sorted(name.decode() for name in fallback_slab_cache_names(self.prog))
460 cmd = self.check_kmem_s(f"-I {','.join(names)}", check_common=False)
461
462 for name in names:
463 self.assertRegex(cmd.stdout, rf"\[IGNORED\].*\b{re.escape(name)}\b")
464
465 self.assertIn("for_each_slab_cache(", cmd.drgn_option.stdout)
466 self.assertIn(" in ignore:", cmd.drgn_option.stdout)
467
468 def test_s_match_and_ignore(self):
469 names = sorted(name.decode() for name in fallback_slab_cache_names(self.prog))
470 cmd = self.check_kmem_s(f"{names[0]} -I {names[0]}", check_common=False)
471
472 self.assertRegex(cmd.stdout, rf"\[IGNORED\].*\b{re.escape(names[0])}\b")
473 self.assertNotRegex(cmd.stdout, rf"\b{re.escape(names[1])}\b")
474
475 self.assertIn("find_slab_cache(", cmd.drgn_option.stdout)
476 self.assertRegex(cmd.drgn_option.stdout, rf"== .*\b{re.escape(names[0])}\b")
477
478 def test_g_value(self):
479 value = (1 << self.prog["PG_locked"].value_()) | (
480 1 << self.prog["PG_uptodate"].value_()
481 )
482 cmd = self.check_crash_command(f"kmem -g {value:x}")
483 self.assertIn("FLAGS:", cmd.stdout)
484 self.assertIn("PG_locked", cmd.stdout)
485 self.assertIn("PG_uptodate", cmd.stdout)
486 self.assertNotIn("PG_dirty", cmd.stdout)
487 self.assertIn("decode_page_flags_value", cmd.drgn_option.stdout)
488 self.assertIn("PG_locked", cmd.drgn_option.globals["flags"])
489
490 def test_g_no_value(self):
491 cmd = self.check_crash_command("kmem -g")
492 self.assertIn("PG_uptodate", cmd.stdout)
493 self.assertIn(".enumerators", cmd.drgn_option.stdout)
494 for variable in ("name", "bit", "value"):
495 self.assertIn(variable, cmd.drgn_option.globals)
496
497 @skip_unless_have_test_kmod
498 def test_identify_symbol(self):
499 address = self.prog.symbol("drgn_test_function").address
500 cmd = self.run_crash_command(f"kmem {address:x}")
501 self.assertRegex(
502 cmd.stdout, rf"(?m)^{address:x} \(.\) drgn_test_function \[drgn_test\]$"
503 )
504
505 @skip_unless_have_test_kmod
506 def test_identify_symbol_offset(self):
507 symbol = self.prog.symbol("drgn_test_function")
508 address = symbol.address + symbol.size - 1
509 cmd = self.run_crash_command(f"kmem {address:x}")
510 self.assertRegex(
511 cmd.stdout,
512 rf"(?m)^{address:x} \(.\) drgn_test_function\+{symbol.size - 1} \[drgn_test\]$",
513 )
514
515 def test_identify_task(self):
516 cmd = self.check_crash_command(f"kmem {self.prog['init_task'].address_:x}")
517 self.assertRegex(cmd.stdout, r'(?m)^COMMAND: "swapper')
518 self.assertIn("identify_address", cmd.drgn_option.globals)
519 self.assertTrue(cmd.drgn_option.globals["identified"])
520
521 def test_identify_task_stack(self):
522 cmd = self.run_crash_command(f"kmem {self.prog['init_task'].stack.value_():x}")
523 self.assertRegex(cmd.stdout, r'(?m)^COMMAND: "swapper')
524
525 @skip_unless_have_test_kmod
526 def test_identify_vmalloc(self):
527 address = self.prog["drgn_test_vmalloc_va"].value_()
528 for option in ("", " -v"):
529 with self.subTest(option=option):
530 cmd = self.run_crash_command(f"kmem{option} {address:x}")
531 self.assertIn("VMAP_AREA", cmd.stdout)
532 self.assertIn(f"{address:x}", cmd.stdout)
533 page_address = f"{self.prog['drgn_test_vmalloc_page'].value_():x}"
534 if HAVE_FULL_MM_SUPPORT:
535 if option:
536 self.assertNotIn(page_address, cmd.stdout)
537 else:
538 self.assertIn(page_address, cmd.stdout)
539
540 @skip_unless_have_test_kmod
541 def test_identify_not_vmalloc(self):
542 address = self.prog["drgn_test_small_slab_objects"][0].value_()
543 cmd = self.run_crash_command(f"kmem -v {address:x}")
544 self.assertIn("address is not allocated in vmalloc subsystem", cmd.stdout)
545 self.assertNotIn("SLAB", cmd.stdout)
546
547 @skip_unless_have_test_kmod
548 def test_identify_page(self):
549 address = self.prog["drgn_test_page"].value_()
550 for option in ("", " -p"):
551 with self.subTest(option=option):
552 cmd = self.run_crash_command(f"kmem{option} {address + 1:x}")
553 self.assertIn("PAGE", cmd.stdout)
554 self.assertIn(f"{address:x}", cmd.stdout)
555
556 @skip_unless_have_full_mm_support
557 @skip_unless_have_test_kmod
558 def test_identify_slab(self):
559 address = self.prog["drgn_test_small_slab_objects"][0].value_()
560 for option in ("", " -s"):
561 with self.subTest(option=option):
562 cmd = self.run_crash_command(f"kmem{option} {address + 1:x}")
563 if self.prog["drgn_test_slob"]:
564 self.assertIn(
565 f"kmem: address is from SLOB: {address + 1:x}", cmd.stdout
566 )
567 else:
568 self.assertIn("drgn_test_small", cmd.stdout)
569 self.assertIn(f"[{address:x}]", cmd.stdout)
570
571 @skip_unless_have_test_kmod
572 def test_identify_not_slab(self):
573 address = self.prog["drgn_test_vmalloc_va"].value_()
574 cmd = self.run_crash_command(f"kmem -s {address:x}")
575 self.assertIn("address is not allocated in slab subsystem", cmd.stdout)
576 self.assertNotIn("VMAP_AREA", cmd.stdout)
577
578 @skip_unless_have_full_mm_support
579 @skip_unless_have_test_kmod
580 def test_identify_slab_with_names(self):
581 address = self.prog["drgn_test_small_slab_objects"][0].value_()
582 cmd = self.run_crash_command(f"kmem -s drgn_test_big {address + 1:x}")
583 self.assertIn("ignoring pre-selected slab caches for address", cmd.stdout)
584 if self.prog["drgn_test_slob"]:
585 self.assertIn(f"kmem: address is from SLOB: {address + 1:x}", cmd.stdout)
586 else:
587 self.assertIn("drgn_test_small", cmd.stdout)
588 self.assertIn(f"[{address:x}]", cmd.stdout)
589
590 @skip_unless_have_full_mm_support
591 @skip_unless_have_test_kmod
592 def test_identify_slab_ignored(self):
593 address = self.prog["drgn_test_small_slab_objects"][0].value_()
594 cmd = self.run_crash_command(f"kmem -s -I drgn_test_small {address + 1:x}")
595 if self.prog["drgn_test_slob"]:
596 self.assertIn(f"kmem: address is from SLOB: {address + 1:x}", cmd.stdout)
597 else:
598 self.assertIn("drgn_test_small", cmd.stdout)
599 self.assertIn("[IGNORED]", cmd.stdout)
600 self.assertNotIn(f"[{address:x}]", cmd.stdout)
601
602 @skip_unless_have_full_mm_support
603 @skip_unless_have_test_kmod
604 def test_identify_multiple(self):
605 slab_address = self.prog["drgn_test_small_slab_objects"][0].value_()
606 vmalloc_address = self.prog["drgn_test_vmalloc_va"].value_()
607 cmd = self.check_crash_command(f"kmem {vmalloc_address:x} {slab_address:x}")
608
609 self.assertIn("VMAP_AREA", cmd.stdout)
610 self.assertIn(f"{vmalloc_address:x}", cmd.stdout)
611
612 if not self.prog["drgn_test_slob"]:
613 self.assertIn("drgn_test_small", cmd.stdout)
614 self.assertIn(f"[{slab_address:x}]", cmd.stdout)
615
616 self.assertIn("identify_address", cmd.drgn_option.globals)
617 self.assertTrue(cmd.drgn_option.globals["identified"])
618
619 def test_no_arguments(self):
620 self.assertRaises(CommandArgumentError, self.run_crash_command, "kmem")