| 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)) |