Debian Codegraph @

tests/linux_kernel/crash_commands/test_collections.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import re
5
6 from drgn import Object, offsetof
7 from drgn.commands import CommandArgumentError
8 from drgn.commands._crash._collections import _find_tree_type
9 from drgn.helpers.linux.rbtree import (
10 rbtree_inorder_for_each,
11 rbtree_inorder_for_each_entry,
12 rbtree_preorder_for_each,
13 rbtree_preorder_for_each_entry,
14 )
15 from tests import TestCase
16 from tests.linux_kernel import skip_unless_have_test_kmod
17 from tests.linux_kernel.crash_commands import CrashCommandTestCase
18
19
20 @skip_unless_have_test_kmod
21 class TestList(CrashCommandTestCase):
22 def test_null_terminated(self):
23 cmd = self.check_crash_command(
24 "list -o drgn_test_custom_list_entry.next drgn_test_custom_list"
25 )
26 self.assertEqual(
27 cmd.stdout,
28 "".join(
29 [
30 f"{self.prog['drgn_test_custom_list'].address_:x}\n",
31 *(
32 f"{entry.address_:x}\n"
33 for entry in self.prog["drgn_test_custom_list_entries"]
34 ),
35 ]
36 ),
37 )
38
39 self.assertIn('prog["drgn_test_custom_list"]', cmd.drgn_option.stdout)
40 self.assertIn("entry.next", cmd.drgn_option.stdout)
41 self.assertEqual(
42 cmd.drgn_option.globals["entry"].type_.type_name(),
43 "struct drgn_test_custom_list_entry *",
44 )
45
46 def test_end(self):
47 end = self.prog["drgn_test_custom_list_entries"][1].address_
48 cmd = self.check_crash_command(
49 f"list -o drgn_test_custom_list_entry.next -e {end:#x} drgn_test_custom_list"
50 )
51 self.assertEqual(
52 cmd.stdout,
53 "".join(
54 [
55 f"{self.prog['drgn_test_custom_list'].address_:x}\n",
56 *(
57 f"{entry.address_:x}\n"
58 for entry in self.prog["drgn_test_custom_list_entries"][:1]
59 ),
60 ]
61 ),
62 )
63
64 self.assertIn('prog["drgn_test_custom_list"]', cmd.drgn_option.stdout)
65 self.assertIn("entry.next", cmd.drgn_option.stdout)
66 self.assertIn(f"= {end:#x}", cmd.drgn_option.stdout)
67 self.assertEqual(
68 cmd.drgn_option.globals["entry"].type_.type_name(),
69 "struct drgn_test_custom_list_entry *",
70 )
71
72 def test_no_offset(self):
73 cmd = self.check_crash_command("list drgn_test_full_list")
74 self.assertEqual(
75 cmd.stdout,
76 "".join(
77 [
78 f"{self.prog['drgn_test_full_list'].address_:x}\n",
79 *(
80 f"{entry.node.address_:x}\n"
81 for entry in self.prog["drgn_test_list_entries"]
82 ),
83 ]
84 ),
85 )
86
87 self.assertIn(
88 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
89 )
90 self.assertIn("prog.read_word(ptr)", cmd.drgn_option.stdout)
91 self.assertIsInstance(cmd.drgn_option.globals["ptr"], int)
92
93 def test_integer_offset(self):
94 offset = offsetof(self.prog.type("struct drgn_test_custom_list_entry"), "next")
95 cmd = self.check_crash_command(f"list -o {offset} drgn_test_custom_list")
96 self.assertEqual(
97 cmd.stdout,
98 "".join(
99 [
100 f"{self.prog['drgn_test_custom_list'].address_:x}\n",
101 *(
102 f"{entry.address_:x}\n"
103 for entry in self.prog["drgn_test_custom_list_entries"]
104 ),
105 ]
106 ),
107 )
108
109 self.assertIn(
110 'prog.symbol("drgn_test_custom_list").address', cmd.drgn_option.stdout
111 )
112 self.assertIn("prog.read_word(ptr + next_offset)", cmd.drgn_option.stdout)
113 self.assertIsInstance(cmd.drgn_option.globals["ptr"], int)
114
115 def test_circular(self):
116 address = self.prog["drgn_test_custom_list_cycle"][2].address_
117 cmd = self.check_crash_command(
118 f"list -o drgn_test_custom_list_entry.next {address:#x}"
119 )
120 self.assertEqual(
121 cmd.stdout,
122 "".join(
123 [
124 f"{entry.address_:x}\n"
125 for entry in self.prog["drgn_test_custom_list_cycle"][2:]
126 ]
127 ),
128 )
129
130 self.assertIn(
131 f'Object(prog, "struct drgn_test_custom_list_entry *", {address:#x})',
132 cmd.drgn_option.stdout,
133 )
134 self.assertIn("entry.next", cmd.drgn_option.stdout)
135 self.assertEqual(
136 cmd.drgn_option.globals["entry"].type_.type_name(),
137 "struct drgn_test_custom_list_entry *",
138 )
139
140 def test_circular_next(self):
141 address = self.prog["drgn_test_custom_list_cycle"][1].address_
142 cmd = self.run_crash_command(
143 f"list -o drgn_test_custom_list_entry.next {address:#x}"
144 )
145 self.assertEqual(
146 cmd.stdout,
147 "".join(
148 [
149 f"{entry.address_:x}\n"
150 for entry in self.prog["drgn_test_custom_list_cycle"][1:]
151 ]
152 ),
153 )
154
155 def test_duplicate(self):
156 cmd = self.run_crash_command(
157 "list -o drgn_test_custom_list_entry.next drgn_test_custom_list_cycle"
158 )
159 expected_lines = [
160 f"{entry.address_:x}\n"
161 for entry in self.prog["drgn_test_custom_list_cycle"]
162 ]
163 expected_lines.append(expected_lines[2])
164 expected_lines.append("\nlist: duplicate list entry: " + expected_lines[-1])
165 self.assertEqual(cmd.stdout, "".join(expected_lines))
166
167 def test_self_cycle(self):
168 cmd = self.check_crash_command(
169 "list -o drgn_test_custom_list_entry.next drgn_test_custom_list_self_cycle"
170 )
171 self.assertEqual(
172 cmd.stdout,
173 "".join(
174 [
175 f"{entry.address_:x}\n"
176 for entry in self.prog["drgn_test_custom_list_self_cycle"]
177 ]
178 ),
179 )
180
181 # drgn_test_custom_list_self_cycle is an array, not a struct
182 # drgn_test_custom_list_entry, so --drgn falls back to a symbol lookup.
183 self.assertIn(
184 'prog.symbol("drgn_test_custom_list_self_cycle").address',
185 cmd.drgn_option.stdout,
186 )
187 self.assertIn("entry.next", cmd.drgn_option.stdout)
188 self.assertEqual(
189 cmd.drgn_option.globals["entry"].type_.type_name(),
190 "struct drgn_test_custom_list_entry *",
191 )
192
193 def test_struct(self):
194 cmd = self.check_crash_command(
195 "list -o drgn_test_custom_list_entry.next -s drgn_test_custom_list_entry drgn_test_custom_list"
196 )
197 regex = [r"^"]
198 for i, entry in enumerate(
199 [
200 self.prog["drgn_test_custom_list"],
201 *self.prog["drgn_test_custom_list_entries"],
202 ],
203 1,
204 ):
205 regex.append(
206 rf"{entry.address_:x}\n\(struct drgn_test_custom_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
207 )
208 regex.append("$")
209 self.assertRegex(cmd.stdout, "".join(regex))
210
211 self.assertIn('prog["drgn_test_custom_list"]', cmd.drgn_option.stdout)
212 self.assertIn("entry.next", cmd.drgn_option.stdout)
213 self.assertEqual(
214 cmd.drgn_option.globals["entry"].type_.type_name(),
215 "struct drgn_test_custom_list_entry *",
216 )
217
218 def test_struct_member(self):
219 cmd = self.check_crash_command(
220 "list -o drgn_test_custom_list_entry.next -s drgn_test_custom_list_entry.value drgn_test_custom_list"
221 )
222 regex = [r"^"]
223 for i, entry in enumerate(
224 [
225 self.prog["drgn_test_custom_list"],
226 *self.prog["drgn_test_custom_list_entries"],
227 ],
228 1,
229 ):
230 regex.append(rf"{entry.address_:x}\n\s*value = \(int\){i}\n")
231 regex.append("$")
232 self.assertRegex(cmd.stdout, "".join(regex))
233
234 self.assertIn('prog["drgn_test_custom_list"]', cmd.drgn_option.stdout)
235 self.assertIn("entry.next", cmd.drgn_option.stdout)
236 self.assertEqual(
237 cmd.drgn_option.globals["entry"].type_.type_name(),
238 "struct drgn_test_custom_list_entry *",
239 )
240 self.assertIsInstance(cmd.drgn_option.globals["value"], Object)
241
242 def test_struct_integer_offset(self):
243 offset = offsetof(self.prog.type("struct drgn_test_custom_list_entry"), "next")
244 cmd = self.check_crash_command(
245 f"list -o {offset} -s drgn_test_custom_list_entry drgn_test_custom_list"
246 )
247 regex = [r"^"]
248 for i, entry in enumerate(
249 [
250 self.prog["drgn_test_custom_list"],
251 *self.prog["drgn_test_custom_list_entries"],
252 ],
253 1,
254 ):
255 regex.append(
256 rf"{entry.address_:x}\n\(struct drgn_test_custom_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
257 )
258 regex.append("$")
259 self.assertRegex(cmd.stdout, "".join(regex))
260
261 self.assertIn(
262 'prog.symbol("drgn_test_custom_list").address', cmd.drgn_option.stdout
263 )
264 self.assertIn("prog.read_word(ptr + next_offset)", cmd.drgn_option.stdout)
265 self.assertEqual(
266 cmd.drgn_option.globals["entry"].type_.type_name(),
267 "struct drgn_test_custom_list_entry *",
268 )
269
270 def test_struct_member_integer_offset(self):
271 offset = offsetof(self.prog.type("struct drgn_test_custom_list_entry"), "next")
272 cmd = self.check_crash_command(
273 f"list -o {offset} -s drgn_test_custom_list_entry.value drgn_test_custom_list"
274 )
275 regex = [r"^"]
276 for i, entry in enumerate(
277 [
278 self.prog["drgn_test_custom_list"],
279 *self.prog["drgn_test_custom_list_entries"],
280 ],
281 1,
282 ):
283 regex.append(rf"{entry.address_:x}\n\s*value = \(int\){i}\n")
284 regex.append("$")
285 self.assertRegex(cmd.stdout, "".join(regex))
286
287 self.assertIn(
288 'prog.symbol("drgn_test_custom_list").address', cmd.drgn_option.stdout
289 )
290 self.assertIn("prog.read_word(ptr + next_offset)", cmd.drgn_option.stdout)
291 self.assertEqual(
292 cmd.drgn_option.globals["entry"].type_.type_name(),
293 "struct drgn_test_custom_list_entry *",
294 )
295 self.assertIsInstance(cmd.drgn_option.globals["value"], Object)
296
297 def test_list_head_empty(self):
298 cmd = self.run_crash_command("list -H drgn_test_empty_list")
299 self.assertEqual(cmd.stdout, "(empty)\n")
300
301 def test_list_head_full(self):
302 cmd = self.check_crash_command("list -H drgn_test_full_list")
303 self.assertEqual(
304 cmd.stdout,
305 "".join(
306 [
307 f"{entry.node.address_:x}\n"
308 for entry in self.prog["drgn_test_list_entries"]
309 ]
310 ),
311 )
312
313 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
314 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
315 self.assertEqual(
316 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
317 )
318
319 def test_list_head_address(self):
320 address = self.prog["drgn_test_full_list"].address_
321 cmd = self.check_crash_command(f"list -H {address:#x}")
322 self.assertEqual(
323 cmd.stdout,
324 "".join(
325 [
326 f"{entry.node.address_:x}\n"
327 for entry in self.prog["drgn_test_list_entries"]
328 ]
329 ),
330 )
331
332 self.assertIn(
333 f'Object(prog, "struct list_head *", {address:#x})', cmd.drgn_option.stdout
334 )
335 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
336 self.assertEqual(
337 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
338 )
339
340 def test_list_head_reverse(self):
341 cmd = self.check_crash_command("list -r -H drgn_test_full_list")
342 self.assertEqual(
343 cmd.stdout,
344 "".join(
345 [
346 f"{entry.node.address_:x}\n"
347 for entry in reversed(self.prog["drgn_test_list_entries"])
348 ]
349 ),
350 )
351
352 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
353 self.assertIn("list_for_each_reverse(", cmd.drgn_option.stdout)
354 self.assertEqual(
355 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
356 )
357
358 def test_list_head_cycle1(self):
359 cmd = self.run_crash_command("list -H drgn_test_list_cycle1")
360 self.assertEqual(
361 cmd.stdout,
362 "".join(
363 [
364 f"{entry.node.address_:x}\n"
365 for entry in self.prog["drgn_test_list_cycle1_entries"]
366 ]
367 ),
368 )
369
370 def test_list_head_cycle2(self):
371 cmd = self.run_crash_command("list -H drgn_test_list_cycle2")
372 self.assertEqual(
373 cmd.stdout,
374 "".join(
375 [
376 f"{entry.node.address_:x}\n"
377 for entry in self.prog["drgn_test_list_cycle2_entries"]
378 ]
379 ),
380 )
381
382 def test_list_head_cycle3(self):
383 cmd = self.run_crash_command("list -H drgn_test_list_cycle3")
384 expected_lines = [
385 f"{entry.node.address_:x}\n"
386 for entry in self.prog["drgn_test_list_cycle3_entries"]
387 ]
388 expected_lines.append(expected_lines[2])
389 expected_lines.append("\nlist: duplicate list entry: " + expected_lines[-1])
390 self.assertEqual(cmd.stdout, "".join(expected_lines))
391
392 def test_list_head_o(self):
393 cmd = self.check_crash_command(
394 "list -o drgn_test_list_entry.node -H drgn_test_full_list"
395 )
396 self.assertEqual(
397 cmd.stdout,
398 "".join(
399 [
400 f"{entry.address_:x}\n"
401 for entry in self.prog["drgn_test_list_entries"]
402 ]
403 ),
404 )
405
406 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
407 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
408 self.assertEqual(
409 cmd.drgn_option.globals["entry"].type_.type_name(),
410 "struct drgn_test_list_entry *",
411 )
412
413 def test_list_head_integer_offset(self):
414 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
415 cmd = self.check_crash_command(f"list -o {offset} -H drgn_test_full_list")
416 self.assertEqual(
417 cmd.stdout,
418 "".join(
419 [
420 f"{entry.address_:x}\n"
421 for entry in self.prog["drgn_test_list_entries"]
422 ]
423 ),
424 )
425
426 self.assertIn(
427 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
428 )
429 self.assertIn("prog.read_word(start)", cmd.drgn_option.stdout)
430 self.assertIn("entry_ptr = ptr - list_head_offset\n", cmd.drgn_option.stdout)
431 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
432 self.assertIn("while ptr != start:", cmd.drgn_option.stdout)
433 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
434
435 def test_list_head_reverse_integer_offset(self):
436 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
437 cmd = self.check_crash_command(f"list -o {offset} -r -H drgn_test_full_list")
438 self.assertEqual(
439 cmd.stdout,
440 "".join(
441 [
442 f"{entry.address_:x}\n"
443 for entry in reversed(self.prog["drgn_test_list_entries"])
444 ]
445 ),
446 )
447
448 self.assertIn(
449 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
450 )
451 self.assertIn("prog.read_word(start + prev_offset)", cmd.drgn_option.stdout)
452 self.assertIn("while ptr != start:", cmd.drgn_option.stdout)
453 self.assertNotIn("not prev_ptr", cmd.drgn_option.stdout)
454
455 def test_list_head_struct(self):
456 cmd = self.check_crash_command(
457 "list -s drgn_test_list_entry -l drgn_test_list_entry.node -H drgn_test_full_list"
458 )
459 regex = [r"^"]
460 for i, entry in enumerate(self.prog["drgn_test_list_entries"], 1):
461 regex.append(
462 rf"{entry.node.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
463 )
464 regex.append("$")
465 self.assertRegex(cmd.stdout, "".join(regex))
466
467 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
468 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
469 self.assertEqual(
470 cmd.drgn_option.globals["entry"].type_.type_name(),
471 "struct drgn_test_list_entry *",
472 )
473
474 def test_list_head_struct_integer_offset(self):
475 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
476 cmd = self.check_crash_command(
477 f"list -s drgn_test_list_entry -l {offset} -H drgn_test_full_list"
478 )
479 regex = [r"^"]
480 for i, entry in enumerate(self.prog["drgn_test_list_entries"], 1):
481 regex.append(
482 rf"{entry.node.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
483 )
484 regex.append("$")
485 self.assertRegex(cmd.stdout, "".join(regex))
486
487 self.assertIn(
488 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
489 )
490 self.assertIn("prog.read_word(start)", cmd.drgn_option.stdout)
491 self.assertIn(
492 'entry = Object(prog, "struct drgn_test_list_entry *", ptr - entry_offset)',
493 cmd.drgn_option.stdout,
494 )
495 self.assertIn("while ptr != start:", cmd.drgn_option.stdout)
496 self.assertEqual(cmd.drgn_option.globals["entry_offset"], offset)
497 self.assertEqual(
498 cmd.drgn_option.globals["entry"].type_.type_name(),
499 "struct drgn_test_list_entry *",
500 )
501
502 def test_list_head_struct_o(self):
503 cmd = self.check_crash_command(
504 "list -s drgn_test_list_entry -o drgn_test_list_entry.node -H drgn_test_full_list"
505 )
506 regex = [r"^"]
507 for i, entry in enumerate(self.prog["drgn_test_list_entries"], 1):
508 regex.append(
509 rf"{entry.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
510 )
511 regex.append("$")
512 self.assertRegex(cmd.stdout, "".join(regex))
513
514 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
515 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
516 self.assertEqual(
517 cmd.drgn_option.globals["entry"].type_.type_name(),
518 "struct drgn_test_list_entry *",
519 )
520
521 def test_list_head_struct_o_integer_offset(self):
522 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
523 cmd = self.check_crash_command(
524 f"list -s drgn_test_list_entry -o {offset} -H drgn_test_full_list"
525 )
526 regex = [r"^"]
527 for i, entry in enumerate(self.prog["drgn_test_list_entries"], 1):
528 regex.append(
529 rf"{entry.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
530 )
531 regex.append("$")
532 self.assertRegex(cmd.stdout, "".join(regex))
533
534 self.assertIn(
535 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
536 )
537 self.assertIn("prog.read_word(start)", cmd.drgn_option.stdout)
538 self.assertIn(
539 'entry = Object(prog, "struct drgn_test_list_entry *", ptr - list_head_offset)',
540 cmd.drgn_option.stdout,
541 )
542 self.assertIn("while ptr != start:", cmd.drgn_option.stdout)
543 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
544 self.assertEqual(
545 cmd.drgn_option.globals["entry"].type_.type_name(),
546 "struct drgn_test_list_entry *",
547 )
548
549 def test_list_head_struct_reverse(self):
550 cmd = self.check_crash_command(
551 "list -s drgn_test_list_entry -l drgn_test_list_entry.node -r -H drgn_test_full_list"
552 )
553 regex = [r"^"]
554 for i, entry in reversed(
555 list(enumerate(self.prog["drgn_test_list_entries"], 1))
556 ):
557 regex.append(
558 rf"{entry.node.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
559 )
560 regex.append("$")
561 self.assertRegex(cmd.stdout, "".join(regex))
562
563 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
564 self.assertIn("list_for_each_entry_reverse(", cmd.drgn_option.stdout)
565 self.assertEqual(
566 cmd.drgn_option.globals["entry"].type_.type_name(),
567 "struct drgn_test_list_entry *",
568 )
569
570 def test_list_head_struct_reverse_integer_offset(self):
571 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
572 cmd = self.check_crash_command(
573 f"list -s drgn_test_list_entry -l {offset} -r -H drgn_test_full_list"
574 )
575 regex = [r"^"]
576 for i, entry in reversed(
577 list(enumerate(self.prog["drgn_test_list_entries"], 1))
578 ):
579 regex.append(
580 rf"{entry.node.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
581 )
582 regex.append("$")
583 self.assertRegex(cmd.stdout, "".join(regex))
584
585 self.assertIn(
586 'prog.symbol("drgn_test_full_list").address', cmd.drgn_option.stdout
587 )
588 self.assertIn("prog.read_word(start + prev_offset)", cmd.drgn_option.stdout)
589 self.assertIn(
590 'entry = Object(prog, "struct drgn_test_list_entry *", ptr - entry_offset)',
591 cmd.drgn_option.stdout,
592 )
593 self.assertIn("while ptr != start:", cmd.drgn_option.stdout)
594 self.assertEqual(cmd.drgn_option.globals["entry_offset"], offset)
595 self.assertEqual(
596 cmd.drgn_option.globals["entry"].type_.type_name(),
597 "struct drgn_test_list_entry *",
598 )
599
600 def test_embedded_list_head(self):
601 cmd = self.check_crash_command("list -h drgn_test_full_list")
602 self.assertEqual(
603 cmd.stdout,
604 "".join(
605 [
606 f"{self.prog['drgn_test_full_list'].address_:x}\n",
607 *(
608 f"{entry.node.address_:x}\n"
609 for entry in self.prog["drgn_test_list_entries"]
610 ),
611 ]
612 ),
613 )
614
615 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
616 self.assertIn("node = node.next", cmd.drgn_option.stdout)
617 self.assertEqual(
618 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
619 )
620
621 def test_embedded_list_head_address(self):
622 address = self.prog["drgn_test_full_list"].address_
623 cmd = self.check_crash_command(f"list -h {address:#x}")
624 self.assertEqual(
625 cmd.stdout,
626 "".join(
627 [
628 f"{self.prog['drgn_test_full_list'].address_:x}\n",
629 *(
630 f"{entry.node.address_:x}\n"
631 for entry in self.prog["drgn_test_list_entries"]
632 ),
633 ]
634 ),
635 )
636
637 self.assertIn(
638 f'Object(prog, "struct list_head *", {address:#x})', cmd.drgn_option.stdout
639 )
640 self.assertIn("node = node.next", cmd.drgn_option.stdout)
641 self.assertEqual(
642 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
643 )
644
645 def test_embedded_list_head_o(self):
646 cmd = self.check_crash_command(
647 "list -o drgn_test_list_entry.node -h drgn_test_circular_list"
648 )
649 self.assertEqual(
650 cmd.stdout,
651 "".join(
652 [
653 f"{self.prog['drgn_test_circular_list'].address_:x}\n",
654 *(
655 f"{entry.address_:x}\n"
656 for entry in self.prog["drgn_test_circular_list_entries"]
657 ),
658 ]
659 ),
660 )
661
662 self.assertIn('prog["drgn_test_circular_list"]', cmd.drgn_option.stdout)
663 self.assertIn("entry = list_next_entry(", cmd.drgn_option.stdout)
664 self.assertEqual(
665 cmd.drgn_option.globals["entry"].type_.type_name(),
666 "struct drgn_test_list_entry *",
667 )
668
669 def test_embedded_list_head_integer_offset(self):
670 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
671 cmd = self.check_crash_command(f"list -o {offset} -h drgn_test_circular_list")
672 self.assertEqual(
673 cmd.stdout,
674 "".join(
675 [
676 f"{self.prog['drgn_test_circular_list'].address_:x}\n",
677 *(
678 f"{entry.address_:x}\n"
679 for entry in self.prog["drgn_test_circular_list_entries"]
680 ),
681 ]
682 ),
683 )
684
685 self.assertIn(
686 'prog.symbol("drgn_test_circular_list").address', cmd.drgn_option.stdout
687 )
688 self.assertIn("entry_ptr = ptr - list_head_offset\n", cmd.drgn_option.stdout)
689 self.assertIn("prog.read_word(ptr)", cmd.drgn_option.stdout)
690 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
691
692 def test_embedded_list_head_address_o(self):
693 address = self.prog["drgn_test_circular_list"].address_
694 cmd = self.check_crash_command(
695 f"list -o drgn_test_list_entry.node -h {address:#x}"
696 )
697 self.assertEqual(
698 cmd.stdout,
699 "".join(
700 [
701 f"{self.prog['drgn_test_circular_list'].address_:x}\n",
702 *(
703 f"{entry.address_:x}\n"
704 for entry in self.prog["drgn_test_circular_list_entries"]
705 ),
706 ]
707 ),
708 )
709
710 self.assertIn(
711 f'Object(prog, "struct drgn_test_list_entry *", {address:#x})',
712 cmd.drgn_option.stdout,
713 )
714 self.assertIn("entry = list_next_entry(", cmd.drgn_option.stdout)
715 self.assertEqual(
716 cmd.drgn_option.globals["entry"].type_.type_name(),
717 "struct drgn_test_list_entry *",
718 )
719
720 def test_embedded_list_head_reverse(self):
721 for h in ("-h ", ""):
722 with self.subTest("explicit" if h else "implicit"):
723 cmd = self.check_crash_command(f"list -r {h}drgn_test_full_list")
724 self.assertEqual(
725 cmd.stdout,
726 "".join(
727 [
728 f"{self.prog['drgn_test_full_list'].address_:x}\n",
729 *(
730 f"{entry.node.address_:x}\n"
731 for entry in reversed(
732 self.prog["drgn_test_list_entries"]
733 )
734 ),
735 ]
736 ),
737 )
738
739 self.assertIn('prog["drgn_test_full_list"]', cmd.drgn_option.stdout)
740 self.assertIn("node = node.prev", cmd.drgn_option.stdout)
741 self.assertEqual(
742 cmd.drgn_option.globals["node"].type_.type_name(),
743 "struct list_head *",
744 )
745
746 def test_embedded_list_head_reverse_o(self):
747 cmd = self.check_crash_command(
748 "list -o drgn_test_list_entry.node -r -h drgn_test_circular_list"
749 )
750 self.assertEqual(
751 cmd.stdout,
752 "".join(
753 [
754 f"{self.prog['drgn_test_circular_list'].address_:x}\n",
755 *(
756 f"{entry.address_:x}\n"
757 for entry in reversed(
758 self.prog["drgn_test_circular_list_entries"]
759 )
760 ),
761 ]
762 ),
763 )
764
765 self.assertIn('prog["drgn_test_circular_list"]', cmd.drgn_option.stdout)
766 self.assertIn("entry = list_prev_entry(", cmd.drgn_option.stdout)
767 self.assertEqual(
768 cmd.drgn_option.globals["entry"].type_.type_name(),
769 "struct drgn_test_list_entry *",
770 )
771
772 def test_embedded_list_head_reverse_integer_offset(self):
773 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
774 cmd = self.check_crash_command(
775 f"list -o {offset} -r -h drgn_test_circular_list"
776 )
777 self.assertEqual(
778 cmd.stdout,
779 "".join(
780 [
781 f"{self.prog['drgn_test_circular_list'].address_:x}\n",
782 *(
783 f"{entry.address_:x}\n"
784 for entry in reversed(
785 self.prog["drgn_test_circular_list_entries"]
786 )
787 ),
788 ]
789 ),
790 )
791
792 self.assertIn(
793 'prog.symbol("drgn_test_circular_list").address', cmd.drgn_option.stdout
794 )
795 self.assertIn("entry_ptr = ptr - list_head_offset\n", cmd.drgn_option.stdout)
796 self.assertIn("prog.read_word(ptr + prev_offset)", cmd.drgn_option.stdout)
797 self.assertNotIn("not prev_ptr", cmd.drgn_option.stdout)
798
799 def test_embedded_list_head_struct(self):
800 cmd = self.check_crash_command(
801 "list -o drgn_test_list_entry.node -s drgn_test_list_entry -h drgn_test_circular_list"
802 )
803 regex = [r"^"]
804 for i, entry in enumerate(
805 [
806 self.prog["drgn_test_circular_list"],
807 *self.prog["drgn_test_circular_list_entries"],
808 ],
809 1,
810 ):
811 regex.append(
812 rf"{entry.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
813 )
814 regex.append("$")
815 self.assertRegex(cmd.stdout, "".join(regex))
816
817 self.assertIn('prog["drgn_test_circular_list"]', cmd.drgn_option.stdout)
818 self.assertIn("entry = list_next_entry(", cmd.drgn_option.stdout)
819 self.assertEqual(
820 cmd.drgn_option.globals["entry"].type_.type_name(),
821 "struct drgn_test_list_entry *",
822 )
823
824 def test_embedded_list_head_member(self):
825 cmd = self.check_crash_command(
826 "list -o drgn_test_list_entry.node -s drgn_test_list_entry.value -h drgn_test_circular_list"
827 )
828 regex = [r"^"]
829 for i, entry in enumerate(
830 [
831 self.prog["drgn_test_circular_list"],
832 *self.prog["drgn_test_circular_list_entries"],
833 ],
834 1,
835 ):
836 regex.append(rf"{entry.address_:x}\n\s*value = \(int\){i}\n")
837 regex.append("$")
838 self.assertRegex(cmd.stdout, "".join(regex))
839
840 self.assertIn('prog["drgn_test_circular_list"]', cmd.drgn_option.stdout)
841 self.assertIn("entry = list_next_entry(", cmd.drgn_option.stdout)
842 self.assertEqual(
843 cmd.drgn_option.globals["entry"].type_.type_name(),
844 "struct drgn_test_list_entry *",
845 )
846 self.assertIsInstance(cmd.drgn_option.globals["value"], Object)
847
848 def test_embedded_list_head_struct_integer_offset(self):
849 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
850 cmd = self.check_crash_command(
851 f"list -o {offset} -s drgn_test_list_entry -h drgn_test_circular_list"
852 )
853 regex = [r"^"]
854 for i, entry in enumerate(
855 [
856 self.prog["drgn_test_circular_list"],
857 *self.prog["drgn_test_circular_list_entries"],
858 ],
859 1,
860 ):
861 regex.append(
862 rf"{entry.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
863 )
864 regex.append("$")
865 self.assertRegex(cmd.stdout, "".join(regex))
866
867 self.assertIn(
868 'prog.symbol("drgn_test_circular_list").address', cmd.drgn_option.stdout
869 )
870 self.assertIn(
871 'entry = Object(prog, "struct drgn_test_list_entry *", ptr - list_head_offset)',
872 cmd.drgn_option.stdout,
873 )
874 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
875 self.assertIn("prog.read_word(ptr)", cmd.drgn_option.stdout)
876 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
877 self.assertEqual(
878 cmd.drgn_option.globals["entry"].type_.type_name(),
879 "struct drgn_test_list_entry *",
880 )
881
882 def test_embedded_list_head_member_integer_offset(self):
883 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
884 cmd = self.check_crash_command(
885 f"list -o {offset} -s drgn_test_list_entry.value -h drgn_test_circular_list"
886 )
887 regex = [r"^"]
888 for i, entry in enumerate(
889 [
890 self.prog["drgn_test_circular_list"],
891 *self.prog["drgn_test_circular_list_entries"],
892 ],
893 1,
894 ):
895 regex.append(rf"{entry.address_:x}\n\s*value = \(int\){i}\n")
896 regex.append("$")
897 self.assertRegex(cmd.stdout, "".join(regex))
898
899 self.assertIn(
900 'prog.symbol("drgn_test_circular_list").address', cmd.drgn_option.stdout
901 )
902 self.assertIn(
903 'entry = Object(prog, "struct drgn_test_list_entry *", ptr - list_head_offset)',
904 cmd.drgn_option.stdout,
905 )
906 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
907 self.assertIn("prog.read_word(ptr)", cmd.drgn_option.stdout)
908 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
909 self.assertEqual(
910 cmd.drgn_option.globals["entry"].type_.type_name(),
911 "struct drgn_test_list_entry *",
912 )
913 self.assertIsInstance(cmd.drgn_option.globals["value"], Object)
914
915 def test_head_node_offset(self):
916 cmd = self.check_crash_command(
917 "list -O drgn_test_list_anchor.list -h drgn_test_anchored_list"
918 )
919 self.assertEqual(
920 cmd.stdout,
921 "".join(
922 [
923 f"{entry.node.address_:x}\n"
924 for entry in self.prog["drgn_test_anchored_list_entries"]
925 ]
926 ),
927 )
928
929 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
930 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
931 self.assertEqual(
932 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
933 )
934
935 def test_head_node_integer_offset(self):
936 offset = offsetof(self.prog.type("struct drgn_test_list_anchor"), "list")
937 cmd = self.check_crash_command(f"list -O {offset} -h drgn_test_anchored_list")
938 self.assertEqual(
939 cmd.stdout,
940 "".join(
941 [
942 f"{entry.node.address_:x}\n"
943 for entry in self.prog["drgn_test_anchored_list_entries"]
944 ]
945 ),
946 )
947
948 self.assertIn(
949 'prog.symbol("drgn_test_anchored_list").address', cmd.drgn_option.stdout
950 )
951 self.assertEqual(cmd.drgn_option.globals["offset"], offset)
952 self.assertIn(
953 'Object(prog, "struct list_head *", address + offset)',
954 cmd.drgn_option.stdout,
955 )
956 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
957 self.assertEqual(
958 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
959 )
960
961 def test_head_node_offset_address(self):
962 address = self.prog["drgn_test_anchored_list"].address_
963 cmd = self.check_crash_command(
964 f"list -O drgn_test_list_anchor.list -h {address:#x}"
965 )
966 self.assertEqual(
967 cmd.stdout,
968 "".join(
969 [
970 f"{entry.node.address_:x}\n"
971 for entry in self.prog["drgn_test_anchored_list_entries"]
972 ]
973 ),
974 )
975
976 self.assertIn(
977 f'Object(prog, "struct drgn_test_list_anchor", address={address:#x}).list',
978 cmd.drgn_option.stdout,
979 )
980 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
981 self.assertEqual(
982 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
983 )
984
985 def test_head_node_integer_offset_address(self):
986 offset = offsetof(self.prog.type("struct drgn_test_list_anchor"), "list")
987 address = self.prog["drgn_test_anchored_list"].address_
988 cmd = self.check_crash_command(f"list -O {offset} -h {address:#x}")
989 self.assertEqual(
990 cmd.stdout,
991 "".join(
992 [
993 f"{entry.node.address_:x}\n"
994 for entry in self.prog["drgn_test_anchored_list_entries"]
995 ]
996 ),
997 )
998
999 self.assertEqual(cmd.drgn_option.globals["offset"], offset)
1000 self.assertIn(
1001 f'Object(prog, "struct list_head *", {address:#x} + offset)',
1002 cmd.drgn_option.stdout,
1003 )
1004 self.assertIn("list_for_each(", cmd.drgn_option.stdout)
1005 self.assertEqual(
1006 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
1007 )
1008
1009 def test_head_node_offset_o(self):
1010 cmd = self.check_crash_command(
1011 "list -o drgn_test_list_entry.node -O drgn_test_list_anchor.list -h drgn_test_anchored_list"
1012 )
1013 self.assertEqual(
1014 cmd.stdout,
1015 "".join(
1016 [
1017 f"{entry.address_:x}\n"
1018 for entry in self.prog["drgn_test_anchored_list_entries"]
1019 ]
1020 ),
1021 )
1022
1023 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
1024 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
1025 self.assertEqual(
1026 cmd.drgn_option.globals["entry"].type_.type_name(),
1027 "struct drgn_test_list_entry *",
1028 )
1029
1030 def test_head_node_offset_and_integer_o(self):
1031 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
1032 cmd = self.check_crash_command(
1033 f"list -o {offset} -O drgn_test_list_anchor.list -h drgn_test_anchored_list"
1034 )
1035 self.assertEqual(
1036 cmd.stdout,
1037 "".join(
1038 [
1039 f"{entry.address_:x}\n"
1040 for entry in self.prog["drgn_test_anchored_list_entries"]
1041 ]
1042 ),
1043 )
1044
1045 self.assertIn(
1046 'prog.symbol("drgn_test_anchored_list").address', cmd.drgn_option.stdout
1047 )
1048 self.assertIn(
1049 'start += offsetof("struct drgn_test_list_anchor", "list")',
1050 cmd.drgn_option.stdout,
1051 )
1052 self.assertIn("prog.read_word(start)", cmd.drgn_option.stdout)
1053 self.assertIn("entry_ptr = ptr - list_head_offset\n", cmd.drgn_option.stdout)
1054 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
1055 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
1056
1057 def test_head_node_integer_offset_and_integer_o(self):
1058 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
1059 head_node_offset = offsetof(
1060 self.prog.type("struct drgn_test_list_anchor"), "list"
1061 )
1062 cmd = self.check_crash_command(
1063 f"list -o {offset} -O {head_node_offset} -h drgn_test_anchored_list"
1064 )
1065 self.assertEqual(
1066 cmd.stdout,
1067 "".join(
1068 [
1069 f"{entry.address_:x}\n"
1070 for entry in self.prog["drgn_test_anchored_list_entries"]
1071 ]
1072 ),
1073 )
1074
1075 self.assertIn(
1076 'prog.symbol("drgn_test_anchored_list").address', cmd.drgn_option.stdout
1077 )
1078 self.assertIn(f"start += {head_node_offset}", cmd.drgn_option.stdout)
1079 self.assertIn("prog.read_word(start)", cmd.drgn_option.stdout)
1080 self.assertIn("entry_ptr = ptr - list_head_offset\n", cmd.drgn_option.stdout)
1081 self.assertEqual(cmd.drgn_option.globals["list_head_offset"], offset)
1082 self.assertNotIn("not next_ptr", cmd.drgn_option.stdout)
1083
1084 def test_head_node_offset_struct(self):
1085 cmd = self.check_crash_command(
1086 "list -l drgn_test_list_entry.node -s drgn_test_list_entry -O drgn_test_list_anchor.list -h drgn_test_anchored_list"
1087 )
1088 regex = [r"^"]
1089 for i, entry in enumerate(self.prog["drgn_test_anchored_list_entries"], 1):
1090 regex.append(
1091 rf"{entry.node.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
1092 )
1093 regex.append("$")
1094 self.assertRegex(cmd.stdout, "".join(regex))
1095
1096 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
1097 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
1098 self.assertEqual(
1099 cmd.drgn_option.globals["entry"].type_.type_name(),
1100 "struct drgn_test_list_entry *",
1101 )
1102
1103 def test_head_node_offset_struct_o(self):
1104 cmd = self.check_crash_command(
1105 "list -o drgn_test_list_entry.node -s drgn_test_list_entry -O drgn_test_list_anchor.list -h drgn_test_anchored_list"
1106 )
1107 regex = [r"^"]
1108 for i, entry in enumerate(self.prog["drgn_test_anchored_list_entries"], 1):
1109 regex.append(
1110 rf"{entry.address_:x}\n\(struct drgn_test_list_entry\)(?s:.)*\.value = \(int\){i},(?s:.)*"
1111 )
1112 regex.append("$")
1113 self.assertRegex(cmd.stdout, "".join(regex))
1114
1115 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
1116 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
1117 self.assertEqual(
1118 cmd.drgn_option.globals["entry"].type_.type_name(),
1119 "struct drgn_test_list_entry *",
1120 )
1121
1122 def test_head_node_offset_reverse(self):
1123 cmd = self.check_crash_command(
1124 "list -O drgn_test_list_anchor.list -r -h drgn_test_anchored_list"
1125 )
1126 self.assertEqual(
1127 cmd.stdout,
1128 "".join(
1129 [
1130 f"{entry.node.address_:x}\n"
1131 for entry in reversed(self.prog["drgn_test_anchored_list_entries"])
1132 ]
1133 ),
1134 )
1135
1136 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
1137 self.assertIn("list_for_each_reverse(", cmd.drgn_option.stdout)
1138 self.assertEqual(
1139 cmd.drgn_option.globals["node"].type_.type_name(), "struct list_head *"
1140 )
1141
1142 def test_head_node_offset_reverse_o(self):
1143 cmd = self.check_crash_command(
1144 "list -o drgn_test_list_entry.node -O drgn_test_list_anchor.list -r -h drgn_test_anchored_list"
1145 )
1146 self.assertEqual(
1147 cmd.stdout,
1148 "".join(
1149 [
1150 f"{entry.address_:x}\n"
1151 for entry in reversed(self.prog["drgn_test_anchored_list_entries"])
1152 ]
1153 ),
1154 )
1155
1156 self.assertIn('prog["drgn_test_anchored_list"].list', cmd.drgn_option.stdout)
1157 self.assertIn("list_for_each_entry_reverse(", cmd.drgn_option.stdout)
1158 self.assertEqual(
1159 cmd.drgn_option.globals["entry"].type_.type_name(),
1160 "struct drgn_test_list_entry *",
1161 )
1162
1163
1164 class TestFindTreeType(TestCase):
1165 def test_full(self):
1166 self.assertEqual(_find_tree_type("rbtree"), "rbtree")
1167 self.assertEqual(_find_tree_type("radix"), "radix")
1168 self.assertEqual(_find_tree_type("xarray"), "xarray")
1169 self.assertEqual(_find_tree_type("maple"), "maple")
1170
1171 def test_abbreviated(self):
1172 for expected, abbreviations in (
1173 ("rbtree", ("rb", "rbt", "rbtr", "rbtre")),
1174 ("radix", ("ra", "rad", "radi")),
1175 ("xarray", ("x", "xa", "xar", "xarr", "xarra")),
1176 ("maple", ("m", "ma", "map", "mapl")),
1177 ):
1178 for abbreviation in abbreviations:
1179 with self.subTest(abbreviation=abbreviation):
1180 self.assertEqual(_find_tree_type(abbreviation), expected)
1181
1182 def test_ambiguous(self):
1183 self.assertRaises(CommandArgumentError, _find_tree_type, "r")
1184
1185 def test_unknown(self):
1186 self.assertRaises(CommandArgumentError, _find_tree_type, "z")
1187
1188
1189 @skip_unless_have_test_kmod
1190 class TestTree(CrashCommandTestCase):
1191 def test_rbtree(self):
1192 cmd = self.check_crash_command("tree drgn_test_rb_root")
1193 self.assertEqual(
1194 cmd.stdout,
1195 "".join(
1196 [
1197 f"{node.value_():x}\n"
1198 for node in rbtree_preorder_for_each(
1199 self.prog["drgn_test_rb_root"].address_of_()
1200 )
1201 ]
1202 ),
1203 )
1204 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1205 self.assertIn("rbtree_preorder_for_each(", cmd.drgn_option.stdout)
1206 self.assertNotIn("rbtree_inorder_for_each", cmd.drgn_option.stdout)
1207 self.assertEqual(
1208 cmd.drgn_option.globals["root"],
1209 self.prog["drgn_test_rb_root"].address_of_(),
1210 )
1211 self.assertEqual(
1212 cmd.drgn_option.globals["node"].type_.type_name(), "struct rb_node *"
1213 )
1214
1215 with self.subTest("explicit type"):
1216 explicit_cmd = self.check_crash_command("tree -t rbtree drgn_test_rb_root")
1217 self.assertEqual(explicit_cmd.stdout, cmd.stdout)
1218 self.assertEqual(explicit_cmd.drgn_option.stdout, cmd.drgn_option.stdout)
1219
1220 def test_rbtree_linear(self):
1221 cmd = self.check_crash_command("tree -l drgn_test_rb_root")
1222 self.assertEqual(
1223 cmd.stdout,
1224 "".join(
1225 [
1226 f"{node.value_():x}\n"
1227 for node in rbtree_inorder_for_each(
1228 self.prog["drgn_test_rb_root"].address_of_()
1229 )
1230 ]
1231 ),
1232 )
1233 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1234 self.assertIn("rbtree_inorder_for_each(", cmd.drgn_option.stdout)
1235 self.assertNotIn("rbtree_preorder_for_each", cmd.drgn_option.stdout)
1236 self.assertEqual(
1237 cmd.drgn_option.globals["root"],
1238 self.prog["drgn_test_rb_root"].address_of_(),
1239 )
1240 self.assertEqual(
1241 cmd.drgn_option.globals["node"].type_.type_name(), "struct rb_node *"
1242 )
1243
1244 def test_rbtree_node_member(self):
1245 cmd = self.check_crash_command(
1246 "tree -o drgn_test_rb_entry.node drgn_test_rb_root"
1247 )
1248 self.assertEqual(
1249 cmd.stdout,
1250 "".join(
1251 [
1252 f"{entry.value_():x}\n"
1253 for entry in rbtree_preorder_for_each_entry(
1254 "struct drgn_test_rb_entry",
1255 self.prog["drgn_test_rb_root"].address_of_(),
1256 "node",
1257 )
1258 ]
1259 ),
1260 )
1261 self.assertIn("rbtree_preorder_for_each_entry(", cmd.drgn_option.stdout)
1262 self.assertEqual(
1263 cmd.drgn_option.globals["entry"].type_.type_name(),
1264 "struct drgn_test_rb_entry *",
1265 )
1266
1267 def test_rbtree_node_member_linear(self):
1268 cmd = self.check_crash_command(
1269 "tree -l -o drgn_test_rb_entry.node drgn_test_rb_root"
1270 )
1271 self.assertEqual(
1272 cmd.stdout,
1273 "".join(
1274 [
1275 f"{entry.value_():x}\n"
1276 for entry in rbtree_inorder_for_each_entry(
1277 "struct drgn_test_rb_entry",
1278 self.prog["drgn_test_rb_root"].address_of_(),
1279 "node",
1280 )
1281 ]
1282 ),
1283 )
1284 self.assertIn("rbtree_inorder_for_each_entry(", cmd.drgn_option.stdout)
1285 self.assertEqual(
1286 cmd.drgn_option.globals["entry"].type_.type_name(),
1287 "struct drgn_test_rb_entry *",
1288 )
1289
1290 def test_rbtree_node_offset(self):
1291 offset = offsetof(self.prog.type("struct drgn_test_rb_entry"), "node")
1292 cmd = self.check_crash_command(f"tree -o {offset} drgn_test_rb_root")
1293 self.assertEqual(
1294 cmd.stdout,
1295 "".join(
1296 [
1297 f"{entry.value_():x}\n"
1298 for entry in rbtree_preorder_for_each_entry(
1299 "struct drgn_test_rb_entry",
1300 self.prog["drgn_test_rb_root"].address_of_(),
1301 "node",
1302 )
1303 ]
1304 ),
1305 )
1306 self.assertIn("rbtree_preorder_for_each(", cmd.drgn_option.stdout)
1307 self.assertIn(f"- {offset}", cmd.drgn_option.stdout)
1308 self.assertEqual(cmd.drgn_option.globals["entry"].type_.type_name(), "void *")
1309 self.assertEqual(
1310 cmd.drgn_option.globals["node"].value_(),
1311 cmd.drgn_option.globals["entry"].value_() + offset,
1312 )
1313
1314 def test_rbtree_entry_type(self):
1315 cmd = self.check_crash_command("tree -s drgn_test_rb_entry drgn_test_rb_root")
1316 for node in rbtree_preorder_for_each(
1317 self.prog["drgn_test_rb_root"].address_of_()
1318 ):
1319 self.assertRegex(cmd.stdout, rf"(?m)^{node.value_():x}$")
1320 self.assertIn("(struct drgn_test_rb_entry){", cmd.stdout)
1321 self.assertEqual(
1322 cmd.drgn_option.globals["entry"].type_.type_name(),
1323 "struct drgn_test_rb_entry *",
1324 )
1325
1326 def test_rbtree_entry_type_and_node_member(self):
1327 cmd = self.check_crash_command(
1328 "tree -l -s drgn_test_rb_entry -o drgn_test_rb_entry.node drgn_test_rb_root"
1329 )
1330 self.assertEqual(
1331 re.findall(r"\.value = \(int\)[0-9]+", cmd.stdout),
1332 [f".value = (int){i}" for i in range(4)],
1333 )
1334 self.assertIn("(struct drgn_test_rb_entry){", cmd.stdout)
1335 self.assertIn("rbtree_inorder_for_each_entry(", cmd.drgn_option.stdout)
1336 self.assertNotIn("cast(", cmd.drgn_option.stdout)
1337 self.assertEqual(
1338 cmd.drgn_option.globals["entry"].type_.type_name(),
1339 "struct drgn_test_rb_entry *",
1340 )
1341 self.assertEqual(cmd.drgn_option.globals["entry"].value, 3)
1342
1343 def test_rbtree_entry_type_and_node_offset(self):
1344 offset = offsetof(self.prog.type("struct drgn_test_rb_entry"), "node")
1345 cmd = self.check_crash_command(
1346 f"tree -l -s drgn_test_rb_entry -o {offset} drgn_test_rb_root"
1347 )
1348 self.assertEqual(
1349 re.findall(r"\.value = \(int\)[0-9]+", cmd.stdout),
1350 [f".value = (int){i}" for i in range(4)],
1351 )
1352 self.assertIn("(struct drgn_test_rb_entry){", cmd.stdout)
1353 self.assertIn(f"- {offset}", cmd.drgn_option.stdout)
1354 self.assertEqual(
1355 cmd.drgn_option.globals["entry"].type_.type_name(),
1356 "struct drgn_test_rb_entry *",
1357 )
1358 self.assertEqual(cmd.drgn_option.globals["entry"].value, 3)
1359
1360 def test_rbtree_members(self):
1361 cmd = self.check_crash_command(
1362 "tree -l -s drgn_test_rb_entry.value -o drgn_test_rb_entry.node drgn_test_rb_root"
1363 )
1364 self.assertEqual(
1365 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1366 [f"value = (int){i}" for i in range(4)],
1367 )
1368 self.assertEqual(
1369 cmd.drgn_option.globals["entry"].type_.type_name(),
1370 "struct drgn_test_rb_entry *",
1371 )
1372 self.assertIdentical(
1373 cmd.drgn_option.globals["value"].read_(), Object(self.prog, "int", 3)
1374 )
1375
1376 def test_rbtree_wrong_entry_type(self):
1377 cmd = self.check_crash_command(
1378 "tree -l -s list_head -o drgn_test_rb_entry.node drgn_test_rb_root"
1379 )
1380 self.assertIn("(struct list_head){", cmd.stdout)
1381 self.assertIn("rbtree_inorder_for_each_entry(", cmd.drgn_option.stdout)
1382 self.assertEqual(
1383 cmd.drgn_option.globals["entry"].type_.type_name(), "struct list_head *"
1384 )
1385
1386 def test_rbtree_start_address(self):
1387 address = self.prog["drgn_test_rb_root"].address_
1388 cmd = self.check_crash_command(f"tree {hex(address)}")
1389 self.assertEqual(
1390 cmd.stdout,
1391 "".join(
1392 [
1393 f"{node.value_():x}\n"
1394 for node in rbtree_preorder_for_each(
1395 self.prog["drgn_test_rb_root"].address_of_()
1396 )
1397 ]
1398 ),
1399 )
1400 self.assertIn("Object(", cmd.drgn_option.stdout)
1401
1402 def test_rbtree_root_member(self):
1403 cmd = self.check_crash_command(
1404 "tree -l -s drgn_test_rb_entry.value -o drgn_test_rb_entry.node -r drgn_test_rbtree_container_struct.root drgn_test_rbtree_container"
1405 )
1406 self.assertEqual(
1407 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1408 [f"value = (int){i}" for i in range(2)],
1409 )
1410 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1411 self.assertIn("].root", cmd.drgn_option.stdout)
1412 self.assertIdentical(
1413 cmd.drgn_option.globals["root"],
1414 self.prog["drgn_test_rbtree_container"].root.address_of_(),
1415 )
1416 self.assertIdentical(
1417 cmd.drgn_option.globals["value"],
1418 self.prog["drgn_test_rbtree_container"].entries[1].value,
1419 )
1420
1421 def test_rbtree_root_offset(self):
1422 offset = offsetof(
1423 self.prog.type("struct drgn_test_rbtree_container_struct"), "root"
1424 )
1425 cmd = self.check_crash_command(
1426 f"tree -l -s drgn_test_rb_entry.value -o drgn_test_rb_entry.node -r {offset} drgn_test_rbtree_container"
1427 )
1428 self.assertEqual(
1429 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1430 [f"value = (int){i}" for i in range(2)],
1431 )
1432 self.assertIn(f"+ {offset}", cmd.drgn_option.stdout)
1433 self.assertIdentical(
1434 cmd.drgn_option.globals["root"],
1435 self.prog["drgn_test_rbtree_container"].root.address_of_(),
1436 )
1437 self.assertIdentical(
1438 cmd.drgn_option.globals["value"],
1439 self.prog["drgn_test_rbtree_container"].entries[1].value,
1440 )
1441
1442 def test_rbtree_root_member_start_address(self):
1443 address = self.prog["drgn_test_rbtree_container"].address_
1444 cmd = self.check_crash_command(
1445 f"tree -l -s drgn_test_rb_entry.value -o drgn_test_rb_entry.node -r drgn_test_rbtree_container_struct.root {hex(address)}"
1446 )
1447 self.assertEqual(
1448 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1449 [f"value = (int){i}" for i in range(2)],
1450 )
1451 self.assertIn("Object(", cmd.drgn_option.stdout)
1452 self.assertIn("+= offsetof(", cmd.drgn_option.stdout)
1453 self.assertIdentical(
1454 cmd.drgn_option.globals["root"],
1455 self.prog["drgn_test_rbtree_container"].root.address_of_(),
1456 )
1457 self.assertIdentical(
1458 cmd.drgn_option.globals["value"],
1459 self.prog["drgn_test_rbtree_container"].entries[1].value,
1460 )
1461
1462 def test_rbtree_root_offset_start_address(self):
1463 address = self.prog["drgn_test_rbtree_container"].address_
1464 offset = offsetof(
1465 self.prog.type("struct drgn_test_rbtree_container_struct"), "root"
1466 )
1467 cmd = self.check_crash_command(
1468 f"tree -l -s drgn_test_rb_entry.value -o drgn_test_rb_entry.node -r {offset} {hex(address)}"
1469 )
1470 self.assertEqual(
1471 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1472 [f"value = (int){i}" for i in range(2)],
1473 )
1474 self.assertIn(f"+ {offset}", cmd.drgn_option.stdout)
1475 self.assertIdentical(
1476 cmd.drgn_option.globals["root"],
1477 self.prog["drgn_test_rbtree_container"].root.address_of_(),
1478 )
1479 self.assertIdentical(
1480 cmd.drgn_option.globals["value"],
1481 self.prog["drgn_test_rbtree_container"].entries[1].value,
1482 )
1483
1484 def test_radix(self):
1485 cmd = self.check_crash_command("tree -t radix drgn_test_radix_tree_sparse")
1486 self.assertEqual(
1487 cmd.stdout,
1488 """\
1489 1234
1490 5678
1491 9abc
1492 """,
1493 )
1494 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1495 self.assertIn("radix_tree_for_each(", cmd.drgn_option.stdout)
1496 self.assertEqual(
1497 cmd.drgn_option.globals["root"],
1498 self.prog["drgn_test_radix_tree_sparse"].address_of_(),
1499 )
1500 self.assertEqual(cmd.drgn_option.globals["index"], 0xFFFFFFFF)
1501 self.assertIdentical(
1502 cmd.drgn_option.globals["entry"].read_(),
1503 Object(self.prog, "void *", 0x9ABC),
1504 )
1505
1506 def skip_unless_have_xarray(self):
1507 if not self.prog["drgn_test_have_xarray"]:
1508 self.skipTest("kernel does not have XArray")
1509
1510 def test_xarray(self):
1511 self.skip_unless_have_xarray()
1512 cmd = self.check_crash_command("tree -t xarray drgn_test_xarray_sparse")
1513 self.assertEqual(
1514 cmd.stdout,
1515 """\
1516 1234
1517 5678
1518 9abc
1519 """,
1520 )
1521 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1522 self.assertIn("xa_for_each(", cmd.drgn_option.stdout)
1523 self.assertEqual(
1524 cmd.drgn_option.globals["root"],
1525 self.prog["drgn_test_xarray_sparse"].address_of_(),
1526 )
1527 self.assertEqual(cmd.drgn_option.globals["index"], 0xFFFFFFFF)
1528 self.assertIdentical(
1529 cmd.drgn_option.globals["entry"].read_(),
1530 Object(self.prog, "void *", 0x9ABC),
1531 )
1532
1533 def test_xarray_entry_type(self):
1534 self.skip_unless_have_xarray()
1535 cmd = self.check_crash_command(
1536 "tree -t xarray -s drgn_test_xarray_entry drgn_test_xarray_pointers"
1537 )
1538 self.assertEqual(cmd.stdout.count("(struct drgn_test_xarray_entry){"), 4)
1539 self.assertEqual(cmd.drgn_option.globals["index"], 3)
1540 self.assertIdentical(
1541 cmd.drgn_option.globals["entry"].read_(),
1542 self.prog["drgn_test_xarray_entries"][3].address_of_(),
1543 )
1544
1545 def test_xarray_members(self):
1546 self.skip_unless_have_xarray()
1547 cmd = self.check_crash_command(
1548 "tree -t xarray -s drgn_test_xarray_entry.value drgn_test_xarray_pointers"
1549 )
1550 self.assertEqual(
1551 re.findall(r"\bvalue = \(int\)[0-9]+", cmd.stdout),
1552 [f"value = (int){i}" for i in range(4)],
1553 )
1554 self.assertIdentical(
1555 cmd.drgn_option.globals["entry"].read_(),
1556 self.prog["drgn_test_xarray_entries"][3].address_of_(),
1557 )
1558 self.assertIdentical(
1559 cmd.drgn_option.globals["value"].read_(), Object(self.prog, "int", 3)
1560 )
1561
1562 def test_maple(self):
1563 if not self.prog["drgn_test_have_maple_tree"]:
1564 self.skipTest("kernel does not have maple tree")
1565 cmd = self.check_crash_command(
1566 "tree -t maple drgn_test_maple_tree_sparse_ranges"
1567 )
1568 self.assertEqual(
1569 cmd.stdout,
1570 """\
1571 b0ba000
1572 b0ba001
1573 b0ba002
1574 b0ba003
1575 b0ba004
1576 """,
1577 )
1578 self.assertIn("root = prog[", cmd.drgn_option.stdout)
1579 self.assertIn("mt_for_each(", cmd.drgn_option.stdout)
1580 self.assertEqual(
1581 cmd.drgn_option.globals["root"],
1582 self.prog["drgn_test_maple_tree_sparse_ranges"].address_of_(),
1583 )
1584 self.assertEqual(cmd.drgn_option.globals["first_index"], 81)
1585 self.assertEqual(cmd.drgn_option.globals["last_index"], 100)
1586 self.assertIdentical(
1587 cmd.drgn_option.globals["entry"].read_(),
1588 Object(self.prog, "void *", 0xB0BA004),
1589 )
1590
1591 def test_wrong_type(self):
1592 cmd = self.run_crash_command_drgn_option(
1593 "tree drgn_test_radix_tree_sparse", mode="compile"
1594 )
1595 self.assertIn("prog.symbol", cmd.stdout)
1596 self.assertIn("root = Object", cmd.stdout)