Debian Codegraph @

tests/linux_kernel/crash_commands/test_struct.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import os
5 import re
6
7 from drgn import Object, offsetof, reinterpret
8 from drgn.commands import CommandError, CommandNotFoundError
9 from drgn.helpers.linux.pid import find_task
10 from drgn.helpers.linux.sched import task_thread_info
11 from tests.linux_kernel import possible_cpus, skip_unless_have_test_kmod
12 from tests.linux_kernel.crash_commands import CrashCommandTestCase
13
14
15 class TestStruct(CrashCommandTestCase):
16 def test_type(self):
17 cmd = self.check_crash_command("struct list_head")
18 self.assertIn("struct list_head {", cmd.stdout)
19 self.assertRegex(cmd.stdout, "(?m)^SIZE: [0-9]+$")
20 self.assertEqual(
21 cmd.drgn_option.globals["type"].type_name(), "struct list_head"
22 )
23 self.assertIsInstance(cmd.drgn_option.globals["size"], int)
24
25 def test_typedef(self):
26 # atomic_t is a typedef of an anonymous struct. Crash allows this.
27 cmd = self.check_crash_command("struct atomic_t")
28 self.assertIn("} atomic_t", cmd.stdout)
29 self.assertIn('prog.type("atomic_t")', cmd.drgn_option.stdout)
30 self.assertEqual(cmd.drgn_option.globals["type"].type_name(), "atomic_t")
31
32 def test_not_found(self):
33 self.assertRaises(
34 LookupError, self.run_crash_command, "struct drgn_test_non_existent"
35 )
36
37 def test_not_found_drgn_option(self):
38 cmd = self.run_crash_command_drgn_option(
39 "struct drgn_test_non_existent", mode="compile"
40 )
41 self.assertIn('prog.type("struct drgn_test_non_existent")', cmd.stdout)
42
43 @skip_unless_have_test_kmod
44 def test_union(self):
45 self.assertRaises(LookupError, self.run_crash_command, "struct drgn_test_union")
46
47 @skip_unless_have_test_kmod
48 def test_anonymous_union(self):
49 self.assertRaises(
50 LookupError, self.run_crash_command, "struct drgn_test_anonymous_union"
51 )
52
53 def test_type_member(self):
54 cmd = self.check_crash_command("struct list_head.next")
55 self.assertRegex(cmd.stdout, r"\[[0-9]+\] struct list_head \*next;")
56 self.assertEqual(
57 cmd.drgn_option.globals["next_type"].type_name(), "struct list_head *"
58 )
59 self.assertIsInstance(cmd.drgn_option.globals["next_offset"], int)
60
61 def test_type_multiple_members(self):
62 cmd = self.check_crash_command("struct list_head.next,prev")
63 self.assertRegex(cmd.stdout, r"\[[0-9]+\] struct list_head \*next;")
64 self.assertRegex(cmd.stdout, r"\[[0-9]+\] struct list_head \*prev;")
65 self.assertEqual(
66 cmd.drgn_option.globals["next_type"].type_name(), "struct list_head *"
67 )
68 self.assertIsInstance(cmd.drgn_option.globals["next_offset"], int)
69 self.assertEqual(
70 cmd.drgn_option.globals["prev_type"].type_name(), "struct list_head *"
71 )
72 self.assertIsInstance(cmd.drgn_option.globals["prev_offset"], int)
73
74 @skip_unless_have_test_kmod
75 def test_address(self):
76 address = self.prog["drgn_test_singular_list"].address_
77 cmd = self.check_crash_command(f"struct list_head {address:x}")
78 self.assertIn("(struct list_head){", cmd.stdout)
79 self.assertIn(
80 'Object(prog, "struct list_head", address=0x', cmd.drgn_option.stdout
81 )
82 self.assertIdentical(
83 cmd.drgn_option.globals["object"], self.prog["drgn_test_singular_list"]
84 )
85
86 @skip_unless_have_test_kmod
87 def test_symbol(self):
88 cmd = self.check_crash_command("struct list_head drgn_test_singular_list")
89 self.assertIn("(struct list_head){", cmd.stdout)
90 self.assertIn(
91 'object = prog["drgn_test_singular_list"]', cmd.drgn_option.stdout
92 )
93 self.assertIdentical(
94 cmd.drgn_option.globals["object"], self.prog["drgn_test_singular_list"]
95 )
96
97 @skip_unless_have_test_kmod
98 def test_symbol_wrong_type(self):
99 cmd = self.check_crash_command("struct hlist_head drgn_test_singular_list")
100 self.assertIn("(struct hlist_head){", cmd.stdout)
101 self.assertIn("prog.symbol", cmd.drgn_option.stdout)
102 self.assertIdentical(
103 cmd.drgn_option.globals["object"],
104 reinterpret("struct hlist_head", self.prog["drgn_test_singular_list"]),
105 )
106
107 def test_member(self):
108 cmd = self.check_crash_command("struct task_struct.pid init_task")
109 self.assertRegex(cmd.stdout, r"pid = \([^)]*\)0")
110 self.assertIn(".pid", cmd.drgn_option.stdout)
111 self.assertIdentical(cmd.drgn_option.globals["object"], self.prog["init_task"])
112 self.assertEqual(cmd.drgn_option.globals["pid"], 0)
113
114 def test_multiple_members(self):
115 cmd = self.check_crash_command("struct task_struct.pid,tgid init_task")
116 self.assertRegex(cmd.stdout, r"pid = \([^)]*\)0")
117 self.assertRegex(cmd.stdout, r"tgid = \([^)]*\)0")
118 self.assertIn(".pid", cmd.drgn_option.stdout)
119 self.assertIn(".tgid", cmd.drgn_option.stdout)
120 self.assertIdentical(cmd.drgn_option.globals["object"], self.prog["init_task"])
121 self.assertEqual(cmd.drgn_option.globals["pid"], 0)
122 self.assertEqual(cmd.drgn_option.globals["tgid"], 0)
123
124 @skip_unless_have_test_kmod
125 def test_address_and_offset(self):
126 address = hex(self.prog["drgn_test_singular_list"].next)
127 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "node")
128 cmd = self.check_crash_command(
129 f"struct drgn_test_list_entry {address} -l {offset}"
130 )
131 self.assertIn("(struct drgn_test_list_entry){", cmd.stdout)
132 self.assertIn(".value = (int)0,", cmd.stdout)
133 self.assertIn(f"- {offset}", cmd.drgn_option.stdout)
134 self.assertIdentical(
135 cmd.drgn_option.globals["object"],
136 self.prog["drgn_test_singular_list_entry"],
137 )
138
139 @skip_unless_have_test_kmod
140 def test_container_of_address(self):
141 address = hex(self.prog["drgn_test_singular_list"].next)
142 cmd = self.check_crash_command(
143 f"struct drgn_test_list_entry {address} -l drgn_test_list_entry.node"
144 )
145 self.assertIn("(struct drgn_test_list_entry){", cmd.stdout)
146 self.assertIn(".value = (int)0,", cmd.stdout)
147 self.assertIn("container_of(", cmd.drgn_option.stdout)
148 self.assertIdentical(
149 cmd.drgn_option.globals["object"],
150 self.prog["drgn_test_singular_list_entry"],
151 )
152
153 @skip_unless_have_test_kmod
154 def test_container_of_address_wrong_type(self):
155 address = hex(self.prog["drgn_test_singular_list"].next)
156 cmd = self.check_crash_command(
157 f"struct hlist_head {address} -l drgn_test_list_entry.node"
158 )
159 self.assertIn("(struct hlist_head){", cmd.stdout)
160 self.assertIn("container_of(", cmd.drgn_option.stdout)
161 self.assertIn("reinterpret(", cmd.drgn_option.stdout)
162 self.assertIdentical(
163 cmd.drgn_option.globals["object"],
164 reinterpret(
165 "struct hlist_head", self.prog["drgn_test_singular_list_entry"]
166 ),
167 )
168
169 @skip_unless_have_test_kmod
170 def test_container_of_address_with_member(self):
171 address = hex(self.prog["drgn_test_singular_list"].next)
172 cmd = self.check_crash_command(
173 f"struct drgn_test_list_entry.value {address} -l drgn_test_list_entry.node"
174 )
175 self.assertIn("(int)0", cmd.stdout)
176 self.assertIn("container_of(", cmd.drgn_option.stdout)
177 self.assertIdentical(
178 cmd.drgn_option.globals["object"],
179 self.prog["drgn_test_singular_list_entry"],
180 )
181 self.assertIdentical(
182 cmd.drgn_option.globals["value"],
183 self.prog["drgn_test_singular_list_entry"].value,
184 )
185
186 @skip_unless_have_test_kmod
187 def test_positional_count(self):
188 cmd = self.check_crash_command(
189 "struct drgn_test_list_entry drgn_test_list_entries 3"
190 )
191 self.assertEqual(cmd.stdout.count("(struct drgn_test_list_entry){"), 3)
192 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
193 self.assertIdentical(
194 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
195 )
196
197 @skip_unless_have_test_kmod
198 def test_count_option(self):
199 cmd = self.check_crash_command(
200 "struct drgn_test_list_entry drgn_test_list_entries -c 3"
201 )
202 self.assertEqual(cmd.stdout.count("(struct drgn_test_list_entry){"), 3)
203 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
204 self.assertIdentical(
205 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
206 )
207
208 @skip_unless_have_test_kmod
209 def test_negative_count(self):
210 address = self.prog["drgn_test_list_entries"][2].address_
211 cmd = self.check_crash_command(
212 f"struct drgn_test_list_entry {hex(address)} -c -3"
213 )
214 self.assertEqual(cmd.stdout.count("(struct drgn_test_list_entry){"), 3)
215 self.assertIn("for object in pointer[-2:1]", cmd.drgn_option.stdout)
216 self.assertIdentical(
217 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
218 )
219
220 @skip_unless_have_test_kmod
221 def test_count_with_member(self):
222 cmd = self.check_crash_command(
223 "struct drgn_test_list_entry.value drgn_test_list_entries 3"
224 )
225 self.assertEqual(cmd.stdout.count("(int)"), 3)
226 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
227 self.assertIn(" value = object.value", cmd.drgn_option.stdout)
228 self.assertIdentical(
229 cmd.drgn_option.globals["value"],
230 self.prog["drgn_test_list_entries"][2].value,
231 )
232
233 @skip_unless_have_test_kmod
234 def test_count_with_offset(self):
235 address = self.prog["drgn_test_list_entries"][0].value.address_
236 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "value")
237 cmd = self.check_crash_command(
238 f"struct drgn_test_list_entry {hex(address)} -l {offset} -c 3"
239 )
240 self.assertEqual(cmd.stdout.count("(struct drgn_test_list_entry){"), 3)
241 self.assertIn(f"- {offset}", cmd.drgn_option.stdout)
242 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
243 self.assertIdentical(
244 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
245 )
246
247 @skip_unless_have_test_kmod
248 def test_count_with_container_of(self):
249 address = self.prog["drgn_test_list_entries"][0].value.address_
250 cmd = self.check_crash_command(
251 f"struct drgn_test_list_entry {hex(address)} -l drgn_test_list_entry.value -c 3"
252 )
253 self.assertEqual(cmd.stdout.count("(struct drgn_test_list_entry){"), 3)
254 self.assertIn("container_of(", cmd.drgn_option.stdout)
255 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
256 self.assertIdentical(
257 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
258 )
259
260 @skip_unless_have_test_kmod
261 def test_count_with_offset_and_member(self):
262 address = self.prog["drgn_test_list_entries"][0].value.address_
263 offset = offsetof(self.prog.type("struct drgn_test_list_entry"), "value")
264 cmd = self.check_crash_command(
265 f"struct drgn_test_list_entry.value {hex(address)} -l {offset} -c 3"
266 )
267 self.assertEqual(cmd.stdout.count("(int)"), 3)
268 self.assertIn(f"- {offset}", cmd.drgn_option.stdout)
269 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
270 self.assertIn(" value = object.value", cmd.drgn_option.stdout)
271 self.assertIdentical(
272 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
273 )
274 self.assertIdentical(
275 cmd.drgn_option.globals["value"],
276 self.prog["drgn_test_list_entries"][2].value,
277 )
278
279 @skip_unless_have_test_kmod
280 def test_count_with_container_of_and_member(self):
281 address = self.prog["drgn_test_list_entries"][0].value.address_
282 cmd = self.check_crash_command(
283 f"struct drgn_test_list_entry.value {hex(address)} -l drgn_test_list_entry.value -c 3"
284 )
285 self.assertEqual(cmd.stdout.count("(int)"), 3)
286 self.assertIn("container_of(", cmd.drgn_option.stdout)
287 self.assertIn("for object in pointer[:3]", cmd.drgn_option.stdout)
288 self.assertIn(" value = object.value", cmd.drgn_option.stdout)
289 self.assertIdentical(
290 cmd.drgn_option.globals["object"], self.prog["drgn_test_list_entries"][2]
291 )
292 self.assertIdentical(
293 cmd.drgn_option.globals["value"],
294 self.prog["drgn_test_list_entries"][2].value,
295 )
296
297 @skip_unless_have_test_kmod
298 def test_cpuspec(self):
299 cmd = self.check_crash_command(
300 "struct drgn_test_percpu_struct drgn_test_percpu_structs:a"
301 )
302 cpus = sorted(possible_cpus())
303 matches = re.findall(
304 r"^\[([0-9]+)\]: [0-9a-f]+\n\(struct drgn_test_percpu_struct\)\{",
305 cmd.stdout,
306 flags=re.MULTILINE,
307 )
308 self.assertEqual([int(match) for match in matches], cpus)
309 self.assertIn("per_cpu(", cmd.drgn_option.stdout)
310 self.assertEqual(cmd.drgn_option.globals["object"].cpu, max(cpus))
311
312 @skip_unless_have_test_kmod
313 def test_cpuspec_with_member(self):
314 cmd = self.check_crash_command(
315 "struct drgn_test_percpu_struct.cpu drgn_test_percpu_structs:a"
316 )
317 cpus = sorted(possible_cpus())
318 matches = re.findall(r"cpu = \([^)]*\)([0-9]+)", cmd.stdout, flags=re.MULTILINE)
319 self.assertEqual([int(match) for match in matches], cpus)
320 self.assertIn("per_cpu(", cmd.drgn_option.stdout)
321 self.assertEqual(cmd.drgn_option.globals["object"].cpu, max(cpus))
322 self.assertEqual(cmd.drgn_option.globals["cpu"], max(cpus))
323
324 @skip_unless_have_test_kmod
325 def test_cpuspec_with_count(self):
326 cmd = self.check_crash_command(
327 "struct drgn_test_percpu_struct drgn_test_percpu_arrays:a 3"
328 )
329 cpus = sorted(possible_cpus())
330 matches = re.findall(
331 r"(cpu|i) = \([^)]*\)([0-9]+)", cmd.stdout, flags=re.MULTILINE
332 )
333 expected = []
334 for cpu in cpus:
335 for i in range(3):
336 expected.append(("cpu", str(cpu)))
337 expected.append(("i", str(i)))
338 self.assertEqual(matches, expected)
339 self.assertEqual(cmd.drgn_option.globals["object"].cpu, max(cpus))
340 self.assertEqual(cmd.drgn_option.globals["object"].i, 2)
341
342 @skip_unless_have_test_kmod
343 def test_cpuspec_with_count_and_members(self):
344 cmd = self.check_crash_command(
345 "struct drgn_test_percpu_struct.cpu,i drgn_test_percpu_arrays:a 3"
346 )
347 cpus = sorted(possible_cpus())
348 matches = re.findall(
349 r"^(cpu|i) = \([^)]*\)([0-9]+)", cmd.stdout, flags=re.MULTILINE
350 )
351 expected = []
352 for cpu in cpus:
353 for i in range(3):
354 expected.append(("cpu", str(cpu)))
355 expected.append(("i", str(i)))
356 self.assertEqual(matches, expected)
357 self.assertEqual(cmd.drgn_option.globals["object"].cpu, max(cpus))
358 self.assertEqual(cmd.drgn_option.globals["object"].i, 2)
359 self.assertEqual(cmd.drgn_option.globals["cpu"], max(cpus))
360 self.assertEqual(cmd.drgn_option.globals["i"], 2)
361
362 @skip_unless_have_test_kmod
363 def test_radix(self):
364 self.addCleanup(self.prog.config.pop, "crash_radix", None)
365
366 self.run_crash_command("set radix 16")
367 cmd = self.run_crash_command(
368 "struct drgn_test_list_entry drgn_test_singular_list_entry"
369 )
370 self.assertRegex(cmd.stdout, r"value = \([^)]+\)0x0")
371
372 cmd = self.run_crash_command(
373 "struct drgn_test_list_entry drgn_test_singular_list_entry -d"
374 )
375 self.assertRegex(cmd.stdout, r"value = \([^)]+\)0\b")
376
377 self.run_crash_command("set radix 10")
378 cmd = self.run_crash_command(
379 "struct drgn_test_list_entry drgn_test_singular_list_entry"
380 )
381 self.assertRegex(cmd.stdout, r"value = \([^)]+\)0\b")
382
383 cmd = self.run_crash_command(
384 "struct drgn_test_list_entry drgn_test_singular_list_entry -x"
385 )
386 self.assertRegex(cmd.stdout, r"value = \([^)]+\)0x0")
387
388 def test_type_with_count(self):
389 self.assertRaisesRegex(
390 CommandError,
391 "requires address",
392 self.run_crash_command,
393 "struct list_head -c 1",
394 )
395
396 def test_type_with_offset(self):
397 self.assertRaisesRegex(
398 CommandError,
399 "requires address",
400 self.run_crash_command,
401 "struct list_head -l 0",
402 )
403
404 def test_invalid_structure_name(self):
405 self.assertRaisesRegex(
406 ValueError,
407 "invalid type name",
408 self.check_crash_command,
409 "struct 1234",
410 )
411
412 def test_invalid_member(self):
413 self.assertRaisesRegex(
414 ValueError,
415 "invalid member name",
416 self.check_crash_command,
417 "struct rq.[1]",
418 )
419 self.assertRaisesRegex(
420 ValueError,
421 "invalid member name",
422 self.check_crash_command,
423 "struct rq.2",
424 )
425
426
427 class TestUnion(CrashCommandTestCase):
428 @skip_unless_have_test_kmod
429 def test_type(self):
430 cmd = self.check_crash_command("union drgn_test_union")
431 self.assertIn("union drgn_test_union {", cmd.stdout)
432 self.assertRegex(cmd.stdout, "(?m)^SIZE: [0-9]+$")
433 self.assertEqual(
434 cmd.drgn_option.globals["type"].type_name(), "union drgn_test_union"
435 )
436 self.assertIsInstance(cmd.drgn_option.globals["size"], int)
437
438 @skip_unless_have_test_kmod
439 def test_typedef(self):
440 cmd = self.check_crash_command("union drgn_test_anonymous_union")
441 self.assertIn("} drgn_test_anonymous_union", cmd.stdout)
442 self.assertIn('prog.type("drgn_test_anonymous_union")', cmd.drgn_option.stdout)
443 self.assertEqual(
444 cmd.drgn_option.globals["type"].type_name(), "drgn_test_anonymous_union"
445 )
446
447 def test_struct(self):
448 self.assertRaises(LookupError, self.run_crash_command, "union task_struct")
449
450 def test_anonymous_struct(self):
451 self.assertRaises(LookupError, self.run_crash_command, "union atomic_t")
452
453
454 class TestAsterisk(CrashCommandTestCase):
455 def test_struct(self):
456 cmd = self.check_crash_command("*list_head")
457 self.assertIn("struct list_head {", cmd.stdout)
458 self.assertEqual(
459 cmd.drgn_option.globals["type"].type_name(), "struct list_head"
460 )
461
462 def test_struct_with_space(self):
463 cmd = self.check_crash_command("* list_head")
464 self.assertIn("struct list_head {", cmd.stdout)
465 self.assertEqual(
466 cmd.drgn_option.globals["type"].type_name(), "struct list_head"
467 )
468
469 @skip_unless_have_test_kmod
470 def test_union(self):
471 cmd = self.check_crash_command("*drgn_test_union")
472 self.assertIn("union drgn_test_union {", cmd.stdout)
473 self.assertEqual(
474 cmd.drgn_option.globals["type"].type_name(), "union drgn_test_union"
475 )
476
477 def test_struct_typedef(self):
478 cmd = self.check_crash_command("*atomic_t")
479 self.assertIn("} atomic_t", cmd.stdout)
480 self.assertIn('prog.type("atomic_t")', cmd.drgn_option.stdout)
481 self.assertEqual(cmd.drgn_option.globals["type"].type_name(), "atomic_t")
482
483 @skip_unless_have_test_kmod
484 def test_union_typedef(self):
485 cmd = self.check_crash_command("*drgn_test_anonymous_union")
486 self.assertIn("} drgn_test_anonymous_union", cmd.stdout)
487 self.assertIn('prog.type("drgn_test_anonymous_union")', cmd.drgn_option.stdout)
488 self.assertEqual(
489 cmd.drgn_option.globals["type"].type_name(), "drgn_test_anonymous_union"
490 )
491
492 def test_not_found(self):
493 self.assertRaises(
494 LookupError, self.run_crash_command, "*drgn_test_non_existent"
495 )
496
497
498 class TestImplicit(CrashCommandTestCase):
499 def test_struct(self):
500 cmd = self.check_crash_command("list_head")
501 self.assertIn("struct list_head {", cmd.stdout)
502 self.assertEqual(
503 cmd.drgn_option.globals["type"].type_name(), "struct list_head"
504 )
505
506 @skip_unless_have_test_kmod
507 def test_union(self):
508 cmd = self.check_crash_command("drgn_test_union")
509 self.assertIn("union drgn_test_union {", cmd.stdout)
510 self.assertEqual(
511 cmd.drgn_option.globals["type"].type_name(), "union drgn_test_union"
512 )
513
514 def test_struct_typedef(self):
515 cmd = self.check_crash_command("atomic_t")
516 self.assertIn("} atomic_t", cmd.stdout)
517 self.assertIn('prog.type("atomic_t")', cmd.drgn_option.stdout)
518 self.assertEqual(cmd.drgn_option.globals["type"].type_name(), "atomic_t")
519
520 @skip_unless_have_test_kmod
521 def test_union_typedef(self):
522 cmd = self.check_crash_command("drgn_test_anonymous_union")
523 self.assertIn("} drgn_test_anonymous_union", cmd.stdout)
524 self.assertIn('prog.type("drgn_test_anonymous_union")', cmd.drgn_option.stdout)
525 self.assertEqual(
526 cmd.drgn_option.globals["type"].type_name(), "drgn_test_anonymous_union"
527 )
528
529 def test_member(self):
530 cmd = self.check_crash_command("task_struct.pid init_task")
531 self.assertRegex(cmd.stdout, r"pid = \([^)]*\)0")
532 self.assertIn(".pid", cmd.drgn_option.stdout)
533 self.assertIdentical(cmd.drgn_option.globals["object"], self.prog["init_task"])
534 self.assertEqual(cmd.drgn_option.globals["pid"], 0)
535
536 def test_not_found(self):
537 self.assertRaises(
538 CommandNotFoundError, self.run_crash_command, "drgn_test_non_existent"
539 )
540
541
542 class TestTask(CrashCommandTestCase):
543 def test_no_args(self):
544 self.run_crash_command("set -p")
545
546 cmd = self.check_crash_command("task")
547 self.assertIn(f"PID: {os.getpid()}", cmd.stdout)
548 self.assertIn("(struct task_struct){", cmd.stdout)
549 self.assertIn("(struct thread_info){", cmd.stdout)
550
551 task = find_task(self.prog, os.getpid())
552 self.assertEqual(cmd.drgn_option.globals["task"], task)
553 self.assertIn("pid", cmd.drgn_option.globals)
554 self.assertIn("cpu", cmd.drgn_option.globals)
555 self.assertIn("command", cmd.drgn_option.globals)
556 self.assertEqual(cmd.drgn_option.globals["thread_info"], task_thread_info(task))
557
558 def test_pids(self):
559 cmd = self.check_crash_command("task 1 2")
560 foreach_cmd = self.check_crash_command("foreach 1 2 task", mode="capture")
561
562 for c in (cmd, foreach_cmd):
563 self.assertIn("PID: 1", c.stdout)
564 self.assertIn("PID: 2", c.stdout)
565 self.assertIn("(struct task_struct){", c.stdout)
566 self.assertIn("(struct thread_info){", c.stdout)
567
568 task = find_task(self.prog, 2)
569 self.assertEqual(cmd.drgn_option.globals["task"], task)
570 self.assertIn("pid", cmd.drgn_option.globals)
571 self.assertIn("cpu", cmd.drgn_option.globals)
572 self.assertIn("command", cmd.drgn_option.globals)
573 self.assertEqual(cmd.drgn_option.globals["thread_info"], task_thread_info(task))
574
575 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
576
577 def test_members(self):
578 cmd = self.check_crash_command("task 1 -R on_rq,prio")
579 foreach_cmd = self.check_crash_command(
580 "foreach 1 task -R on_rq,prio", mode="capture"
581 )
582
583 for c in (cmd, foreach_cmd):
584 self.assertNotIn("(struct task_struct){", c.stdout)
585 self.assertNotIn("(struct thread_info){", c.stdout)
586 self.assertIn("on_rq =", c.stdout)
587 self.assertIn("prio =", c.stdout)
588
589 task = find_task(self.prog, 1)
590 self.assertEqual(cmd.drgn_option.globals["task"], task)
591 self.assertIn("pid", cmd.drgn_option.globals)
592 self.assertIn("cpu", cmd.drgn_option.globals)
593 self.assertIn("command", cmd.drgn_option.globals)
594 self.assertIsInstance(cmd.drgn_option.globals["on_rq"], Object)
595 self.assertIsInstance(cmd.drgn_option.globals["prio"], Object)
596 self.assertNotIn("thread_info", cmd.drgn_option.globals)
597
598 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
599
600 def test_members_without_R(self):
601 cmd = self.check_crash_command("task 1 prio")
602 self.assertNotIn("(struct task_struct){", cmd.stdout)
603 self.assertNotIn("(struct thread_info){", cmd.stdout)
604 self.assertIn("prio =", cmd.stdout)
605
606 task = find_task(self.prog, 1)
607 self.assertEqual(cmd.drgn_option.globals["task"], task)
608 self.assertIn("pid", cmd.drgn_option.globals)
609 self.assertIn("cpu", cmd.drgn_option.globals)
610 self.assertIn("command", cmd.drgn_option.globals)
611 self.assertIsInstance(cmd.drgn_option.globals["prio"], Object)
612 self.assertNotIn("thread_info", cmd.drgn_option.globals)
613
614 def test_members_with_and_without_R(self):
615 cmd = self.check_crash_command("task -R on_rq 1 prio")
616 self.assertNotIn("(struct task_struct){", cmd.stdout)
617 self.assertNotIn("(struct thread_info){", cmd.stdout)
618 self.assertIn("on_rq =", cmd.stdout)
619 self.assertIn("prio =", cmd.stdout)
620
621 task = find_task(self.prog, 1)
622 self.assertEqual(cmd.drgn_option.globals["task"], task)
623 self.assertIn("pid", cmd.drgn_option.globals)
624 self.assertIn("cpu", cmd.drgn_option.globals)
625 self.assertIn("command", cmd.drgn_option.globals)
626 self.assertIsInstance(cmd.drgn_option.globals["on_rq"], Object)
627 self.assertIsInstance(cmd.drgn_option.globals["prio"], Object)
628 self.assertNotIn("thread_info", cmd.drgn_option.globals)