Debian Codegraph @

tests/linux_kernel/crash_commands/test_ps.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import collections
5 import os
6 from pathlib import Path
7 import re
8 import threading
9
10 from drgn import Object
11 from drgn.commands._crash.common import _CRASH_FOREACH_SUBCOMMANDS
12 from drgn.helpers.common.format import double_quote_ascii_string
13 from drgn.helpers.linux.mm import TaskRss
14 from drgn.helpers.linux.pid import find_task
15 from tests.linux_kernel import (
16 fork_and_stop,
17 online_cpus,
18 skip_if_highmem,
19 skip_unless_have_full_mm_support,
20 )
21 from tests.linux_kernel.crash_commands import CrashCommandTestCase
22
23
24 def _quoted_comm(pid="self"):
25 return double_quote_ascii_string(
26 Path(f"/proc/{pid}/comm").read_bytes().rstrip(b"\n")
27 )
28
29
30 class TestPs(CrashCommandTestCase):
31 @classmethod
32 def setUpClass(cls):
33 super().setUpClass()
34
35 cls.condition = threading.Condition()
36 cls.threads = [threading.Thread(target=cls.thread_func) for _ in range(2)]
37 cls.addClassCleanup(cls.cleanup_threads)
38 for i, thread in enumerate(cls.threads):
39 name = f"drgn_test_ps{i}"
40 thread.name = name
41 thread.start()
42
43 # Since Python 3.14, the thread name will be set at the OS level,
44 # but before that, we have to do it manually.
45 comm_path = Path(f"/proc/{thread.native_id}/comm")
46 if comm_path.read_text() != name + "\n":
47 comm_path.write_text(name + "\n")
48
49 @classmethod
50 def thread_func(cls):
51 with cls.condition:
52 cls.condition.wait()
53
54 @classmethod
55 def cleanup_threads(cls):
56 with cls.condition:
57 cls.condition.notify_all()
58 for thread in cls.threads:
59 thread.join()
60
61 def _test_drgn_common(self, cmd):
62 for variable in (
63 "task",
64 "pid",
65 "ppid",
66 "comm",
67 ):
68 with self.subTest(variable=variable):
69 self.assertIsInstance(cmd.drgn_option.globals[variable], Object)
70 self.assertIsInstance(cmd.drgn_option.globals["cpu"], int)
71 self.assertIsInstance(cmd.drgn_option.globals["state"], str)
72 self.assertIsInstance(cmd.drgn_option.globals["mem_usage"], float)
73 self.assertIsInstance(cmd.drgn_option.globals["vsize"], int)
74 self.assertIsInstance(cmd.drgn_option.globals["rss"], TaskRss)
75
76 def test_no_args(self):
77 cmd = self.check_crash_command("ps")
78
79 self.assertRegex(cmd.stdout, r"^\s*PID\s+PPID")
80 for pid in [0, 1, os.getpid(), *(thread.native_id for thread in self.threads)]:
81 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{pid}\b")
82
83 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
84 self.assertNotIn("continue", cmd.drgn_option.stdout)
85 self._test_drgn_common(cmd)
86
87 def test_pid(self):
88 cmd = self.check_crash_command("ps -H 1")
89 foreach_cmd = self.check_crash_command("foreach 1 ps -H", mode="capture")
90
91 for c in (cmd, foreach_cmd):
92 self.assertRegex(c.stdout, r"^>?\s*1\b.*\n$")
93
94 self.assertIn("pid = 1", cmd.drgn_option.stdout)
95 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
96 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
97 self._test_drgn_common(cmd)
98
99 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
100
101 def test_pid_0(self):
102 cmd = self.check_crash_command("ps -H 0")
103
104 for line in cmd.stdout.splitlines(keepends=True):
105 self.assertRegex(line, r"^>?\s*0\b.*\n$")
106
107 self.assertIn("for_each_online_cpu(", cmd.drgn_option.stdout)
108 self.assertIn("idle_task(", cmd.drgn_option.stdout)
109 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
110 self._test_drgn_common(cmd)
111
112 def test_multiple_pids(self):
113 cmd = self.check_crash_command(f"ps -H {os.getpid()} 1")
114
115 self.assertRegex(cmd.stdout, rf"^>?\s*1\b.*\n>?\s*{os.getpid()}\b.*\n$")
116
117 self.assertIn("pid = 1\n", cmd.drgn_option.stdout)
118 self.assertIn(f"pid = {os.getpid()}\n", cmd.drgn_option.stdout)
119 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
120 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
121 self._test_drgn_common(cmd)
122
123 def test_invalid_pid(self):
124 cmd = self.check_crash_command("ps -H 2147483647")
125
126 self.assertIn("no such process with PID 2147483647", cmd.stdout)
127
128 def test_task_struct(self):
129 address = find_task(self.prog, 1).value_()
130 cmd = self.check_crash_command(f"ps -H {address:#x}")
131
132 self.assertRegex(cmd.stdout, r"^>?\s*1\b.*\n$")
133
134 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
135 self.assertIn(hex(address), cmd.drgn_option.stdout)
136 self.assertIn('Object(prog, "struct task_struct *", ', cmd.drgn_option.stdout)
137 self._test_drgn_common(cmd)
138
139 def test_multiple_task_structs(self):
140 cmd = self.check_crash_command(
141 f"ps -H {find_task(self.prog, 1).value_():#x} {self.prog['init_task'].address_:#x}"
142 )
143
144 self.assertRegex(cmd.stdout, r"^>?\s*0\b.*\n>?\s*1\b.*\n$")
145
146 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
147 self.assertIn('Object(prog, "struct task_struct *", ', cmd.drgn_option.stdout)
148 self._test_drgn_common(cmd)
149
150 def test_invalid_task_struct(self):
151 address = self.prog["init_task"].address_
152 cmd = self.run_crash_command(f"ps -H {address + 1:#x}")
153
154 self.assertIn(f"invalid task_struct: {address + 1:#x}", cmd.stdout)
155
156 def test_pid_and_task_struct(self):
157 address = self.prog["init_task"].address_
158 cmd = self.check_crash_command(f"ps -H 1 {address:#x}")
159
160 self.assertRegex(cmd.stdout, r"(?m)^>?\s*0\b")
161 self.assertRegex(cmd.stdout, r"(?m)^>?\s*1\b")
162
163 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
164 self.assertIn("pid = 1", cmd.drgn_option.stdout)
165 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
166 self.assertIn(hex(address), cmd.drgn_option.stdout)
167 self.assertIn('Object(prog, "struct task_struct *", ', cmd.drgn_option.stdout)
168 self._test_drgn_common(cmd)
169
170 def test_command_names(self):
171 self_comm = Path("/proc/self/comm").read_bytes().rstrip(b"\n")
172 similar_comm = self_comm + b"1" if len(self_comm) < 15 else self_comm[:-1]
173 with fork_and_stop(Path("/proc/self/comm").write_bytes, similar_comm) as (
174 pid,
175 _,
176 ):
177 cmd = self.check_crash_command(
178 f"ps -H {double_quote_ascii_string(self_comm)} {_quoted_comm(1)}"
179 )
180
181 self.assertRegex(cmd.stdout, r"(?m)^>?\s*1\b")
182 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{os.getpid()}\b")
183 self.assertNotRegex(cmd.stdout, rf"(?m)^>?\s*{pid}\b")
184
185 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
186 self.assertIn("comm_string not in ", cmd.drgn_option.stdout)
187 self.assertIn("continue", cmd.drgn_option.stdout)
188 self._test_drgn_common(cmd)
189
190 def test_backslash_command_name(self):
191 with fork_and_stop(Path("/proc/self/comm").write_bytes, b"drgn_test_ps") as (
192 pid,
193 _,
194 ):
195 cmd = self.check_crash_command(r"ps -H \drgn_test_ps")
196
197 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{pid}\b")
198
199 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
200 self.assertIn('comm_string != "drgn_test_ps"', cmd.drgn_option.stdout)
201 self.assertIn("continue", cmd.drgn_option.stdout)
202 self._test_drgn_common(cmd)
203
204 def test_command_name_regex(self):
205 cmd = self.check_crash_command(r"ps -H 'drgn_test_ps[0-9]'")
206
207 for pid in [thread.native_id for thread in self.threads]:
208 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{pid}\b")
209
210 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
211 self.assertIn(
212 're.search("drgn_test_ps[0-9]", comm_string)', cmd.drgn_option.stdout
213 )
214 self.assertIn("continue", cmd.drgn_option.stdout)
215 self._test_drgn_common(cmd)
216
217 def test_pid_and_command_name(self):
218 cmd = self.check_crash_command(f"ps -H {_quoted_comm()} 1")
219
220 self.assertRegex(cmd.stdout, r"(?m)^>?\s*1\b")
221 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{os.getpid()}\b")
222
223 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
224 self.assertNotIn("find_task(", cmd.drgn_option.stdout)
225 self.assertIn("task.pid.value_() == 1", cmd.drgn_option.stdout)
226 self.assertIn("comm_string != ", cmd.drgn_option.stdout)
227 self.assertIn("continue", cmd.drgn_option.stdout)
228 self._test_drgn_common(cmd)
229
230 def test_pid_and_task_struct_and_command_name(self):
231 address = self.prog["init_task"].address_
232 cmd = self.check_crash_command(f"ps -H {_quoted_comm()} 1 {address:#x}")
233
234 self.assertRegex(cmd.stdout, r"(?m)^>?\s*0\b")
235 self.assertRegex(cmd.stdout, r"(?m)^>?\s*1\b")
236 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{os.getpid()}\b")
237
238 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
239 self.assertNotIn("find_task(", cmd.drgn_option.stdout)
240 self.assertIn("task.pid.value_() == 1", cmd.drgn_option.stdout)
241 self.assertIn(f"task.value_() == {address:#x}", cmd.drgn_option.stdout)
242 self.assertIn("comm_string != ", cmd.drgn_option.stdout)
243 self.assertIn("continue", cmd.drgn_option.stdout)
244 self._test_drgn_common(cmd)
245
246 def test_kernel(self):
247 cmd = self.check_crash_command("ps -k")
248
249 self.assertRegex(cmd.stdout, r"(?m)^>?\s*0\b")
250 self.assertNotRegex(cmd.stdout, r"(?m)^>?\s*1\b")
251
252 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
253 self.assertIn("if not task_is_kthread(task):", cmd.drgn_option.stdout)
254 self.assertIn("continue", cmd.drgn_option.stdout)
255 self._test_drgn_common(cmd)
256
257 def test_kernel_and_pid(self):
258 cmd = self.check_crash_command("ps -H -k 0 2")
259
260 self.assertRegex(cmd.stdout, r"(?:^>?\s*[02]\b.*\n)+")
261
262 self.assertIn("for_each_online_cpu(", cmd.drgn_option.stdout)
263 self.assertIn("idle_task(", cmd.drgn_option.stdout)
264 self.assertIn("pid = 2", cmd.drgn_option.stdout)
265 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
266 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
267 self.assertIn("if not task_is_kthread(task):", cmd.drgn_option.stdout)
268 self.assertIn("continue", cmd.drgn_option.stdout)
269 self._test_drgn_common(cmd)
270
271 def test_kernel_and_user_pid(self):
272 cmd = self.check_crash_command("ps -H -k 1")
273
274 self.assertFalse(cmd.stdout)
275 self.assertNotIn("ppid", cmd.drgn_option.globals)
276
277 def test_user(self):
278 cmd = self.check_crash_command("ps -u")
279
280 self.assertRegex(cmd.stdout, r"(?m)^>?\s*1\b")
281 self.assertNotRegex(cmd.stdout, r"(?m)^>?\s*0\b")
282
283 self.assertIn("for_each_task()", cmd.drgn_option.stdout)
284 self.assertIn("if task_is_kthread(task):", cmd.drgn_option.stdout)
285 self.assertIn("continue", cmd.drgn_option.stdout)
286 self._test_drgn_common(cmd)
287
288 def test_user_and_pid(self):
289 cmd = self.check_crash_command("ps -H -u 1")
290
291 self.assertRegex(cmd.stdout, r"^>?\s*1\b.*\n$")
292
293 self.assertIn("pid = 1", cmd.drgn_option.stdout)
294 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
295 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
296 self.assertIn("if task_is_kthread(task):", cmd.drgn_option.stdout)
297 self.assertIn("continue", cmd.drgn_option.stdout)
298 self._test_drgn_common(cmd)
299
300 def test_user_and_kernel_pid(self):
301 cmd = self.check_crash_command("ps -H -u 0 2")
302
303 self.assertFalse(cmd.stdout)
304 self.assertNotIn("ppid", cmd.drgn_option.globals)
305
306 def test_group_leader(self):
307 cmd = self.check_crash_command("ps -G")
308
309 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{os.getpid()}\b")
310 self.assertNotRegex(cmd.stdout, rf"(?m)^>?\s*{self.threads[0].native_id}\b")
311
312 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
313 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
314 self.assertIn("continue", cmd.drgn_option.stdout)
315 self._test_drgn_common(cmd)
316
317 def test_group_leader_and_pid(self):
318 cmd = self.check_crash_command(f"ps -H -G {os.getpid()}")
319 foreach_cmd = self.check_crash_command(
320 f"foreach {os.getpid()} ps -H -G", mode="capture"
321 )
322
323 for c in (cmd, foreach_cmd):
324 self.assertRegex(c.stdout, rf"^>?\s*{os.getpid()}\b.*$")
325
326 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
327 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
328 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
329 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
330 self.assertNotIn("continue", cmd.drgn_option.stdout)
331 self._test_drgn_common(cmd)
332
333 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
334
335 def test_group_leader_and_tid(self):
336 cmd = self.check_crash_command(f"ps -H -G {self.threads[0].native_id}")
337
338 self.assertRegex(cmd.stdout, rf"^>?\s*{os.getpid()}\b.*$")
339
340 self.assertIn("find_task(pid)", cmd.drgn_option.stdout)
341 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
342 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
343 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
344 self.assertNotIn("continue", cmd.drgn_option.stdout)
345 self._test_drgn_common(cmd)
346
347 def test_group_leader_and_task_struct(self):
348 address = find_task(self.prog, os.getpid()).value_()
349 cmd = self.check_crash_command(f"ps -H -G {address:#x}")
350
351 self.assertRegex(cmd.stdout, rf"^>?\s*{os.getpid()}\b.*$")
352
353 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
354 self.assertIn(hex(address), cmd.drgn_option.stdout)
355 self.assertIn('Object(prog, "struct task_struct *", ', cmd.drgn_option.stdout)
356 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
357 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
358 self._test_drgn_common(cmd)
359
360 def test_group_leader_and_thread_task_struct(self):
361 address = find_task(self.prog, self.threads[0].native_id).value_()
362 cmd = self.check_crash_command(f"ps -H -G {address:#x}")
363
364 self.assertRegex(cmd.stdout, rf"^>?\s*{os.getpid()}\b.*$")
365
366 self.assertNotIn("for_each_task", cmd.drgn_option.stdout)
367 self.assertIn(hex(address), cmd.drgn_option.stdout)
368 self.assertIn('Object(prog, "struct task_struct *", ', cmd.drgn_option.stdout)
369 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
370 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
371 self._test_drgn_common(cmd)
372
373 def test_group_leader_and_command_name(self):
374 cmd = self.check_crash_command(
375 f"ps -H -G {_quoted_comm()} {_quoted_comm(self.threads[0].native_id)}"
376 )
377
378 self.assertRegex(cmd.stdout, rf"(?m)^>?\s*{os.getpid()}\b")
379 self.assertNotRegex(cmd.stdout, rf"(?m)^>?\s*{self.threads[0].native_id}\b")
380
381 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
382 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
383 self.assertNotIn("task = task.group_leader", cmd.drgn_option.stdout)
384 self.assertIn("comm_string not in ", cmd.drgn_option.stdout)
385 self.assertIn("continue", cmd.drgn_option.stdout)
386 self._test_drgn_common(cmd)
387
388 def test_policy(self):
389 with fork_and_stop() as pid1, fork_and_stop() as pid2:
390 os.sched_setscheduler(pid1, os.SCHED_OTHER, os.sched_param(0))
391 os.sched_setscheduler(pid2, os.SCHED_BATCH, os.sched_param(0))
392
393 cmd = self.check_crash_command("ps -y BATCH")
394 foreach_cmd = self.check_crash_command(
395 "foreach ps -y BATCH", mode="capture"
396 )
397
398 for c in (cmd, foreach_cmd):
399 self.assertRegex(c.stdout, rf"(?m)^>?\s*{pid2}\b")
400 self.assertNotRegex(c.stdout, rf"(?m)^>?\s*{pid1}\b")
401
402 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
403 self.assertIn("if task.policy.value_() != ", cmd.drgn_option.stdout)
404 self.assertIn("continue", cmd.drgn_option.stdout)
405 self._test_drgn_common(cmd)
406
407 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
408
409 def test_state(self):
410 with fork_and_stop() as pid:
411 cmd = self.check_crash_command("foreach R ps")
412
413 self.assertNotRegex(cmd.stdout, rf"(?m)^>?\s*{pid}\b")
414
415 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
416 self.assertIn("if task_state_to_char(task) != ", cmd.drgn_option.stdout)
417 self.assertIn("continue", cmd.drgn_option.stdout)
418 self._test_drgn_common(cmd)
419
420 def test_active(self):
421 with fork_and_stop() as pid:
422 cmd = self.check_crash_command("ps -A")
423 foreach_cmd = self.check_crash_command("foreach active ps", mode="capture")
424
425 for c in (cmd, foreach_cmd):
426 self.assertNotRegex(c.stdout, rf"(?m)^>?\s*{pid}\b")
427
428 self.assertIn("for_each_task(idle=True)", cmd.drgn_option.stdout)
429 self.assertIn("if not task_on_cpu(task)", cmd.drgn_option.stdout)
430 self.assertIn("continue", cmd.drgn_option.stdout)
431 self._test_drgn_common(cmd)
432
433 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
434
435 def _test_drgn_task_header(self, cmd):
436 for variable in (
437 "task",
438 "pid",
439 "command",
440 ):
441 with self.subTest(variable=variable):
442 self.assertIsInstance(cmd.drgn_option.globals[variable], Object)
443 self.assertIsInstance(cmd.drgn_option.globals["cpu"], int)
444
445 def test_parents(self):
446 with fork_and_stop() as pid:
447 parents = [pid]
448 current_pid = pid
449 while current_pid != 0:
450 ppid = int(
451 re.search(
452 r"^PPid:\s*([0-9]+)",
453 Path(f"/proc/{current_pid}/status").read_text(),
454 flags=re.M,
455 ).group(1)
456 )
457 parents.append(ppid)
458 current_pid = ppid
459
460 cmd = self.check_crash_command(f"ps -p {pid}")
461 foreach_cmd = self.check_crash_command(
462 f"foreach {pid} ps -p", mode="capture"
463 )
464
465 regex = ["^"]
466 for i, expected_pid in enumerate(reversed(parents)):
467 regex.append(" " * i + rf"PID: {expected_pid}\b.*\n")
468 regex.append("$")
469 for c in (cmd, foreach_cmd):
470 self.assertRegex(c.stdout, "".join(regex))
471
472 self.assertIn("task.parent", cmd.drgn_option.stdout)
473 self.assertEqual(
474 cmd.drgn_option.globals["parent"].type_.type_name(), "struct task_struct *"
475 )
476 self._test_drgn_task_header(cmd)
477
478 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
479
480 def test_children(self):
481 with fork_and_stop() as pid1, fork_and_stop() as pid2:
482 cmd = self.check_crash_command(f"ps -c {os.getpid()}")
483 foreach_cmd = self.check_crash_command(
484 f"foreach {os.getpid()} ps -c", mode="capture"
485 )
486
487 for c in (cmd, foreach_cmd):
488 self.assertRegex(c.stdout, rf"^PID: {os.getpid()}\b")
489 for pid in pid1, pid2:
490 self.assertRegex(c.stdout, rf"(?m)^ PID: {pid}\b")
491
492 self.assertIn("list_for_each_entry(", cmd.drgn_option.stdout)
493 self.assertIn("task.children", cmd.drgn_option.stdout)
494 self.assertEqual(
495 cmd.drgn_option.globals["child"].type_.type_name(), "struct task_struct *"
496 )
497 self._test_drgn_task_header(cmd)
498
499 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
500
501 def test_no_children(self):
502 with fork_and_stop() as pid:
503 cmd = self.run_crash_command(f"ps -c {pid}")
504 self.assertIn("(no children)", cmd.stdout)
505
506 def test_times(self):
507 cmd = self.check_crash_command(f"ps -t {os.getpid()}")
508 foreach_cmd = self.check_crash_command(
509 f"foreach {os.getpid()} ps -t", mode="capture"
510 )
511
512 for c in (cmd, foreach_cmd):
513 self.assertRegex(
514 c.stdout,
515 r"(?m)^\s*RUN TIME: (?:[0-9] days, )?[0-9]{2}:[0-9]{2}:[0-9]{2}",
516 )
517 self.assertRegex(c.stdout, r"(?m)^\s*START TIME: [0-9]+$")
518 self.assertRegex(c.stdout, r"(?m)^\s*UTIME: [0-9]+$")
519 self.assertRegex(c.stdout, r"(?m)^\s*STIME: [0-9]+$")
520
521 for variable in (
522 "run_time",
523 "start_time",
524 "utime",
525 "stime",
526 ):
527 with self.subTest(variable=variable):
528 self.assertIsInstance(cmd.drgn_option.globals[variable], Object)
529 self._test_drgn_task_header(cmd)
530
531 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
532
533 def test_last_arrival_timestamp(self):
534 cmd = self.check_crash_command("ps -l")
535 foreach_cmd = self.check_crash_command("foreach ps -l", mode="capture")
536
537 for c in (cmd, foreach_cmd):
538 timestamps = []
539 for line in c.stdout.splitlines():
540 timestamps.append(
541 int(re.match(r"\[\s*([0-9]+)\] \[[A-Z]\] PID: ", line).group(1))
542 )
543 self.assertEqual(timestamps, sorted(timestamps, reverse=True))
544
545 self.assertIsInstance(cmd.drgn_option.globals["last_arrival"], Object)
546 self.assertIsInstance(cmd.drgn_option.globals["state"], str)
547 self._test_drgn_task_header(cmd)
548
549 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
550
551 def test_last_arrival_elapsed(self):
552 cmd = self.check_crash_command("ps -m")
553 foreach_cmd = self.check_crash_command("foreach ps -m", mode="capture")
554
555 for c in (cmd, foreach_cmd):
556 for line in c.stdout.splitlines():
557 self.assertRegex(
558 line,
559 r"^\[\s*[0-9]+ [0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}\] \[[A-Z]\] PID: ",
560 )
561
562 self.assertIn("task_since_last_arrival_ns(", cmd.drgn_option.stdout)
563 self.assertIsInstance(cmd.drgn_option.globals["elapsed"], int)
564 self.assertIsInstance(cmd.drgn_option.globals["state"], str)
565 self._test_drgn_task_header(cmd)
566
567 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
568
569 def test_last_arrival_cpus(self):
570 cpu = min(online_cpus())
571 cmd = self.run_crash_command(f"ps -l -C {cpu}")
572 foreach_cmd = self.run_crash_command(f"foreach ps -l -C {cpu}")
573
574 for c in (cmd, foreach_cmd):
575 timestamps = []
576 lines = c.stdout.splitlines()
577 self.assertEqual(lines[0], f"CPU: {cpu}")
578 for line in lines[1:]:
579 timestamps.append(
580 int(
581 re.match(
582 rf"\[\s*([0-9]+)\] \[[A-Z]\] PID: .*\bCPU: {cpu}\b", line
583 ).group(1)
584 )
585 )
586 self.assertEqual(timestamps, sorted(timestamps, reverse=True))
587
588 @skip_unless_have_full_mm_support
589 @skip_if_highmem
590 def test_arguments(self):
591 cmd = self.check_crash_command(f"ps -a {os.getpid()}")
592 foreach_cmd = self.check_crash_command(
593 f"foreach {os.getpid()} ps -a", mode="capture"
594 )
595
596 cmdline = Path("/proc/self/cmdline").read_text()
597 if cmdline.endswith("\0"):
598 cmdline = cmdline[:-1]
599 cmdline = cmdline.replace("\0", " ")
600
601 environ = Path("/proc/self/environ").read_text()
602 if environ.endswith("\0"):
603 environ = environ[:-1]
604 environ = environ.replace("\0", "\n ")
605
606 for c in (cmd, foreach_cmd):
607 self.assertRegex(c.stdout, rf"(?m)^ARG: {re.escape(cmdline)}$")
608 self.assertRegex(c.stdout, rf"(?m)^ENV: {re.escape(environ)}$")
609
610 self.assertIn("cmdline(", cmd.drgn_option.stdout)
611 self.assertIn("environ(", cmd.drgn_option.stdout)
612 self.assertIsInstance(cmd.drgn_option.globals["arg"], list)
613 self.assertIsInstance(cmd.drgn_option.globals["env"], list)
614 self._test_drgn_task_header(cmd)
615
616 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
617
618 def test_thread_groups(self):
619 cmd = self.check_crash_command("ps -g")
620 foreach_cmd = self.check_crash_command("foreach ps -g", mode="capture")
621
622 for c in (cmd, foreach_cmd):
623 self.assertRegex(
624 c.stdout,
625 rf"(?m)^PID: {os.getpid()}\b.*\n(?: PID: .*\n)* PID: {self.threads[0].native_id}\b",
626 )
627 self.assertNotRegex(c.stdout, rf"(?m)^PID: {self.threads[0].native_id}\b")
628
629 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
630 self.assertIn("continue", cmd.drgn_option.stdout)
631 self.assertIn("for_each_task_in_group(", cmd.drgn_option.stdout)
632 self.assertEqual(
633 cmd.drgn_option.globals["thread"].type_.type_name(), "struct task_struct *"
634 )
635 self._test_drgn_task_header(cmd)
636
637 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
638
639 def test_thread_groups_and_pid(self):
640 cmd = self.check_crash_command(f"ps -g {os.getpid()}")
641
642 self.assertRegex(
643 cmd.stdout,
644 rf"(?m)^PID: {os.getpid()}\b.*\n(?: PID: .*\n)* PID: {self.threads[0].native_id}\b",
645 )
646 self.assertNotRegex(cmd.stdout, rf"(?m)^PID: {self.threads[0].native_id}\b")
647
648 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
649 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
650 self.assertIn("for_each_task_in_group(", cmd.drgn_option.stdout)
651 self.assertEqual(
652 cmd.drgn_option.globals["thread"].type_.type_name(), "struct task_struct *"
653 )
654 self._test_drgn_task_header(cmd)
655
656 def test_thread_groups_no_threads(self):
657 with fork_and_stop() as pid:
658 cmd = self.run_crash_command(f"ps -g {pid}")
659
660 self.assertIn("(no threads)", cmd.stdout)
661
662 def test_thread_groups_and_tid(self):
663 cmd = self.check_crash_command(f"ps -g {self.threads[-1].native_id}")
664
665 self.assertRegex(
666 cmd.stdout,
667 rf"(?m)^PID: {os.getpid()}\b.*\n(?: PID: .*\n)* PID: {self.threads[0].native_id}\b",
668 )
669 self.assertNotRegex(cmd.stdout, rf"(?m)^PID: {self.threads[-1].native_id}\b")
670
671 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
672 self.assertIn("task = task.group_leader", cmd.drgn_option.stdout)
673 self.assertIn("for_each_task_in_group(", cmd.drgn_option.stdout)
674 self.assertEqual(
675 cmd.drgn_option.globals["thread"].type_.type_name(), "struct task_struct *"
676 )
677 self._test_drgn_task_header(cmd)
678
679 def test_thread_groups_and_command_name(self):
680 cmd = self.check_crash_command(f"ps -g {_quoted_comm()}")
681
682 self.assertRegex(
683 cmd.stdout,
684 rf"(?m)^PID: {os.getpid()}\b.*\n(?: PID: .*\n)* PID: {self.threads[0].native_id}\b",
685 )
686 self.assertNotRegex(cmd.stdout, rf"(?m)^PID: {self.threads[0].native_id}\b")
687
688 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
689 self.assertIn("continue", cmd.drgn_option.stdout)
690 self.assertNotIn("task = task.group_leader", cmd.drgn_option.stdout)
691 self.assertIn("for_each_task_in_group(", cmd.drgn_option.stdout)
692 self.assertEqual(
693 cmd.drgn_option.globals["thread"].type_.type_name(), "struct task_struct *"
694 )
695 self._test_drgn_task_header(cmd)
696
697 def test_thread_groups_and_thread_command_name(self):
698 cmd = self.check_crash_command(
699 f"ps -g {_quoted_comm(self.threads[0].native_id)}"
700 )
701
702 self.assertNotRegex(cmd.stdout, rf"(?m)^PID: {os.getpid()}\b")
703 self.assertNotRegex(cmd.stdout, rf"(?m)^PID: {self.threads[0].native_id}\b")
704
705 self.assertIn("if not thread_group_leader(task):", cmd.drgn_option.stdout)
706 self.assertIn("continue", cmd.drgn_option.stdout)
707 self.assertNotIn("task = task.group_leader", cmd.drgn_option.stdout)
708 self.assertIn("for_each_task_in_group(", cmd.drgn_option.stdout)
709 self.assertNotIn("thread", cmd.drgn_option.globals)
710
711 def test_rlimit(self):
712 cmd = self.check_crash_command(f"ps -r {os.getpid()}")
713 foreach_cmd = self.check_crash_command(
714 f"foreach {os.getpid()} ps -r", mode="capture"
715 )
716
717 for c in (cmd, foreach_cmd):
718 for name in (
719 "CPU",
720 "FSIZE",
721 "DATA",
722 "STACK",
723 "CORE",
724 "RSS",
725 "NPROC",
726 "NOFILE",
727 "MEMLOCK",
728 "AS",
729 "LOCKS",
730 "SIGPENDING",
731 "MSGQUEUE",
732 "NICE",
733 "RTPRIO",
734 "RTTIME",
735 ):
736 self.assertRegex(
737 c.stdout, rf"(?m)^\s*{name}(?:\s+(?:[0-9]+|\(unlimited\))){{2}}$"
738 )
739
740 self.assertIn("task_rlimits(", cmd.drgn_option.stdout)
741 self.assertIsInstance(cmd.drgn_option.globals["rlimits"], dict)
742 self._test_drgn_task_header(cmd)
743
744 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
745
746 def test_summary(self):
747 cmd = self.check_crash_command("ps -S")
748 foreach_cmd = self.check_crash_command("foreach ps -S", mode="capture")
749
750 for c in (cmd, foreach_cmd):
751 self.assertRegex(c.stdout, r"^(?:\s*[A-Z]: [0-9]+)+$")
752
753 self.assertIn("task_state_to_char(", cmd.drgn_option.stdout)
754 self.assertIsInstance(cmd.drgn_option.globals["counter"], collections.Counter)
755
756 self.assertEqual(cmd.drgn_option.stdout, foreach_cmd.drgn_option.stdout)
757
758
759 class TestForeach(CrashCommandTestCase):
760 def test_help(self):
761 # The actual functionality of foreach is tested in the individual
762 # subcommands. This just tests that we properly document what
763 # subcommands are supported.
764 cmd = self.run_crash_command("help foreach")
765 match = re.search(
766 r"Currently,\s+((?:\*\*\w+\*\*,\s+)+)and\s+(\*\*\w+\*\*)\s+are\s+supported",
767 cmd.stdout,
768 )
769 self.assertTrue(match)
770 documented = (
771 (match.group(1) + match.group(2)).replace("*", "").replace(",", "").split()
772 )
773 self.assertEqual(documented, sorted(_CRASH_FOREACH_SUBCOMMANDS))