1 /*- 2 * Copyright (c) 2015 John Baldwin <jhb@FreeBSD.org> 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 #include <sys/types.h> 30 #include <sys/cpuset.h> 31 #include <sys/event.h> 32 #include <sys/file.h> 33 #include <sys/time.h> 34 #include <sys/procctl.h> 35 #include <sys/procdesc.h> 36 #define _WANT_MIPS_REGNUM 37 #include <sys/ptrace.h> 38 #include <sys/queue.h> 39 #include <sys/runq.h> 40 #include <sys/syscall.h> 41 #include <sys/sysctl.h> 42 #include <sys/user.h> 43 #include <sys/wait.h> 44 #include <errno.h> 45 #include <machine/cpufunc.h> 46 #include <pthread.h> 47 #include <sched.h> 48 #include <semaphore.h> 49 #include <signal.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <unistd.h> 53 #include <atf-c.h> 54 55 /* 56 * Architectures with a user-visible breakpoint(). 57 */ 58 #if defined(__aarch64__) || defined(__amd64__) || defined(__arm__) || \ 59 defined(__i386__) || defined(__mips__) || defined(__riscv) || \ 60 defined(__sparc64__) 61 #define HAVE_BREAKPOINT 62 #endif 63 64 /* 65 * Adjust PC to skip over a breakpoint when stopped for a breakpoint trap. 66 */ 67 #ifdef HAVE_BREAKPOINT 68 #if defined(__aarch64__) 69 #define SKIP_BREAK(reg) ((reg)->elr += 4) 70 #elif defined(__amd64__) || defined(__i386__) 71 #define SKIP_BREAK(reg) 72 #elif defined(__arm__) 73 #define SKIP_BREAK(reg) ((reg)->r_pc += 4) 74 #elif defined(__mips__) 75 #define SKIP_BREAK(reg) ((reg)->r_regs[PC] += 4) 76 #elif defined(__riscv) 77 #define SKIP_BREAK(reg) ((reg)->sepc += 4) 78 #elif defined(__sparc64__) 79 #define SKIP_BREAK(reg) do { \ 80 (reg)->r_tpc = (reg)->r_tnpc + 4; \ 81 (reg)->r_tnpc += 8; \ 82 } while (0) 83 #endif 84 #endif 85 86 /* 87 * A variant of ATF_REQUIRE that is suitable for use in child 88 * processes. This only works if the parent process is tripped up by 89 * the early exit and fails some requirement itself. 90 */ 91 #define CHILD_REQUIRE(exp) do { \ 92 if (!(exp)) \ 93 child_fail_require(__FILE__, __LINE__, \ 94 #exp " not met"); \ 95 } while (0) 96 97 static __dead2 void 98 child_fail_require(const char *file, int line, const char *str) 99 { 100 char buf[128]; 101 102 snprintf(buf, sizeof(buf), "%s:%d: %s\n", file, line, str); 103 write(2, buf, strlen(buf)); 104 _exit(32); 105 } 106 107 static void 108 trace_me(void) 109 { 110 111 /* Attach the parent process as a tracer of this process. */ 112 CHILD_REQUIRE(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 113 114 /* Trigger a stop. */ 115 raise(SIGSTOP); 116 } 117 118 static void 119 attach_child(pid_t pid) 120 { 121 pid_t wpid; 122 int status; 123 124 ATF_REQUIRE(ptrace(PT_ATTACH, pid, NULL, 0) == 0); 125 126 wpid = waitpid(pid, &status, 0); 127 ATF_REQUIRE(wpid == pid); 128 ATF_REQUIRE(WIFSTOPPED(status)); 129 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 130 } 131 132 static void 133 wait_for_zombie(pid_t pid) 134 { 135 136 /* 137 * Wait for a process to exit. This is kind of gross, but 138 * there is not a better way. 139 * 140 * Prior to r325719, the kern.proc.pid.<pid> sysctl failed 141 * with ESRCH. After that change, a valid struct kinfo_proc 142 * is returned for zombies with ki_stat set to SZOMB. 143 */ 144 for (;;) { 145 struct kinfo_proc kp; 146 size_t len; 147 int mib[4]; 148 149 mib[0] = CTL_KERN; 150 mib[1] = KERN_PROC; 151 mib[2] = KERN_PROC_PID; 152 mib[3] = pid; 153 len = sizeof(kp); 154 if (sysctl(mib, nitems(mib), &kp, &len, NULL, 0) == -1) { 155 ATF_REQUIRE(errno == ESRCH); 156 break; 157 } 158 if (kp.ki_stat == SZOMB) 159 break; 160 usleep(5000); 161 } 162 } 163 164 /* 165 * Verify that a parent debugger process "sees" the exit of a debugged 166 * process exactly once when attached via PT_TRACE_ME. 167 */ 168 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_trace_me); 169 ATF_TC_BODY(ptrace__parent_wait_after_trace_me, tc) 170 { 171 pid_t child, wpid; 172 int status; 173 174 ATF_REQUIRE((child = fork()) != -1); 175 if (child == 0) { 176 /* Child process. */ 177 trace_me(); 178 179 _exit(1); 180 } 181 182 /* Parent process. */ 183 184 /* The first wait() should report the stop from SIGSTOP. */ 185 wpid = waitpid(child, &status, 0); 186 ATF_REQUIRE(wpid == child); 187 ATF_REQUIRE(WIFSTOPPED(status)); 188 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 189 190 /* Continue the child ignoring the SIGSTOP. */ 191 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 192 193 /* The second wait() should report the exit status. */ 194 wpid = waitpid(child, &status, 0); 195 ATF_REQUIRE(wpid == child); 196 ATF_REQUIRE(WIFEXITED(status)); 197 ATF_REQUIRE(WEXITSTATUS(status) == 1); 198 199 /* The child should no longer exist. */ 200 wpid = waitpid(child, &status, 0); 201 ATF_REQUIRE(wpid == -1); 202 ATF_REQUIRE(errno == ECHILD); 203 } 204 205 /* 206 * Verify that a parent debugger process "sees" the exit of a debugged 207 * process exactly once when attached via PT_ATTACH. 208 */ 209 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_attach); 210 ATF_TC_BODY(ptrace__parent_wait_after_attach, tc) 211 { 212 pid_t child, wpid; 213 int cpipe[2], status; 214 char c; 215 216 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 217 atf_tc_skip("https://bugs.freebsd.org/244055"); 218 219 ATF_REQUIRE(pipe(cpipe) == 0); 220 ATF_REQUIRE((child = fork()) != -1); 221 if (child == 0) { 222 /* Child process. */ 223 close(cpipe[0]); 224 225 /* Wait for the parent to attach. */ 226 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == 0); 227 228 _exit(1); 229 } 230 close(cpipe[1]); 231 232 /* Parent process. */ 233 234 /* Attach to the child process. */ 235 attach_child(child); 236 237 /* Continue the child ignoring the SIGSTOP. */ 238 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 239 240 /* Signal the child to exit. */ 241 close(cpipe[0]); 242 243 /* The second wait() should report the exit status. */ 244 wpid = waitpid(child, &status, 0); 245 ATF_REQUIRE(wpid == child); 246 ATF_REQUIRE(WIFEXITED(status)); 247 ATF_REQUIRE(WEXITSTATUS(status) == 1); 248 249 /* The child should no longer exist. */ 250 wpid = waitpid(child, &status, 0); 251 ATF_REQUIRE(wpid == -1); 252 ATF_REQUIRE(errno == ECHILD); 253 } 254 255 /* 256 * Verify that a parent process "sees" the exit of a debugged process only 257 * after the debugger has seen it. 258 */ 259 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_child_debugger); 260 ATF_TC_BODY(ptrace__parent_sees_exit_after_child_debugger, tc) 261 { 262 pid_t child, debugger, wpid; 263 int cpipe[2], dpipe[2], status; 264 char c; 265 266 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 267 atf_tc_skip("https://bugs.freebsd.org/239399"); 268 269 ATF_REQUIRE(pipe(cpipe) == 0); 270 ATF_REQUIRE((child = fork()) != -1); 271 272 if (child == 0) { 273 /* Child process. */ 274 close(cpipe[0]); 275 276 /* Wait for parent to be ready. */ 277 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 278 279 _exit(1); 280 } 281 close(cpipe[1]); 282 283 ATF_REQUIRE(pipe(dpipe) == 0); 284 ATF_REQUIRE((debugger = fork()) != -1); 285 286 if (debugger == 0) { 287 /* Debugger process. */ 288 close(dpipe[0]); 289 290 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 291 292 wpid = waitpid(child, &status, 0); 293 CHILD_REQUIRE(wpid == child); 294 CHILD_REQUIRE(WIFSTOPPED(status)); 295 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 296 297 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 298 299 /* Signal parent that debugger is attached. */ 300 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 301 302 /* Wait for parent's failed wait. */ 303 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == 0); 304 305 wpid = waitpid(child, &status, 0); 306 CHILD_REQUIRE(wpid == child); 307 CHILD_REQUIRE(WIFEXITED(status)); 308 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 309 310 _exit(0); 311 } 312 close(dpipe[1]); 313 314 /* Parent process. */ 315 316 /* Wait for the debugger to attach to the child. */ 317 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 318 319 /* Release the child. */ 320 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 321 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 322 close(cpipe[0]); 323 324 wait_for_zombie(child); 325 326 /* 327 * This wait should return a pid of 0 to indicate no status to 328 * report. The parent should see the child as non-exited 329 * until the debugger sees the exit. 330 */ 331 wpid = waitpid(child, &status, WNOHANG); 332 ATF_REQUIRE(wpid == 0); 333 334 /* Signal the debugger to wait for the child. */ 335 close(dpipe[0]); 336 337 /* Wait for the debugger. */ 338 wpid = waitpid(debugger, &status, 0); 339 ATF_REQUIRE(wpid == debugger); 340 ATF_REQUIRE(WIFEXITED(status)); 341 ATF_REQUIRE(WEXITSTATUS(status) == 0); 342 343 /* The child process should now be ready. */ 344 wpid = waitpid(child, &status, WNOHANG); 345 ATF_REQUIRE(wpid == child); 346 ATF_REQUIRE(WIFEXITED(status)); 347 ATF_REQUIRE(WEXITSTATUS(status) == 1); 348 } 349 350 /* 351 * Verify that a parent process "sees" the exit of a debugged process 352 * only after a non-direct-child debugger has seen it. In particular, 353 * various wait() calls in the parent must avoid failing with ESRCH by 354 * checking the parent's orphan list for the debugee. 355 */ 356 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_unrelated_debugger); 357 ATF_TC_BODY(ptrace__parent_sees_exit_after_unrelated_debugger, tc) 358 { 359 pid_t child, debugger, fpid, wpid; 360 int cpipe[2], dpipe[2], status; 361 char c; 362 363 ATF_REQUIRE(pipe(cpipe) == 0); 364 ATF_REQUIRE((child = fork()) != -1); 365 366 if (child == 0) { 367 /* Child process. */ 368 close(cpipe[0]); 369 370 /* Wait for parent to be ready. */ 371 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 372 373 _exit(1); 374 } 375 close(cpipe[1]); 376 377 ATF_REQUIRE(pipe(dpipe) == 0); 378 ATF_REQUIRE((debugger = fork()) != -1); 379 380 if (debugger == 0) { 381 /* Debugger parent. */ 382 383 /* 384 * Fork again and drop the debugger parent so that the 385 * debugger is not a child of the main parent. 386 */ 387 CHILD_REQUIRE((fpid = fork()) != -1); 388 if (fpid != 0) 389 _exit(2); 390 391 /* Debugger process. */ 392 close(dpipe[0]); 393 394 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 395 396 wpid = waitpid(child, &status, 0); 397 CHILD_REQUIRE(wpid == child); 398 CHILD_REQUIRE(WIFSTOPPED(status)); 399 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 400 401 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 402 403 /* Signal parent that debugger is attached. */ 404 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 405 406 /* Wait for parent's failed wait. */ 407 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == sizeof(c)); 408 409 wpid = waitpid(child, &status, 0); 410 CHILD_REQUIRE(wpid == child); 411 CHILD_REQUIRE(WIFEXITED(status)); 412 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 413 414 _exit(0); 415 } 416 close(dpipe[1]); 417 418 /* Parent process. */ 419 420 /* Wait for the debugger parent process to exit. */ 421 wpid = waitpid(debugger, &status, 0); 422 ATF_REQUIRE(wpid == debugger); 423 ATF_REQUIRE(WIFEXITED(status)); 424 ATF_REQUIRE(WEXITSTATUS(status) == 2); 425 426 /* A WNOHANG wait here should see the non-exited child. */ 427 wpid = waitpid(child, &status, WNOHANG); 428 ATF_REQUIRE(wpid == 0); 429 430 /* Wait for the debugger to attach to the child. */ 431 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 432 433 /* Release the child. */ 434 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 435 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 436 close(cpipe[0]); 437 438 wait_for_zombie(child); 439 440 /* 441 * This wait should return a pid of 0 to indicate no status to 442 * report. The parent should see the child as non-exited 443 * until the debugger sees the exit. 444 */ 445 wpid = waitpid(child, &status, WNOHANG); 446 ATF_REQUIRE(wpid == 0); 447 448 /* Signal the debugger to wait for the child. */ 449 ATF_REQUIRE(write(dpipe[0], &c, sizeof(c)) == sizeof(c)); 450 451 /* Wait for the debugger. */ 452 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == 0); 453 close(dpipe[0]); 454 455 /* The child process should now be ready. */ 456 wpid = waitpid(child, &status, WNOHANG); 457 ATF_REQUIRE(wpid == child); 458 ATF_REQUIRE(WIFEXITED(status)); 459 ATF_REQUIRE(WEXITSTATUS(status) == 1); 460 } 461 462 /* 463 * Make sure that we can collect the exit status of an orphaned process. 464 */ 465 ATF_TC_WITHOUT_HEAD(ptrace__parent_exits_before_child); 466 ATF_TC_BODY(ptrace__parent_exits_before_child, tc) 467 { 468 ssize_t n; 469 int cpipe1[2], cpipe2[2], gcpipe[2], status; 470 pid_t child, gchild; 471 472 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 473 atf_tc_skip("https://bugs.freebsd.org/244056"); 474 475 ATF_REQUIRE(pipe(cpipe1) == 0); 476 ATF_REQUIRE(pipe(cpipe2) == 0); 477 ATF_REQUIRE(pipe(gcpipe) == 0); 478 479 ATF_REQUIRE(procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0); 480 481 ATF_REQUIRE((child = fork()) != -1); 482 if (child == 0) { 483 CHILD_REQUIRE((gchild = fork()) != -1); 484 if (gchild == 0) { 485 status = 1; 486 do { 487 n = read(gcpipe[0], &status, sizeof(status)); 488 } while (n == -1 && errno == EINTR); 489 _exit(status); 490 } 491 492 CHILD_REQUIRE(write(cpipe1[1], &gchild, sizeof(gchild)) == 493 sizeof(gchild)); 494 CHILD_REQUIRE(read(cpipe2[0], &status, sizeof(status)) == 495 sizeof(status)); 496 _exit(status); 497 } 498 499 ATF_REQUIRE(read(cpipe1[0], &gchild, sizeof(gchild)) == sizeof(gchild)); 500 501 ATF_REQUIRE(ptrace(PT_ATTACH, gchild, NULL, 0) == 0); 502 503 status = 0; 504 ATF_REQUIRE(write(cpipe2[1], &status, sizeof(status)) == 505 sizeof(status)); 506 ATF_REQUIRE(waitpid(child, &status, 0) == child); 507 ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 0); 508 509 status = 0; 510 ATF_REQUIRE(write(gcpipe[1], &status, sizeof(status)) == 511 sizeof(status)); 512 ATF_REQUIRE(waitpid(gchild, &status, 0) == gchild); 513 ATF_REQUIRE(WIFSTOPPED(status)); 514 ATF_REQUIRE(ptrace(PT_DETACH, gchild, (caddr_t)1, 0) == 0); 515 ATF_REQUIRE(waitpid(gchild, &status, 0) == gchild); 516 ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 0); 517 518 ATF_REQUIRE(close(cpipe1[0]) == 0); 519 ATF_REQUIRE(close(cpipe1[1]) == 0); 520 ATF_REQUIRE(close(cpipe2[0]) == 0); 521 ATF_REQUIRE(close(cpipe2[1]) == 0); 522 ATF_REQUIRE(close(gcpipe[0]) == 0); 523 ATF_REQUIRE(close(gcpipe[1]) == 0); 524 } 525 526 /* 527 * The parent process should always act the same regardless of how the 528 * debugger is attached to it. 529 */ 530 static __dead2 void 531 follow_fork_parent(bool use_vfork) 532 { 533 pid_t fpid, wpid; 534 int status; 535 536 if (use_vfork) 537 CHILD_REQUIRE((fpid = vfork()) != -1); 538 else 539 CHILD_REQUIRE((fpid = fork()) != -1); 540 541 if (fpid == 0) 542 /* Child */ 543 _exit(2); 544 545 wpid = waitpid(fpid, &status, 0); 546 CHILD_REQUIRE(wpid == fpid); 547 CHILD_REQUIRE(WIFEXITED(status)); 548 CHILD_REQUIRE(WEXITSTATUS(status) == 2); 549 550 _exit(1); 551 } 552 553 /* 554 * Helper routine for follow fork tests. This waits for two stops 555 * that report both "sides" of a fork. It returns the pid of the new 556 * child process. 557 */ 558 static pid_t 559 handle_fork_events(pid_t parent, struct ptrace_lwpinfo *ppl) 560 { 561 struct ptrace_lwpinfo pl; 562 bool fork_reported[2]; 563 pid_t child, wpid; 564 int i, status; 565 566 fork_reported[0] = false; 567 fork_reported[1] = false; 568 child = -1; 569 570 /* 571 * Each process should report a fork event. The parent should 572 * report a PL_FLAG_FORKED event, and the child should report 573 * a PL_FLAG_CHILD event. 574 */ 575 for (i = 0; i < 2; i++) { 576 wpid = wait(&status); 577 ATF_REQUIRE(wpid > 0); 578 ATF_REQUIRE(WIFSTOPPED(status)); 579 580 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 581 sizeof(pl)) != -1); 582 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 583 0); 584 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 585 (PL_FLAG_FORKED | PL_FLAG_CHILD)); 586 if (pl.pl_flags & PL_FLAG_CHILD) { 587 ATF_REQUIRE(wpid != parent); 588 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 589 ATF_REQUIRE(!fork_reported[1]); 590 if (child == -1) 591 child = wpid; 592 else 593 ATF_REQUIRE(child == wpid); 594 if (ppl != NULL) 595 ppl[1] = pl; 596 fork_reported[1] = true; 597 } else { 598 ATF_REQUIRE(wpid == parent); 599 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 600 ATF_REQUIRE(!fork_reported[0]); 601 if (child == -1) 602 child = pl.pl_child_pid; 603 else 604 ATF_REQUIRE(child == pl.pl_child_pid); 605 if (ppl != NULL) 606 ppl[0] = pl; 607 fork_reported[0] = true; 608 } 609 } 610 611 return (child); 612 } 613 614 /* 615 * Verify that a new child process is stopped after a followed fork and 616 * that the traced parent sees the exit of the child after the debugger 617 * when both processes remain attached to the debugger. 618 */ 619 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached); 620 ATF_TC_BODY(ptrace__follow_fork_both_attached, tc) 621 { 622 pid_t children[2], fpid, wpid; 623 int status; 624 625 ATF_REQUIRE((fpid = fork()) != -1); 626 if (fpid == 0) { 627 trace_me(); 628 follow_fork_parent(false); 629 } 630 631 /* Parent process. */ 632 children[0] = fpid; 633 634 /* The first wait() should report the stop from SIGSTOP. */ 635 wpid = waitpid(children[0], &status, 0); 636 ATF_REQUIRE(wpid == children[0]); 637 ATF_REQUIRE(WIFSTOPPED(status)); 638 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 639 640 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 641 642 /* Continue the child ignoring the SIGSTOP. */ 643 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 644 645 children[1] = handle_fork_events(children[0], NULL); 646 ATF_REQUIRE(children[1] > 0); 647 648 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 649 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 650 651 /* 652 * The child can't exit until the grandchild reports status, so the 653 * grandchild should report its exit first to the debugger. 654 */ 655 wpid = wait(&status); 656 ATF_REQUIRE(wpid == children[1]); 657 ATF_REQUIRE(WIFEXITED(status)); 658 ATF_REQUIRE(WEXITSTATUS(status) == 2); 659 660 wpid = wait(&status); 661 ATF_REQUIRE(wpid == children[0]); 662 ATF_REQUIRE(WIFEXITED(status)); 663 ATF_REQUIRE(WEXITSTATUS(status) == 1); 664 665 wpid = wait(&status); 666 ATF_REQUIRE(wpid == -1); 667 ATF_REQUIRE(errno == ECHILD); 668 } 669 670 /* 671 * Verify that a new child process is stopped after a followed fork 672 * and that the traced parent sees the exit of the child when the new 673 * child process is detached after it reports its fork. 674 */ 675 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached); 676 ATF_TC_BODY(ptrace__follow_fork_child_detached, tc) 677 { 678 pid_t children[2], fpid, wpid; 679 int status; 680 681 ATF_REQUIRE((fpid = fork()) != -1); 682 if (fpid == 0) { 683 trace_me(); 684 follow_fork_parent(false); 685 } 686 687 /* Parent process. */ 688 children[0] = fpid; 689 690 /* The first wait() should report the stop from SIGSTOP. */ 691 wpid = waitpid(children[0], &status, 0); 692 ATF_REQUIRE(wpid == children[0]); 693 ATF_REQUIRE(WIFSTOPPED(status)); 694 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 695 696 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 697 698 /* Continue the child ignoring the SIGSTOP. */ 699 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 700 701 children[1] = handle_fork_events(children[0], NULL); 702 ATF_REQUIRE(children[1] > 0); 703 704 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 705 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 706 707 /* 708 * Should not see any status from the grandchild now, only the 709 * child. 710 */ 711 wpid = wait(&status); 712 ATF_REQUIRE(wpid == children[0]); 713 ATF_REQUIRE(WIFEXITED(status)); 714 ATF_REQUIRE(WEXITSTATUS(status) == 1); 715 716 wpid = wait(&status); 717 ATF_REQUIRE(wpid == -1); 718 ATF_REQUIRE(errno == ECHILD); 719 } 720 721 /* 722 * Verify that a new child process is stopped after a followed fork 723 * and that the traced parent sees the exit of the child when the 724 * traced parent is detached after the fork. 725 */ 726 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached); 727 ATF_TC_BODY(ptrace__follow_fork_parent_detached, tc) 728 { 729 pid_t children[2], fpid, wpid; 730 int status; 731 732 ATF_REQUIRE((fpid = fork()) != -1); 733 if (fpid == 0) { 734 trace_me(); 735 follow_fork_parent(false); 736 } 737 738 /* Parent process. */ 739 children[0] = fpid; 740 741 /* The first wait() should report the stop from SIGSTOP. */ 742 wpid = waitpid(children[0], &status, 0); 743 ATF_REQUIRE(wpid == children[0]); 744 ATF_REQUIRE(WIFSTOPPED(status)); 745 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 746 747 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 748 749 /* Continue the child ignoring the SIGSTOP. */ 750 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 751 752 children[1] = handle_fork_events(children[0], NULL); 753 ATF_REQUIRE(children[1] > 0); 754 755 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 756 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 757 758 /* 759 * The child can't exit until the grandchild reports status, so the 760 * grandchild should report its exit first to the debugger. 761 * 762 * Even though the child process is detached, it is still a 763 * child of the debugger, so it will still report it's exit 764 * after the grandchild. 765 */ 766 wpid = wait(&status); 767 ATF_REQUIRE(wpid == children[1]); 768 ATF_REQUIRE(WIFEXITED(status)); 769 ATF_REQUIRE(WEXITSTATUS(status) == 2); 770 771 wpid = wait(&status); 772 ATF_REQUIRE(wpid == children[0]); 773 ATF_REQUIRE(WIFEXITED(status)); 774 ATF_REQUIRE(WEXITSTATUS(status) == 1); 775 776 wpid = wait(&status); 777 ATF_REQUIRE(wpid == -1); 778 ATF_REQUIRE(errno == ECHILD); 779 } 780 781 static void 782 attach_fork_parent(int cpipe[2]) 783 { 784 pid_t fpid; 785 786 close(cpipe[0]); 787 788 /* Double-fork to disassociate from the debugger. */ 789 CHILD_REQUIRE((fpid = fork()) != -1); 790 if (fpid != 0) 791 _exit(3); 792 793 /* Send the pid of the disassociated child to the debugger. */ 794 fpid = getpid(); 795 CHILD_REQUIRE(write(cpipe[1], &fpid, sizeof(fpid)) == sizeof(fpid)); 796 797 /* Wait for the debugger to attach. */ 798 CHILD_REQUIRE(read(cpipe[1], &fpid, sizeof(fpid)) == 0); 799 } 800 801 /* 802 * Verify that a new child process is stopped after a followed fork and 803 * that the traced parent sees the exit of the child after the debugger 804 * when both processes remain attached to the debugger. In this test 805 * the parent that forks is not a direct child of the debugger. 806 */ 807 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached_unrelated_debugger); 808 ATF_TC_BODY(ptrace__follow_fork_both_attached_unrelated_debugger, tc) 809 { 810 pid_t children[2], fpid, wpid; 811 int cpipe[2], status; 812 813 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 814 atf_tc_skip("https://bugs.freebsd.org/239397"); 815 816 ATF_REQUIRE(pipe(cpipe) == 0); 817 ATF_REQUIRE((fpid = fork()) != -1); 818 if (fpid == 0) { 819 attach_fork_parent(cpipe); 820 follow_fork_parent(false); 821 } 822 823 /* Parent process. */ 824 close(cpipe[1]); 825 826 /* Wait for the direct child to exit. */ 827 wpid = waitpid(fpid, &status, 0); 828 ATF_REQUIRE(wpid == fpid); 829 ATF_REQUIRE(WIFEXITED(status)); 830 ATF_REQUIRE(WEXITSTATUS(status) == 3); 831 832 /* Read the pid of the fork parent. */ 833 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 834 sizeof(children[0])); 835 836 /* Attach to the fork parent. */ 837 attach_child(children[0]); 838 839 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 840 841 /* Continue the fork parent ignoring the SIGSTOP. */ 842 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 843 844 /* Signal the fork parent to continue. */ 845 close(cpipe[0]); 846 847 children[1] = handle_fork_events(children[0], NULL); 848 ATF_REQUIRE(children[1] > 0); 849 850 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 851 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 852 853 /* 854 * The fork parent can't exit until the child reports status, 855 * so the child should report its exit first to the debugger. 856 */ 857 wpid = wait(&status); 858 ATF_REQUIRE(wpid == children[1]); 859 ATF_REQUIRE(WIFEXITED(status)); 860 ATF_REQUIRE(WEXITSTATUS(status) == 2); 861 862 wpid = wait(&status); 863 ATF_REQUIRE(wpid == children[0]); 864 ATF_REQUIRE(WIFEXITED(status)); 865 ATF_REQUIRE(WEXITSTATUS(status) == 1); 866 867 wpid = wait(&status); 868 ATF_REQUIRE(wpid == -1); 869 ATF_REQUIRE(errno == ECHILD); 870 } 871 872 /* 873 * Verify that a new child process is stopped after a followed fork 874 * and that the traced parent sees the exit of the child when the new 875 * child process is detached after it reports its fork. In this test 876 * the parent that forks is not a direct child of the debugger. 877 */ 878 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached_unrelated_debugger); 879 ATF_TC_BODY(ptrace__follow_fork_child_detached_unrelated_debugger, tc) 880 { 881 pid_t children[2], fpid, wpid; 882 int cpipe[2], status; 883 884 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 885 atf_tc_skip("https://bugs.freebsd.org/239292"); 886 887 ATF_REQUIRE(pipe(cpipe) == 0); 888 ATF_REQUIRE((fpid = fork()) != -1); 889 if (fpid == 0) { 890 attach_fork_parent(cpipe); 891 follow_fork_parent(false); 892 } 893 894 /* Parent process. */ 895 close(cpipe[1]); 896 897 /* Wait for the direct child to exit. */ 898 wpid = waitpid(fpid, &status, 0); 899 ATF_REQUIRE(wpid == fpid); 900 ATF_REQUIRE(WIFEXITED(status)); 901 ATF_REQUIRE(WEXITSTATUS(status) == 3); 902 903 /* Read the pid of the fork parent. */ 904 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 905 sizeof(children[0])); 906 907 /* Attach to the fork parent. */ 908 attach_child(children[0]); 909 910 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 911 912 /* Continue the fork parent ignoring the SIGSTOP. */ 913 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 914 915 /* Signal the fork parent to continue. */ 916 close(cpipe[0]); 917 918 children[1] = handle_fork_events(children[0], NULL); 919 ATF_REQUIRE(children[1] > 0); 920 921 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 922 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 923 924 /* 925 * Should not see any status from the child now, only the fork 926 * parent. 927 */ 928 wpid = wait(&status); 929 ATF_REQUIRE(wpid == children[0]); 930 ATF_REQUIRE(WIFEXITED(status)); 931 ATF_REQUIRE(WEXITSTATUS(status) == 1); 932 933 wpid = wait(&status); 934 ATF_REQUIRE(wpid == -1); 935 ATF_REQUIRE(errno == ECHILD); 936 } 937 938 /* 939 * Verify that a new child process is stopped after a followed fork 940 * and that the traced parent sees the exit of the child when the 941 * traced parent is detached after the fork. In this test the parent 942 * that forks is not a direct child of the debugger. 943 */ 944 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached_unrelated_debugger); 945 ATF_TC_BODY(ptrace__follow_fork_parent_detached_unrelated_debugger, tc) 946 { 947 pid_t children[2], fpid, wpid; 948 int cpipe[2], status; 949 950 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 951 atf_tc_skip("https://bugs.freebsd.org/239425"); 952 953 ATF_REQUIRE(pipe(cpipe) == 0); 954 ATF_REQUIRE((fpid = fork()) != -1); 955 if (fpid == 0) { 956 attach_fork_parent(cpipe); 957 follow_fork_parent(false); 958 } 959 960 /* Parent process. */ 961 close(cpipe[1]); 962 963 /* Wait for the direct child to exit. */ 964 wpid = waitpid(fpid, &status, 0); 965 ATF_REQUIRE(wpid == fpid); 966 ATF_REQUIRE(WIFEXITED(status)); 967 ATF_REQUIRE(WEXITSTATUS(status) == 3); 968 969 /* Read the pid of the fork parent. */ 970 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 971 sizeof(children[0])); 972 973 /* Attach to the fork parent. */ 974 attach_child(children[0]); 975 976 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 977 978 /* Continue the fork parent ignoring the SIGSTOP. */ 979 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 980 981 /* Signal the fork parent to continue. */ 982 close(cpipe[0]); 983 984 children[1] = handle_fork_events(children[0], NULL); 985 ATF_REQUIRE(children[1] > 0); 986 987 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 988 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 989 990 /* 991 * Should not see any status from the fork parent now, only 992 * the child. 993 */ 994 wpid = wait(&status); 995 ATF_REQUIRE(wpid == children[1]); 996 ATF_REQUIRE(WIFEXITED(status)); 997 ATF_REQUIRE(WEXITSTATUS(status) == 2); 998 999 wpid = wait(&status); 1000 ATF_REQUIRE(wpid == -1); 1001 ATF_REQUIRE(errno == ECHILD); 1002 } 1003 1004 /* 1005 * Verify that a child process does not see an unrelated debugger as its 1006 * parent but sees its original parent process. 1007 */ 1008 ATF_TC_WITHOUT_HEAD(ptrace__getppid); 1009 ATF_TC_BODY(ptrace__getppid, tc) 1010 { 1011 pid_t child, debugger, ppid, wpid; 1012 int cpipe[2], dpipe[2], status; 1013 char c; 1014 1015 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 1016 atf_tc_skip("https://bugs.freebsd.org/240510"); 1017 1018 1019 ATF_REQUIRE(pipe(cpipe) == 0); 1020 ATF_REQUIRE((child = fork()) != -1); 1021 1022 if (child == 0) { 1023 /* Child process. */ 1024 close(cpipe[0]); 1025 1026 /* Wait for parent to be ready. */ 1027 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 1028 1029 /* Report the parent PID to the parent. */ 1030 ppid = getppid(); 1031 CHILD_REQUIRE(write(cpipe[1], &ppid, sizeof(ppid)) == 1032 sizeof(ppid)); 1033 1034 _exit(1); 1035 } 1036 close(cpipe[1]); 1037 1038 ATF_REQUIRE(pipe(dpipe) == 0); 1039 ATF_REQUIRE((debugger = fork()) != -1); 1040 1041 if (debugger == 0) { 1042 /* Debugger process. */ 1043 close(dpipe[0]); 1044 1045 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 1046 1047 wpid = waitpid(child, &status, 0); 1048 CHILD_REQUIRE(wpid == child); 1049 CHILD_REQUIRE(WIFSTOPPED(status)); 1050 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1051 1052 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 1053 1054 /* Signal parent that debugger is attached. */ 1055 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 1056 1057 /* Wait for traced child to exit. */ 1058 wpid = waitpid(child, &status, 0); 1059 CHILD_REQUIRE(wpid == child); 1060 CHILD_REQUIRE(WIFEXITED(status)); 1061 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 1062 1063 _exit(0); 1064 } 1065 close(dpipe[1]); 1066 1067 /* Parent process. */ 1068 1069 /* Wait for the debugger to attach to the child. */ 1070 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 1071 1072 /* Release the child. */ 1073 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 1074 1075 /* Read the parent PID from the child. */ 1076 ATF_REQUIRE(read(cpipe[0], &ppid, sizeof(ppid)) == sizeof(ppid)); 1077 close(cpipe[0]); 1078 1079 ATF_REQUIRE(ppid == getpid()); 1080 1081 /* Wait for the debugger. */ 1082 wpid = waitpid(debugger, &status, 0); 1083 ATF_REQUIRE(wpid == debugger); 1084 ATF_REQUIRE(WIFEXITED(status)); 1085 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1086 1087 /* The child process should now be ready. */ 1088 wpid = waitpid(child, &status, WNOHANG); 1089 ATF_REQUIRE(wpid == child); 1090 ATF_REQUIRE(WIFEXITED(status)); 1091 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1092 } 1093 1094 /* 1095 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 1096 * child process created via fork() reports the correct value. 1097 */ 1098 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_fork); 1099 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_fork, tc) 1100 { 1101 struct ptrace_lwpinfo pl[2]; 1102 pid_t children[2], fpid, wpid; 1103 int status; 1104 1105 ATF_REQUIRE((fpid = fork()) != -1); 1106 if (fpid == 0) { 1107 trace_me(); 1108 follow_fork_parent(false); 1109 } 1110 1111 /* Parent process. */ 1112 children[0] = fpid; 1113 1114 /* The first wait() should report the stop from SIGSTOP. */ 1115 wpid = waitpid(children[0], &status, 0); 1116 ATF_REQUIRE(wpid == children[0]); 1117 ATF_REQUIRE(WIFSTOPPED(status)); 1118 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1119 1120 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 1121 1122 /* Continue the child ignoring the SIGSTOP. */ 1123 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1124 1125 /* Wait for both halves of the fork event to get reported. */ 1126 children[1] = handle_fork_events(children[0], pl); 1127 ATF_REQUIRE(children[1] > 0); 1128 1129 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0); 1130 ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0); 1131 ATF_REQUIRE(pl[0].pl_syscall_code == SYS_fork); 1132 ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code); 1133 ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg); 1134 1135 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1136 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 1137 1138 /* 1139 * The child can't exit until the grandchild reports status, so the 1140 * grandchild should report its exit first to the debugger. 1141 */ 1142 wpid = wait(&status); 1143 ATF_REQUIRE(wpid == children[1]); 1144 ATF_REQUIRE(WIFEXITED(status)); 1145 ATF_REQUIRE(WEXITSTATUS(status) == 2); 1146 1147 wpid = wait(&status); 1148 ATF_REQUIRE(wpid == children[0]); 1149 ATF_REQUIRE(WIFEXITED(status)); 1150 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1151 1152 wpid = wait(&status); 1153 ATF_REQUIRE(wpid == -1); 1154 ATF_REQUIRE(errno == ECHILD); 1155 } 1156 1157 /* 1158 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 1159 * child process created via vfork() reports the correct value. 1160 */ 1161 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_vfork); 1162 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_vfork, tc) 1163 { 1164 struct ptrace_lwpinfo pl[2]; 1165 pid_t children[2], fpid, wpid; 1166 int status; 1167 1168 ATF_REQUIRE((fpid = fork()) != -1); 1169 if (fpid == 0) { 1170 trace_me(); 1171 follow_fork_parent(true); 1172 } 1173 1174 /* Parent process. */ 1175 children[0] = fpid; 1176 1177 /* The first wait() should report the stop from SIGSTOP. */ 1178 wpid = waitpid(children[0], &status, 0); 1179 ATF_REQUIRE(wpid == children[0]); 1180 ATF_REQUIRE(WIFSTOPPED(status)); 1181 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1182 1183 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 1184 1185 /* Continue the child ignoring the SIGSTOP. */ 1186 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1187 1188 /* Wait for both halves of the fork event to get reported. */ 1189 children[1] = handle_fork_events(children[0], pl); 1190 ATF_REQUIRE(children[1] > 0); 1191 1192 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0); 1193 ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0); 1194 ATF_REQUIRE(pl[0].pl_syscall_code == SYS_vfork); 1195 ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code); 1196 ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg); 1197 1198 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1199 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 1200 1201 /* 1202 * The child can't exit until the grandchild reports status, so the 1203 * grandchild should report its exit first to the debugger. 1204 */ 1205 wpid = wait(&status); 1206 ATF_REQUIRE(wpid == children[1]); 1207 ATF_REQUIRE(WIFEXITED(status)); 1208 ATF_REQUIRE(WEXITSTATUS(status) == 2); 1209 1210 wpid = wait(&status); 1211 ATF_REQUIRE(wpid == children[0]); 1212 ATF_REQUIRE(WIFEXITED(status)); 1213 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1214 1215 wpid = wait(&status); 1216 ATF_REQUIRE(wpid == -1); 1217 ATF_REQUIRE(errno == ECHILD); 1218 } 1219 1220 static void * 1221 simple_thread(void *arg __unused) 1222 { 1223 1224 pthread_exit(NULL); 1225 } 1226 1227 static __dead2 void 1228 simple_thread_main(void) 1229 { 1230 pthread_t thread; 1231 1232 CHILD_REQUIRE(pthread_create(&thread, NULL, simple_thread, NULL) == 0); 1233 CHILD_REQUIRE(pthread_join(thread, NULL) == 0); 1234 exit(1); 1235 } 1236 1237 /* 1238 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 1239 * thread reports the correct value. 1240 */ 1241 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_thread); 1242 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_thread, tc) 1243 { 1244 struct ptrace_lwpinfo pl; 1245 pid_t fpid, wpid; 1246 lwpid_t mainlwp; 1247 int status; 1248 1249 ATF_REQUIRE((fpid = fork()) != -1); 1250 if (fpid == 0) { 1251 trace_me(); 1252 simple_thread_main(); 1253 } 1254 1255 /* The first wait() should report the stop from SIGSTOP. */ 1256 wpid = waitpid(fpid, &status, 0); 1257 ATF_REQUIRE(wpid == fpid); 1258 ATF_REQUIRE(WIFSTOPPED(status)); 1259 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1260 1261 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1262 sizeof(pl)) != -1); 1263 mainlwp = pl.pl_lwpid; 1264 1265 /* 1266 * Continue the child ignoring the SIGSTOP and tracing all 1267 * system call exits. 1268 */ 1269 ATF_REQUIRE(ptrace(PT_TO_SCX, fpid, (caddr_t)1, 0) != -1); 1270 1271 /* 1272 * Wait for the new thread to arrive. pthread_create() might 1273 * invoke any number of system calls. For now we just wait 1274 * for the new thread to arrive and make sure it reports a 1275 * valid system call code. If ptrace grows thread event 1276 * reporting then this test can be made more precise. 1277 */ 1278 for (;;) { 1279 wpid = waitpid(fpid, &status, 0); 1280 ATF_REQUIRE(wpid == fpid); 1281 ATF_REQUIRE(WIFSTOPPED(status)); 1282 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1283 1284 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1285 sizeof(pl)) != -1); 1286 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SCX) != 0); 1287 ATF_REQUIRE(pl.pl_syscall_code != 0); 1288 if (pl.pl_lwpid != mainlwp) 1289 /* New thread seen. */ 1290 break; 1291 1292 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1293 } 1294 1295 /* Wait for the child to exit. */ 1296 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1297 for (;;) { 1298 wpid = waitpid(fpid, &status, 0); 1299 ATF_REQUIRE(wpid == fpid); 1300 if (WIFEXITED(status)) 1301 break; 1302 1303 ATF_REQUIRE(WIFSTOPPED(status)); 1304 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1305 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1306 } 1307 1308 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1309 1310 wpid = wait(&status); 1311 ATF_REQUIRE(wpid == -1); 1312 ATF_REQUIRE(errno == ECHILD); 1313 } 1314 1315 /* 1316 * Verify that the expected LWP events are reported for a child thread. 1317 */ 1318 ATF_TC_WITHOUT_HEAD(ptrace__lwp_events); 1319 ATF_TC_BODY(ptrace__lwp_events, tc) 1320 { 1321 struct ptrace_lwpinfo pl; 1322 pid_t fpid, wpid; 1323 lwpid_t lwps[2]; 1324 int status; 1325 1326 ATF_REQUIRE((fpid = fork()) != -1); 1327 if (fpid == 0) { 1328 trace_me(); 1329 simple_thread_main(); 1330 } 1331 1332 /* The first wait() should report the stop from SIGSTOP. */ 1333 wpid = waitpid(fpid, &status, 0); 1334 ATF_REQUIRE(wpid == fpid); 1335 ATF_REQUIRE(WIFSTOPPED(status)); 1336 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1337 1338 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1339 sizeof(pl)) != -1); 1340 lwps[0] = pl.pl_lwpid; 1341 1342 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1343 1344 /* Continue the child ignoring the SIGSTOP. */ 1345 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1346 1347 /* The first event should be for the child thread's birth. */ 1348 wpid = waitpid(fpid, &status, 0); 1349 ATF_REQUIRE(wpid == fpid); 1350 ATF_REQUIRE(WIFSTOPPED(status)); 1351 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1352 1353 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1354 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1355 (PL_FLAG_BORN | PL_FLAG_SCX)); 1356 ATF_REQUIRE(pl.pl_lwpid != lwps[0]); 1357 lwps[1] = pl.pl_lwpid; 1358 1359 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1360 1361 /* The next event should be for the child thread's death. */ 1362 wpid = waitpid(fpid, &status, 0); 1363 ATF_REQUIRE(wpid == fpid); 1364 ATF_REQUIRE(WIFSTOPPED(status)); 1365 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1366 1367 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1368 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) == 1369 (PL_FLAG_EXITED | PL_FLAG_SCE)); 1370 ATF_REQUIRE(pl.pl_lwpid == lwps[1]); 1371 1372 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1373 1374 /* The last event should be for the child process's exit. */ 1375 wpid = waitpid(fpid, &status, 0); 1376 ATF_REQUIRE(WIFEXITED(status)); 1377 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1378 1379 wpid = wait(&status); 1380 ATF_REQUIRE(wpid == -1); 1381 ATF_REQUIRE(errno == ECHILD); 1382 } 1383 1384 static void * 1385 exec_thread(void *arg __unused) 1386 { 1387 1388 execl("/usr/bin/true", "true", NULL); 1389 exit(127); 1390 } 1391 1392 static __dead2 void 1393 exec_thread_main(void) 1394 { 1395 pthread_t thread; 1396 1397 CHILD_REQUIRE(pthread_create(&thread, NULL, exec_thread, NULL) == 0); 1398 for (;;) 1399 sleep(60); 1400 exit(1); 1401 } 1402 1403 /* 1404 * Verify that the expected LWP events are reported for a multithreaded 1405 * process that calls execve(2). 1406 */ 1407 ATF_TC_WITHOUT_HEAD(ptrace__lwp_events_exec); 1408 ATF_TC_BODY(ptrace__lwp_events_exec, tc) 1409 { 1410 struct ptrace_lwpinfo pl; 1411 pid_t fpid, wpid; 1412 lwpid_t lwps[2]; 1413 int status; 1414 1415 ATF_REQUIRE((fpid = fork()) != -1); 1416 if (fpid == 0) { 1417 trace_me(); 1418 exec_thread_main(); 1419 } 1420 1421 /* The first wait() should report the stop from SIGSTOP. */ 1422 wpid = waitpid(fpid, &status, 0); 1423 ATF_REQUIRE(wpid == fpid); 1424 ATF_REQUIRE(WIFSTOPPED(status)); 1425 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1426 1427 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1428 sizeof(pl)) != -1); 1429 lwps[0] = pl.pl_lwpid; 1430 1431 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1432 1433 /* Continue the child ignoring the SIGSTOP. */ 1434 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1435 1436 /* The first event should be for the child thread's birth. */ 1437 wpid = waitpid(fpid, &status, 0); 1438 ATF_REQUIRE(wpid == fpid); 1439 ATF_REQUIRE(WIFSTOPPED(status)); 1440 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1441 1442 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1443 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1444 (PL_FLAG_BORN | PL_FLAG_SCX)); 1445 ATF_REQUIRE(pl.pl_lwpid != lwps[0]); 1446 lwps[1] = pl.pl_lwpid; 1447 1448 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1449 1450 /* 1451 * The next event should be for the main thread's death due to 1452 * single threading from execve(). 1453 */ 1454 wpid = waitpid(fpid, &status, 0); 1455 ATF_REQUIRE(wpid == fpid); 1456 ATF_REQUIRE(WIFSTOPPED(status)); 1457 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1458 1459 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1460 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) == 1461 (PL_FLAG_EXITED)); 1462 ATF_REQUIRE(pl.pl_lwpid == lwps[0]); 1463 1464 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1465 1466 /* The next event should be for the child process's exec. */ 1467 wpid = waitpid(fpid, &status, 0); 1468 ATF_REQUIRE(WIFSTOPPED(status)); 1469 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1470 1471 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1472 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) == 1473 (PL_FLAG_EXEC | PL_FLAG_SCX)); 1474 ATF_REQUIRE(pl.pl_lwpid == lwps[1]); 1475 1476 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1477 1478 /* The last event should be for the child process's exit. */ 1479 wpid = waitpid(fpid, &status, 0); 1480 ATF_REQUIRE(WIFEXITED(status)); 1481 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1482 1483 wpid = wait(&status); 1484 ATF_REQUIRE(wpid == -1); 1485 ATF_REQUIRE(errno == ECHILD); 1486 } 1487 1488 static void 1489 handler(int sig __unused) 1490 { 1491 } 1492 1493 static void 1494 signal_main(void) 1495 { 1496 1497 signal(SIGINFO, handler); 1498 raise(SIGINFO); 1499 exit(0); 1500 } 1501 1502 /* 1503 * Verify that the expected ptrace event is reported for a signal. 1504 */ 1505 ATF_TC_WITHOUT_HEAD(ptrace__siginfo); 1506 ATF_TC_BODY(ptrace__siginfo, tc) 1507 { 1508 struct ptrace_lwpinfo pl; 1509 pid_t fpid, wpid; 1510 int status; 1511 1512 ATF_REQUIRE((fpid = fork()) != -1); 1513 if (fpid == 0) { 1514 trace_me(); 1515 signal_main(); 1516 } 1517 1518 /* The first wait() should report the stop from SIGSTOP. */ 1519 wpid = waitpid(fpid, &status, 0); 1520 ATF_REQUIRE(wpid == fpid); 1521 ATF_REQUIRE(WIFSTOPPED(status)); 1522 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1523 1524 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1525 1526 /* The next event should be for the SIGINFO. */ 1527 wpid = waitpid(fpid, &status, 0); 1528 ATF_REQUIRE(WIFSTOPPED(status)); 1529 ATF_REQUIRE(WSTOPSIG(status) == SIGINFO); 1530 1531 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1532 ATF_REQUIRE(pl.pl_event == PL_EVENT_SIGNAL); 1533 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 1534 ATF_REQUIRE(pl.pl_siginfo.si_code == SI_LWP); 1535 ATF_REQUIRE(pl.pl_siginfo.si_pid == wpid); 1536 1537 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1538 1539 /* The last event should be for the child process's exit. */ 1540 wpid = waitpid(fpid, &status, 0); 1541 ATF_REQUIRE(WIFEXITED(status)); 1542 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1543 1544 wpid = wait(&status); 1545 ATF_REQUIRE(wpid == -1); 1546 ATF_REQUIRE(errno == ECHILD); 1547 } 1548 1549 /* 1550 * Verify that the expected ptrace events are reported for PTRACE_EXEC. 1551 */ 1552 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_disable); 1553 ATF_TC_BODY(ptrace__ptrace_exec_disable, tc) 1554 { 1555 pid_t fpid, wpid; 1556 int events, status; 1557 1558 ATF_REQUIRE((fpid = fork()) != -1); 1559 if (fpid == 0) { 1560 trace_me(); 1561 exec_thread(NULL); 1562 } 1563 1564 /* The first wait() should report the stop from SIGSTOP. */ 1565 wpid = waitpid(fpid, &status, 0); 1566 ATF_REQUIRE(wpid == fpid); 1567 ATF_REQUIRE(WIFSTOPPED(status)); 1568 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1569 1570 events = 0; 1571 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1572 sizeof(events)) == 0); 1573 1574 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1575 1576 /* Should get one event at exit. */ 1577 wpid = waitpid(fpid, &status, 0); 1578 ATF_REQUIRE(WIFEXITED(status)); 1579 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1580 1581 wpid = wait(&status); 1582 ATF_REQUIRE(wpid == -1); 1583 ATF_REQUIRE(errno == ECHILD); 1584 } 1585 1586 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_enable); 1587 ATF_TC_BODY(ptrace__ptrace_exec_enable, tc) 1588 { 1589 struct ptrace_lwpinfo pl; 1590 pid_t fpid, wpid; 1591 int events, status; 1592 1593 ATF_REQUIRE((fpid = fork()) != -1); 1594 if (fpid == 0) { 1595 trace_me(); 1596 exec_thread(NULL); 1597 } 1598 1599 /* The first wait() should report the stop from SIGSTOP. */ 1600 wpid = waitpid(fpid, &status, 0); 1601 ATF_REQUIRE(wpid == fpid); 1602 ATF_REQUIRE(WIFSTOPPED(status)); 1603 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1604 1605 events = PTRACE_EXEC; 1606 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1607 sizeof(events)) == 0); 1608 1609 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1610 1611 /* The next event should be for the child process's exec. */ 1612 wpid = waitpid(fpid, &status, 0); 1613 ATF_REQUIRE(WIFSTOPPED(status)); 1614 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1615 1616 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1617 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) == 1618 (PL_FLAG_EXEC | PL_FLAG_SCX)); 1619 1620 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1621 1622 /* The last event should be for the child process's exit. */ 1623 wpid = waitpid(fpid, &status, 0); 1624 ATF_REQUIRE(WIFEXITED(status)); 1625 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1626 1627 wpid = wait(&status); 1628 ATF_REQUIRE(wpid == -1); 1629 ATF_REQUIRE(errno == ECHILD); 1630 } 1631 1632 ATF_TC_WITHOUT_HEAD(ptrace__event_mask); 1633 ATF_TC_BODY(ptrace__event_mask, tc) 1634 { 1635 pid_t fpid, wpid; 1636 int events, status; 1637 1638 ATF_REQUIRE((fpid = fork()) != -1); 1639 if (fpid == 0) { 1640 trace_me(); 1641 exit(0); 1642 } 1643 1644 /* The first wait() should report the stop from SIGSTOP. */ 1645 wpid = waitpid(fpid, &status, 0); 1646 ATF_REQUIRE(wpid == fpid); 1647 ATF_REQUIRE(WIFSTOPPED(status)); 1648 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1649 1650 /* PT_FOLLOW_FORK should toggle the state of PTRACE_FORK. */ 1651 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 1) != -1); 1652 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1653 sizeof(events)) == 0); 1654 ATF_REQUIRE(events & PTRACE_FORK); 1655 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 0) != -1); 1656 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1657 sizeof(events)) == 0); 1658 ATF_REQUIRE(!(events & PTRACE_FORK)); 1659 1660 /* PT_LWP_EVENTS should toggle the state of PTRACE_LWP. */ 1661 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 1) != -1); 1662 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1663 sizeof(events)) == 0); 1664 ATF_REQUIRE(events & PTRACE_LWP); 1665 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 0) != -1); 1666 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1667 sizeof(events)) == 0); 1668 ATF_REQUIRE(!(events & PTRACE_LWP)); 1669 1670 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1671 1672 /* Should get one event at exit. */ 1673 wpid = waitpid(fpid, &status, 0); 1674 ATF_REQUIRE(WIFEXITED(status)); 1675 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1676 1677 wpid = wait(&status); 1678 ATF_REQUIRE(wpid == -1); 1679 ATF_REQUIRE(errno == ECHILD); 1680 } 1681 1682 /* 1683 * Verify that the expected ptrace events are reported for PTRACE_VFORK. 1684 */ 1685 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork); 1686 ATF_TC_BODY(ptrace__ptrace_vfork, tc) 1687 { 1688 struct ptrace_lwpinfo pl; 1689 pid_t fpid, wpid; 1690 int events, status; 1691 1692 ATF_REQUIRE((fpid = fork()) != -1); 1693 if (fpid == 0) { 1694 trace_me(); 1695 follow_fork_parent(true); 1696 } 1697 1698 /* The first wait() should report the stop from SIGSTOP. */ 1699 wpid = waitpid(fpid, &status, 0); 1700 ATF_REQUIRE(wpid == fpid); 1701 ATF_REQUIRE(WIFSTOPPED(status)); 1702 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1703 1704 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1705 sizeof(events)) == 0); 1706 events |= PTRACE_VFORK; 1707 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1708 sizeof(events)) == 0); 1709 1710 /* Continue the child ignoring the SIGSTOP. */ 1711 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1); 1712 1713 /* The next event should report the end of the vfork. */ 1714 wpid = wait(&status); 1715 ATF_REQUIRE(wpid == fpid); 1716 ATF_REQUIRE(WIFSTOPPED(status)); 1717 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1718 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1719 ATF_REQUIRE((pl.pl_flags & PL_FLAG_VFORK_DONE) != 0); 1720 1721 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1); 1722 1723 wpid = wait(&status); 1724 ATF_REQUIRE(wpid == fpid); 1725 ATF_REQUIRE(WIFEXITED(status)); 1726 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1727 1728 wpid = wait(&status); 1729 ATF_REQUIRE(wpid == -1); 1730 ATF_REQUIRE(errno == ECHILD); 1731 } 1732 1733 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork_follow); 1734 ATF_TC_BODY(ptrace__ptrace_vfork_follow, tc) 1735 { 1736 struct ptrace_lwpinfo pl[2]; 1737 pid_t children[2], fpid, wpid; 1738 int events, status; 1739 1740 ATF_REQUIRE((fpid = fork()) != -1); 1741 if (fpid == 0) { 1742 trace_me(); 1743 follow_fork_parent(true); 1744 } 1745 1746 /* Parent process. */ 1747 children[0] = fpid; 1748 1749 /* The first wait() should report the stop from SIGSTOP. */ 1750 wpid = waitpid(children[0], &status, 0); 1751 ATF_REQUIRE(wpid == children[0]); 1752 ATF_REQUIRE(WIFSTOPPED(status)); 1753 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1754 1755 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, children[0], (caddr_t)&events, 1756 sizeof(events)) == 0); 1757 events |= PTRACE_FORK | PTRACE_VFORK; 1758 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, children[0], (caddr_t)&events, 1759 sizeof(events)) == 0); 1760 1761 /* Continue the child ignoring the SIGSTOP. */ 1762 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1763 1764 /* Wait for both halves of the fork event to get reported. */ 1765 children[1] = handle_fork_events(children[0], pl); 1766 ATF_REQUIRE(children[1] > 0); 1767 1768 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORKED) != 0); 1769 1770 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1771 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 1772 1773 /* 1774 * The child can't exit until the grandchild reports status, so the 1775 * grandchild should report its exit first to the debugger. 1776 */ 1777 wpid = waitpid(children[1], &status, 0); 1778 ATF_REQUIRE(wpid == children[1]); 1779 ATF_REQUIRE(WIFEXITED(status)); 1780 ATF_REQUIRE(WEXITSTATUS(status) == 2); 1781 1782 /* 1783 * The child should report it's vfork() completion before it 1784 * exits. 1785 */ 1786 wpid = wait(&status); 1787 ATF_REQUIRE(wpid == children[0]); 1788 ATF_REQUIRE(WIFSTOPPED(status)); 1789 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1790 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl[0], sizeof(pl[0])) != 1791 -1); 1792 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORK_DONE) != 0); 1793 1794 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1795 1796 wpid = wait(&status); 1797 ATF_REQUIRE(wpid == children[0]); 1798 ATF_REQUIRE(WIFEXITED(status)); 1799 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1800 1801 wpid = wait(&status); 1802 ATF_REQUIRE(wpid == -1); 1803 ATF_REQUIRE(errno == ECHILD); 1804 } 1805 1806 #ifdef HAVE_BREAKPOINT 1807 /* 1808 * Verify that no more events are reported after PT_KILL except for the 1809 * process exit when stopped due to a breakpoint trap. 1810 */ 1811 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_breakpoint); 1812 ATF_TC_BODY(ptrace__PT_KILL_breakpoint, tc) 1813 { 1814 pid_t fpid, wpid; 1815 int status; 1816 1817 ATF_REQUIRE((fpid = fork()) != -1); 1818 if (fpid == 0) { 1819 trace_me(); 1820 breakpoint(); 1821 exit(1); 1822 } 1823 1824 /* The first wait() should report the stop from SIGSTOP. */ 1825 wpid = waitpid(fpid, &status, 0); 1826 ATF_REQUIRE(wpid == fpid); 1827 ATF_REQUIRE(WIFSTOPPED(status)); 1828 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1829 1830 /* Continue the child ignoring the SIGSTOP. */ 1831 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1832 1833 /* The second wait() should report hitting the breakpoint. */ 1834 wpid = waitpid(fpid, &status, 0); 1835 ATF_REQUIRE(wpid == fpid); 1836 ATF_REQUIRE(WIFSTOPPED(status)); 1837 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1838 1839 /* Kill the child process. */ 1840 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1841 1842 /* The last wait() should report the SIGKILL. */ 1843 wpid = waitpid(fpid, &status, 0); 1844 ATF_REQUIRE(wpid == fpid); 1845 ATF_REQUIRE(WIFSIGNALED(status)); 1846 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1847 1848 wpid = wait(&status); 1849 ATF_REQUIRE(wpid == -1); 1850 ATF_REQUIRE(errno == ECHILD); 1851 } 1852 #endif /* HAVE_BREAKPOINT */ 1853 1854 /* 1855 * Verify that no more events are reported after PT_KILL except for the 1856 * process exit when stopped inside of a system call. 1857 */ 1858 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_system_call); 1859 ATF_TC_BODY(ptrace__PT_KILL_system_call, tc) 1860 { 1861 struct ptrace_lwpinfo pl; 1862 pid_t fpid, wpid; 1863 int status; 1864 1865 ATF_REQUIRE((fpid = fork()) != -1); 1866 if (fpid == 0) { 1867 trace_me(); 1868 getpid(); 1869 exit(1); 1870 } 1871 1872 /* The first wait() should report the stop from SIGSTOP. */ 1873 wpid = waitpid(fpid, &status, 0); 1874 ATF_REQUIRE(wpid == fpid); 1875 ATF_REQUIRE(WIFSTOPPED(status)); 1876 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1877 1878 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 1879 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1880 1881 /* The second wait() should report a system call entry for getpid(). */ 1882 wpid = waitpid(fpid, &status, 0); 1883 ATF_REQUIRE(wpid == fpid); 1884 ATF_REQUIRE(WIFSTOPPED(status)); 1885 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1886 1887 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1888 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 1889 1890 /* Kill the child process. */ 1891 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1892 1893 /* The last wait() should report the SIGKILL. */ 1894 wpid = waitpid(fpid, &status, 0); 1895 ATF_REQUIRE(wpid == fpid); 1896 ATF_REQUIRE(WIFSIGNALED(status)); 1897 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1898 1899 wpid = wait(&status); 1900 ATF_REQUIRE(wpid == -1); 1901 ATF_REQUIRE(errno == ECHILD); 1902 } 1903 1904 /* 1905 * Verify that no more events are reported after PT_KILL except for the 1906 * process exit when killing a multithreaded process. 1907 */ 1908 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_threads); 1909 ATF_TC_BODY(ptrace__PT_KILL_threads, tc) 1910 { 1911 struct ptrace_lwpinfo pl; 1912 pid_t fpid, wpid; 1913 lwpid_t main_lwp; 1914 int status; 1915 1916 ATF_REQUIRE((fpid = fork()) != -1); 1917 if (fpid == 0) { 1918 trace_me(); 1919 simple_thread_main(); 1920 } 1921 1922 /* The first wait() should report the stop from SIGSTOP. */ 1923 wpid = waitpid(fpid, &status, 0); 1924 ATF_REQUIRE(wpid == fpid); 1925 ATF_REQUIRE(WIFSTOPPED(status)); 1926 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1927 1928 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1929 sizeof(pl)) != -1); 1930 main_lwp = pl.pl_lwpid; 1931 1932 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1933 1934 /* Continue the child ignoring the SIGSTOP. */ 1935 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1936 1937 /* The first event should be for the child thread's birth. */ 1938 wpid = waitpid(fpid, &status, 0); 1939 ATF_REQUIRE(wpid == fpid); 1940 ATF_REQUIRE(WIFSTOPPED(status)); 1941 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1942 1943 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1944 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1945 (PL_FLAG_BORN | PL_FLAG_SCX)); 1946 ATF_REQUIRE(pl.pl_lwpid != main_lwp); 1947 1948 /* Kill the child process. */ 1949 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1950 1951 /* The last wait() should report the SIGKILL. */ 1952 wpid = waitpid(fpid, &status, 0); 1953 ATF_REQUIRE(wpid == fpid); 1954 ATF_REQUIRE(WIFSIGNALED(status)); 1955 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1956 1957 wpid = wait(&status); 1958 ATF_REQUIRE(wpid == -1); 1959 ATF_REQUIRE(errno == ECHILD); 1960 } 1961 1962 static void * 1963 mask_usr1_thread(void *arg) 1964 { 1965 pthread_barrier_t *pbarrier; 1966 sigset_t sigmask; 1967 1968 pbarrier = (pthread_barrier_t*)arg; 1969 1970 sigemptyset(&sigmask); 1971 sigaddset(&sigmask, SIGUSR1); 1972 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 1973 1974 /* Sync up with other thread after sigmask updated. */ 1975 pthread_barrier_wait(pbarrier); 1976 1977 for (;;) 1978 sleep(60); 1979 1980 return (NULL); 1981 } 1982 1983 /* 1984 * Verify that the SIGKILL from PT_KILL takes priority over other signals 1985 * and prevents spurious stops due to those other signals. 1986 */ 1987 ATF_TC(ptrace__PT_KILL_competing_signal); 1988 ATF_TC_HEAD(ptrace__PT_KILL_competing_signal, tc) 1989 { 1990 1991 atf_tc_set_md_var(tc, "require.user", "root"); 1992 } 1993 ATF_TC_BODY(ptrace__PT_KILL_competing_signal, tc) 1994 { 1995 pid_t fpid, wpid; 1996 int status; 1997 cpuset_t setmask; 1998 pthread_t t; 1999 pthread_barrier_t barrier; 2000 struct sched_param sched_param; 2001 2002 ATF_REQUIRE((fpid = fork()) != -1); 2003 if (fpid == 0) { 2004 /* Bind to one CPU so only one thread at a time will run. */ 2005 CPU_ZERO(&setmask); 2006 CPU_SET(0, &setmask); 2007 cpusetid_t setid; 2008 CHILD_REQUIRE(cpuset(&setid) == 0); 2009 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 2010 CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0); 2011 2012 CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 2013 2014 CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread, 2015 (void*)&barrier) == 0); 2016 2017 /* 2018 * Give the main thread higher priority. The test always 2019 * assumes that, if both threads are able to run, the main 2020 * thread runs first. 2021 */ 2022 sched_param.sched_priority = 2023 (sched_get_priority_max(SCHED_FIFO) + 2024 sched_get_priority_min(SCHED_FIFO)) / 2; 2025 CHILD_REQUIRE(pthread_setschedparam(pthread_self(), 2026 SCHED_FIFO, &sched_param) == 0); 2027 sched_param.sched_priority -= RQ_PPQ; 2028 CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO, 2029 &sched_param) == 0); 2030 2031 sigset_t sigmask; 2032 sigemptyset(&sigmask); 2033 sigaddset(&sigmask, SIGUSR2); 2034 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 2035 2036 /* Sync up with other thread after sigmask updated. */ 2037 pthread_barrier_wait(&barrier); 2038 2039 trace_me(); 2040 2041 for (;;) 2042 sleep(60); 2043 2044 exit(1); 2045 } 2046 2047 /* The first wait() should report the stop from SIGSTOP. */ 2048 wpid = waitpid(fpid, &status, 0); 2049 ATF_REQUIRE(wpid == fpid); 2050 ATF_REQUIRE(WIFSTOPPED(status)); 2051 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2052 2053 /* Continue the child ignoring the SIGSTOP. */ 2054 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2055 2056 /* Send a signal that only the second thread can handle. */ 2057 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2058 2059 /* The second wait() should report the SIGUSR2. */ 2060 wpid = waitpid(fpid, &status, 0); 2061 ATF_REQUIRE(wpid == fpid); 2062 ATF_REQUIRE(WIFSTOPPED(status)); 2063 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2064 2065 /* Send a signal that only the first thread can handle. */ 2066 ATF_REQUIRE(kill(fpid, SIGUSR1) == 0); 2067 2068 /* Replace the SIGUSR2 with a kill. */ 2069 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 2070 2071 /* The last wait() should report the SIGKILL (not the SIGUSR signal). */ 2072 wpid = waitpid(fpid, &status, 0); 2073 ATF_REQUIRE(wpid == fpid); 2074 ATF_REQUIRE(WIFSIGNALED(status)); 2075 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 2076 2077 wpid = wait(&status); 2078 ATF_REQUIRE(wpid == -1); 2079 ATF_REQUIRE(errno == ECHILD); 2080 } 2081 2082 /* 2083 * Verify that the SIGKILL from PT_KILL takes priority over other stop events 2084 * and prevents spurious stops caused by those events. 2085 */ 2086 ATF_TC(ptrace__PT_KILL_competing_stop); 2087 ATF_TC_HEAD(ptrace__PT_KILL_competing_stop, tc) 2088 { 2089 2090 atf_tc_set_md_var(tc, "require.user", "root"); 2091 } 2092 ATF_TC_BODY(ptrace__PT_KILL_competing_stop, tc) 2093 { 2094 pid_t fpid, wpid; 2095 int status; 2096 cpuset_t setmask; 2097 pthread_t t; 2098 pthread_barrier_t barrier; 2099 lwpid_t main_lwp; 2100 struct ptrace_lwpinfo pl; 2101 struct sched_param sched_param; 2102 2103 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 2104 atf_tc_skip("https://bugs.freebsd.org/220841"); 2105 2106 ATF_REQUIRE((fpid = fork()) != -1); 2107 if (fpid == 0) { 2108 trace_me(); 2109 2110 /* Bind to one CPU so only one thread at a time will run. */ 2111 CPU_ZERO(&setmask); 2112 CPU_SET(0, &setmask); 2113 cpusetid_t setid; 2114 CHILD_REQUIRE(cpuset(&setid) == 0); 2115 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 2116 CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0); 2117 2118 CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 2119 2120 CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread, 2121 (void*)&barrier) == 0); 2122 2123 /* 2124 * Give the main thread higher priority. The test always 2125 * assumes that, if both threads are able to run, the main 2126 * thread runs first. 2127 */ 2128 sched_param.sched_priority = 2129 (sched_get_priority_max(SCHED_FIFO) + 2130 sched_get_priority_min(SCHED_FIFO)) / 2; 2131 CHILD_REQUIRE(pthread_setschedparam(pthread_self(), 2132 SCHED_FIFO, &sched_param) == 0); 2133 sched_param.sched_priority -= RQ_PPQ; 2134 CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO, 2135 &sched_param) == 0); 2136 2137 sigset_t sigmask; 2138 sigemptyset(&sigmask); 2139 sigaddset(&sigmask, SIGUSR2); 2140 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 2141 2142 /* Sync up with other thread after sigmask updated. */ 2143 pthread_barrier_wait(&barrier); 2144 2145 /* Sync up with the test before doing the getpid(). */ 2146 raise(SIGSTOP); 2147 2148 getpid(); 2149 exit(1); 2150 } 2151 2152 /* The first wait() should report the stop from SIGSTOP. */ 2153 wpid = waitpid(fpid, &status, 0); 2154 ATF_REQUIRE(wpid == fpid); 2155 ATF_REQUIRE(WIFSTOPPED(status)); 2156 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2157 2158 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2159 main_lwp = pl.pl_lwpid; 2160 2161 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2162 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2163 2164 /* 2165 * Continue until child is done with setup, which is indicated with 2166 * SIGSTOP. Ignore system calls in the meantime. 2167 */ 2168 for (;;) { 2169 wpid = waitpid(fpid, &status, 0); 2170 ATF_REQUIRE(wpid == fpid); 2171 ATF_REQUIRE(WIFSTOPPED(status)); 2172 if (WSTOPSIG(status) == SIGTRAP) { 2173 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 2174 sizeof(pl)) != -1); 2175 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2176 } else { 2177 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2178 break; 2179 } 2180 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2181 } 2182 2183 /* Proceed, allowing main thread to hit syscall entry for getpid(). */ 2184 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2185 2186 wpid = waitpid(fpid, &status, 0); 2187 ATF_REQUIRE(wpid == fpid); 2188 ATF_REQUIRE(WIFSTOPPED(status)); 2189 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2190 2191 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 2192 sizeof(pl)) != -1); 2193 ATF_REQUIRE(pl.pl_lwpid == main_lwp); 2194 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2195 /* Prevent the main thread from hitting its syscall exit for now. */ 2196 ATF_REQUIRE(ptrace(PT_SUSPEND, main_lwp, 0, 0) == 0); 2197 2198 /* 2199 * Proceed, allowing second thread to hit syscall exit for 2200 * pthread_barrier_wait(). 2201 */ 2202 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2203 2204 wpid = waitpid(fpid, &status, 0); 2205 ATF_REQUIRE(wpid == fpid); 2206 ATF_REQUIRE(WIFSTOPPED(status)); 2207 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2208 2209 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 2210 sizeof(pl)) != -1); 2211 ATF_REQUIRE(pl.pl_lwpid != main_lwp); 2212 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 2213 2214 /* Send a signal that only the second thread can handle. */ 2215 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2216 2217 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2218 2219 /* The next wait() should report the SIGUSR2. */ 2220 wpid = waitpid(fpid, &status, 0); 2221 ATF_REQUIRE(wpid == fpid); 2222 ATF_REQUIRE(WIFSTOPPED(status)); 2223 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2224 2225 /* Allow the main thread to try to finish its system call. */ 2226 ATF_REQUIRE(ptrace(PT_RESUME, main_lwp, 0, 0) == 0); 2227 2228 /* 2229 * At this point, the main thread is in the middle of a system call and 2230 * has been resumed. The second thread has taken a SIGUSR2 which will 2231 * be replaced with a SIGKILL below. The main thread will get to run 2232 * first. It should notice the kill request (even though the signal 2233 * replacement occurred in the other thread) and exit accordingly. It 2234 * should not stop for the system call exit event. 2235 */ 2236 2237 /* Replace the SIGUSR2 with a kill. */ 2238 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 2239 2240 /* The last wait() should report the SIGKILL (not a syscall exit). */ 2241 wpid = waitpid(fpid, &status, 0); 2242 ATF_REQUIRE(wpid == fpid); 2243 ATF_REQUIRE(WIFSIGNALED(status)); 2244 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 2245 2246 wpid = wait(&status); 2247 ATF_REQUIRE(wpid == -1); 2248 ATF_REQUIRE(errno == ECHILD); 2249 } 2250 2251 static void 2252 sigusr1_handler(int sig) 2253 { 2254 2255 CHILD_REQUIRE(sig == SIGUSR1); 2256 _exit(2); 2257 } 2258 2259 /* 2260 * Verify that even if the signal queue is full for a child process, 2261 * a PT_KILL will kill the process. 2262 */ 2263 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_with_signal_full_sigqueue); 2264 ATF_TC_BODY(ptrace__PT_KILL_with_signal_full_sigqueue, tc) 2265 { 2266 pid_t fpid, wpid; 2267 int status; 2268 int max_pending_per_proc; 2269 size_t len; 2270 int i; 2271 2272 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2273 2274 ATF_REQUIRE((fpid = fork()) != -1); 2275 if (fpid == 0) { 2276 trace_me(); 2277 exit(1); 2278 } 2279 2280 /* The first wait() should report the stop from SIGSTOP. */ 2281 wpid = waitpid(fpid, &status, 0); 2282 ATF_REQUIRE(wpid == fpid); 2283 ATF_REQUIRE(WIFSTOPPED(status)); 2284 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2285 2286 len = sizeof(max_pending_per_proc); 2287 ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc", 2288 &max_pending_per_proc, &len, NULL, 0) == 0); 2289 2290 /* Fill the signal queue. */ 2291 for (i = 0; i < max_pending_per_proc; ++i) 2292 ATF_REQUIRE(kill(fpid, SIGUSR1) == 0); 2293 2294 /* Kill the child process. */ 2295 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 2296 2297 /* The last wait() should report the SIGKILL. */ 2298 wpid = waitpid(fpid, &status, 0); 2299 ATF_REQUIRE(wpid == fpid); 2300 ATF_REQUIRE(WIFSIGNALED(status)); 2301 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 2302 2303 wpid = wait(&status); 2304 ATF_REQUIRE(wpid == -1); 2305 ATF_REQUIRE(errno == ECHILD); 2306 } 2307 2308 /* 2309 * Verify that when stopped at a system call entry, a signal can be 2310 * requested with PT_CONTINUE which will be delivered once the system 2311 * call is complete. 2312 */ 2313 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry); 2314 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry, tc) 2315 { 2316 struct ptrace_lwpinfo pl; 2317 pid_t fpid, wpid; 2318 int status; 2319 2320 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2321 2322 ATF_REQUIRE((fpid = fork()) != -1); 2323 if (fpid == 0) { 2324 trace_me(); 2325 getpid(); 2326 exit(1); 2327 } 2328 2329 /* The first wait() should report the stop from SIGSTOP. */ 2330 wpid = waitpid(fpid, &status, 0); 2331 ATF_REQUIRE(wpid == fpid); 2332 ATF_REQUIRE(WIFSTOPPED(status)); 2333 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2334 2335 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2336 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2337 2338 /* The second wait() should report a system call entry for getpid(). */ 2339 wpid = waitpid(fpid, &status, 0); 2340 ATF_REQUIRE(wpid == fpid); 2341 ATF_REQUIRE(WIFSTOPPED(status)); 2342 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2343 2344 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2345 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2346 2347 /* Continue the child process with a signal. */ 2348 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2349 2350 for (;;) { 2351 /* 2352 * The last wait() should report exit 2, i.e., a normal _exit 2353 * from the signal handler. In the meantime, catch and proceed 2354 * past any syscall stops. 2355 */ 2356 wpid = waitpid(fpid, &status, 0); 2357 ATF_REQUIRE(wpid == fpid); 2358 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2359 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2360 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2361 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2362 } else { 2363 ATF_REQUIRE(WIFEXITED(status)); 2364 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2365 break; 2366 } 2367 } 2368 2369 wpid = wait(&status); 2370 ATF_REQUIRE(wpid == -1); 2371 ATF_REQUIRE(errno == ECHILD); 2372 } 2373 2374 static void 2375 sigusr1_counting_handler(int sig) 2376 { 2377 static int counter = 0; 2378 2379 CHILD_REQUIRE(sig == SIGUSR1); 2380 counter++; 2381 if (counter == 2) 2382 _exit(2); 2383 } 2384 2385 /* 2386 * Verify that, when continuing from a stop at system call entry and exit, 2387 * a signal can be requested from both stops, and both will be delivered when 2388 * the system call is complete. 2389 */ 2390 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit); 2391 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit, tc) 2392 { 2393 struct ptrace_lwpinfo pl; 2394 pid_t fpid, wpid; 2395 int status; 2396 2397 ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR); 2398 2399 ATF_REQUIRE((fpid = fork()) != -1); 2400 if (fpid == 0) { 2401 trace_me(); 2402 getpid(); 2403 exit(1); 2404 } 2405 2406 /* The first wait() should report the stop from SIGSTOP. */ 2407 wpid = waitpid(fpid, &status, 0); 2408 ATF_REQUIRE(wpid == fpid); 2409 ATF_REQUIRE(WIFSTOPPED(status)); 2410 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2411 2412 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2413 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2414 2415 /* The second wait() should report a system call entry for getpid(). */ 2416 wpid = waitpid(fpid, &status, 0); 2417 ATF_REQUIRE(wpid == fpid); 2418 ATF_REQUIRE(WIFSTOPPED(status)); 2419 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2420 2421 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2422 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2423 2424 /* Continue the child process with a signal. */ 2425 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2426 2427 /* The third wait() should report a system call exit for getpid(). */ 2428 wpid = waitpid(fpid, &status, 0); 2429 ATF_REQUIRE(wpid == fpid); 2430 ATF_REQUIRE(WIFSTOPPED(status)); 2431 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2432 2433 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2434 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 2435 2436 /* Continue the child process with a signal. */ 2437 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2438 2439 for (;;) { 2440 /* 2441 * The last wait() should report exit 2, i.e., a normal _exit 2442 * from the signal handler. In the meantime, catch and proceed 2443 * past any syscall stops. 2444 */ 2445 wpid = waitpid(fpid, &status, 0); 2446 ATF_REQUIRE(wpid == fpid); 2447 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2448 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2449 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2450 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2451 } else { 2452 ATF_REQUIRE(WIFEXITED(status)); 2453 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2454 break; 2455 } 2456 } 2457 2458 wpid = wait(&status); 2459 ATF_REQUIRE(wpid == -1); 2460 ATF_REQUIRE(errno == ECHILD); 2461 } 2462 2463 /* 2464 * Verify that even if the signal queue is full for a child process, 2465 * a PT_CONTINUE with a signal will not result in loss of that signal. 2466 */ 2467 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_full_sigqueue); 2468 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_full_sigqueue, tc) 2469 { 2470 pid_t fpid, wpid; 2471 int status; 2472 int max_pending_per_proc; 2473 size_t len; 2474 int i; 2475 2476 ATF_REQUIRE(signal(SIGUSR2, handler) != SIG_ERR); 2477 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2478 2479 ATF_REQUIRE((fpid = fork()) != -1); 2480 if (fpid == 0) { 2481 trace_me(); 2482 exit(1); 2483 } 2484 2485 /* The first wait() should report the stop from SIGSTOP. */ 2486 wpid = waitpid(fpid, &status, 0); 2487 ATF_REQUIRE(wpid == fpid); 2488 ATF_REQUIRE(WIFSTOPPED(status)); 2489 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2490 2491 len = sizeof(max_pending_per_proc); 2492 ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc", 2493 &max_pending_per_proc, &len, NULL, 0) == 0); 2494 2495 /* Fill the signal queue. */ 2496 for (i = 0; i < max_pending_per_proc; ++i) 2497 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2498 2499 /* Continue with signal. */ 2500 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2501 2502 for (;;) { 2503 wpid = waitpid(fpid, &status, 0); 2504 ATF_REQUIRE(wpid == fpid); 2505 if (WIFSTOPPED(status)) { 2506 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2507 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2508 } else { 2509 /* 2510 * The last wait() should report normal _exit from the 2511 * SIGUSR1 handler. 2512 */ 2513 ATF_REQUIRE(WIFEXITED(status)); 2514 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2515 break; 2516 } 2517 } 2518 2519 wpid = wait(&status); 2520 ATF_REQUIRE(wpid == -1); 2521 ATF_REQUIRE(errno == ECHILD); 2522 } 2523 2524 static sem_t sigusr1_sem; 2525 static int got_usr1; 2526 2527 static void 2528 sigusr1_sempost_handler(int sig __unused) 2529 { 2530 2531 got_usr1++; 2532 CHILD_REQUIRE(sem_post(&sigusr1_sem) == 0); 2533 } 2534 2535 /* 2536 * Verify that even if the signal queue is full for a child process, 2537 * and the signal is masked, a PT_CONTINUE with a signal will not 2538 * result in loss of that signal. 2539 */ 2540 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue); 2541 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue, tc) 2542 { 2543 struct ptrace_lwpinfo pl; 2544 pid_t fpid, wpid; 2545 int status, err; 2546 int max_pending_per_proc; 2547 size_t len; 2548 int i; 2549 sigset_t sigmask; 2550 2551 ATF_REQUIRE(signal(SIGUSR2, handler) != SIG_ERR); 2552 ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0); 2553 ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR); 2554 2555 got_usr1 = 0; 2556 ATF_REQUIRE((fpid = fork()) != -1); 2557 if (fpid == 0) { 2558 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 2559 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 2560 CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0); 2561 2562 trace_me(); 2563 CHILD_REQUIRE(got_usr1 == 0); 2564 2565 /* Allow the pending SIGUSR1 in now. */ 2566 CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0); 2567 /* Wait to receive the SIGUSR1. */ 2568 do { 2569 err = sem_wait(&sigusr1_sem); 2570 CHILD_REQUIRE(err == 0 || errno == EINTR); 2571 } while (err != 0 && errno == EINTR); 2572 CHILD_REQUIRE(got_usr1 == 1); 2573 exit(1); 2574 } 2575 2576 /* The first wait() should report the stop from SIGSTOP. */ 2577 wpid = waitpid(fpid, &status, 0); 2578 ATF_REQUIRE(wpid == fpid); 2579 ATF_REQUIRE(WIFSTOPPED(status)); 2580 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2581 2582 len = sizeof(max_pending_per_proc); 2583 ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc", 2584 &max_pending_per_proc, &len, NULL, 0) == 0); 2585 2586 /* Fill the signal queue. */ 2587 for (i = 0; i < max_pending_per_proc; ++i) 2588 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2589 2590 /* Continue with signal. */ 2591 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2592 2593 /* Collect and ignore all of the SIGUSR2. */ 2594 for (i = 0; i < max_pending_per_proc; ++i) { 2595 wpid = waitpid(fpid, &status, 0); 2596 ATF_REQUIRE(wpid == fpid); 2597 ATF_REQUIRE(WIFSTOPPED(status)); 2598 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2599 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2600 } 2601 2602 /* Now our PT_CONTINUE'd SIGUSR1 should cause a stop after unmask. */ 2603 wpid = waitpid(fpid, &status, 0); 2604 ATF_REQUIRE(wpid == fpid); 2605 ATF_REQUIRE(WIFSTOPPED(status)); 2606 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1); 2607 ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1); 2608 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1); 2609 2610 /* Continue the child, ignoring the SIGUSR1. */ 2611 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2612 2613 /* The last wait() should report exit after receiving SIGUSR1. */ 2614 wpid = waitpid(fpid, &status, 0); 2615 ATF_REQUIRE(wpid == fpid); 2616 ATF_REQUIRE(WIFEXITED(status)); 2617 ATF_REQUIRE(WEXITSTATUS(status) == 1); 2618 2619 wpid = wait(&status); 2620 ATF_REQUIRE(wpid == -1); 2621 ATF_REQUIRE(errno == ECHILD); 2622 } 2623 2624 /* 2625 * Verify that, after stopping due to a signal, that signal can be 2626 * replaced with another signal. 2627 */ 2628 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_change_sig); 2629 ATF_TC_BODY(ptrace__PT_CONTINUE_change_sig, tc) 2630 { 2631 struct ptrace_lwpinfo pl; 2632 pid_t fpid, wpid; 2633 int status; 2634 2635 ATF_REQUIRE((fpid = fork()) != -1); 2636 if (fpid == 0) { 2637 trace_me(); 2638 sleep(20); 2639 exit(1); 2640 } 2641 2642 /* The first wait() should report the stop from SIGSTOP. */ 2643 wpid = waitpid(fpid, &status, 0); 2644 ATF_REQUIRE(wpid == fpid); 2645 ATF_REQUIRE(WIFSTOPPED(status)); 2646 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2647 2648 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2649 2650 /* Send a signal without ptrace. */ 2651 ATF_REQUIRE(kill(fpid, SIGINT) == 0); 2652 2653 /* The second wait() should report a SIGINT was received. */ 2654 wpid = waitpid(fpid, &status, 0); 2655 ATF_REQUIRE(wpid == fpid); 2656 ATF_REQUIRE(WIFSTOPPED(status)); 2657 ATF_REQUIRE(WSTOPSIG(status) == SIGINT); 2658 2659 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2660 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 2661 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGINT); 2662 2663 /* Continue the child process with a different signal. */ 2664 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTERM) == 0); 2665 2666 /* 2667 * The last wait() should report having died due to the new 2668 * signal, SIGTERM. 2669 */ 2670 wpid = waitpid(fpid, &status, 0); 2671 ATF_REQUIRE(wpid == fpid); 2672 ATF_REQUIRE(WIFSIGNALED(status)); 2673 ATF_REQUIRE(WTERMSIG(status) == SIGTERM); 2674 2675 wpid = wait(&status); 2676 ATF_REQUIRE(wpid == -1); 2677 ATF_REQUIRE(errno == ECHILD); 2678 } 2679 2680 /* 2681 * Verify that a signal can be passed through to the child even when there 2682 * was no true signal originally. Such cases arise when a SIGTRAP is 2683 * invented for e.g, system call stops. 2684 */ 2685 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry); 2686 ATF_TC_BODY(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry, tc) 2687 { 2688 struct ptrace_lwpinfo pl; 2689 struct rlimit rl; 2690 pid_t fpid, wpid; 2691 int status; 2692 2693 ATF_REQUIRE((fpid = fork()) != -1); 2694 if (fpid == 0) { 2695 trace_me(); 2696 /* SIGTRAP expected to cause exit on syscall entry. */ 2697 rl.rlim_cur = rl.rlim_max = 0; 2698 ATF_REQUIRE(setrlimit(RLIMIT_CORE, &rl) == 0); 2699 getpid(); 2700 exit(1); 2701 } 2702 2703 /* The first wait() should report the stop from SIGSTOP. */ 2704 wpid = waitpid(fpid, &status, 0); 2705 ATF_REQUIRE(wpid == fpid); 2706 ATF_REQUIRE(WIFSTOPPED(status)); 2707 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2708 2709 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2710 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2711 2712 /* The second wait() should report a system call entry for getpid(). */ 2713 wpid = waitpid(fpid, &status, 0); 2714 ATF_REQUIRE(wpid == fpid); 2715 ATF_REQUIRE(WIFSTOPPED(status)); 2716 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2717 2718 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2719 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2720 2721 /* Continue the child process with a SIGTRAP. */ 2722 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTRAP) == 0); 2723 2724 for (;;) { 2725 /* 2726 * The last wait() should report exit due to SIGTRAP. In the 2727 * meantime, catch and proceed past any syscall stops. 2728 */ 2729 wpid = waitpid(fpid, &status, 0); 2730 ATF_REQUIRE(wpid == fpid); 2731 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2732 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2733 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2734 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2735 } else { 2736 ATF_REQUIRE(WIFSIGNALED(status)); 2737 ATF_REQUIRE(WTERMSIG(status) == SIGTRAP); 2738 break; 2739 } 2740 } 2741 2742 wpid = wait(&status); 2743 ATF_REQUIRE(wpid == -1); 2744 ATF_REQUIRE(errno == ECHILD); 2745 2746 } 2747 2748 /* 2749 * A mixed bag PT_CONTINUE with signal test. 2750 */ 2751 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_mix); 2752 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_mix, tc) 2753 { 2754 struct ptrace_lwpinfo pl; 2755 pid_t fpid, wpid; 2756 int status; 2757 2758 ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR); 2759 2760 ATF_REQUIRE((fpid = fork()) != -1); 2761 if (fpid == 0) { 2762 trace_me(); 2763 getpid(); 2764 exit(1); 2765 } 2766 2767 /* The first wait() should report the stop from SIGSTOP. */ 2768 wpid = waitpid(fpid, &status, 0); 2769 ATF_REQUIRE(wpid == fpid); 2770 ATF_REQUIRE(WIFSTOPPED(status)); 2771 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2772 2773 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2774 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2775 2776 /* The second wait() should report a system call entry for getpid(). */ 2777 wpid = waitpid(fpid, &status, 0); 2778 ATF_REQUIRE(wpid == fpid); 2779 ATF_REQUIRE(WIFSTOPPED(status)); 2780 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2781 2782 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2783 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2784 2785 /* Continue with the first SIGUSR1. */ 2786 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2787 2788 /* The next wait() should report a system call exit for getpid(). */ 2789 wpid = waitpid(fpid, &status, 0); 2790 ATF_REQUIRE(wpid == fpid); 2791 ATF_REQUIRE(WIFSTOPPED(status)); 2792 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2793 2794 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2795 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 2796 2797 /* Send an ABRT without ptrace. */ 2798 ATF_REQUIRE(kill(fpid, SIGABRT) == 0); 2799 2800 /* Continue normally. */ 2801 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2802 2803 /* The next wait() should report the SIGABRT. */ 2804 wpid = waitpid(fpid, &status, 0); 2805 ATF_REQUIRE(wpid == fpid); 2806 ATF_REQUIRE(WIFSTOPPED(status)); 2807 ATF_REQUIRE(WSTOPSIG(status) == SIGABRT); 2808 2809 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2810 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 2811 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT); 2812 2813 /* Continue, replacing the SIGABRT with another SIGUSR1. */ 2814 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2815 2816 for (;;) { 2817 /* 2818 * The last wait() should report exit 2, i.e., a normal _exit 2819 * from the signal handler. In the meantime, catch and proceed 2820 * past any syscall stops. 2821 */ 2822 wpid = waitpid(fpid, &status, 0); 2823 ATF_REQUIRE(wpid == fpid); 2824 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2825 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2826 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2827 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2828 } else { 2829 ATF_REQUIRE(WIFEXITED(status)); 2830 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2831 break; 2832 } 2833 } 2834 2835 wpid = wait(&status); 2836 ATF_REQUIRE(wpid == -1); 2837 ATF_REQUIRE(errno == ECHILD); 2838 2839 } 2840 2841 /* 2842 * Verify a signal delivered by ptrace is noticed by kevent(2). 2843 */ 2844 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_kqueue); 2845 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_kqueue, tc) 2846 { 2847 pid_t fpid, wpid; 2848 int status, kq, nevents; 2849 struct kevent kev; 2850 2851 ATF_REQUIRE(signal(SIGUSR1, SIG_IGN) != SIG_ERR); 2852 2853 ATF_REQUIRE((fpid = fork()) != -1); 2854 if (fpid == 0) { 2855 CHILD_REQUIRE((kq = kqueue()) > 0); 2856 EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_ADD, 0, 0, 0); 2857 CHILD_REQUIRE(kevent(kq, &kev, 1, NULL, 0, NULL) == 0); 2858 2859 trace_me(); 2860 2861 for (;;) { 2862 nevents = kevent(kq, NULL, 0, &kev, 1, NULL); 2863 if (nevents == -1 && errno == EINTR) 2864 continue; 2865 CHILD_REQUIRE(nevents > 0); 2866 CHILD_REQUIRE(kev.filter == EVFILT_SIGNAL); 2867 CHILD_REQUIRE(kev.ident == SIGUSR1); 2868 break; 2869 } 2870 2871 exit(1); 2872 } 2873 2874 /* The first wait() should report the stop from SIGSTOP. */ 2875 wpid = waitpid(fpid, &status, 0); 2876 ATF_REQUIRE(wpid == fpid); 2877 ATF_REQUIRE(WIFSTOPPED(status)); 2878 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2879 2880 /* Continue with the SIGUSR1. */ 2881 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2882 2883 /* 2884 * The last wait() should report normal exit with code 1. 2885 */ 2886 wpid = waitpid(fpid, &status, 0); 2887 ATF_REQUIRE(wpid == fpid); 2888 ATF_REQUIRE(WIFEXITED(status)); 2889 ATF_REQUIRE(WEXITSTATUS(status) == 1); 2890 2891 wpid = wait(&status); 2892 ATF_REQUIRE(wpid == -1); 2893 ATF_REQUIRE(errno == ECHILD); 2894 } 2895 2896 static void * 2897 signal_thread(void *arg) 2898 { 2899 int err; 2900 sigset_t sigmask; 2901 2902 pthread_barrier_t *pbarrier = (pthread_barrier_t*)arg; 2903 2904 /* Wait for this thread to receive a SIGUSR1. */ 2905 do { 2906 err = sem_wait(&sigusr1_sem); 2907 CHILD_REQUIRE(err == 0 || errno == EINTR); 2908 } while (err != 0 && errno == EINTR); 2909 2910 /* Free our companion thread from the barrier. */ 2911 pthread_barrier_wait(pbarrier); 2912 2913 /* 2914 * Swap ignore duties; the next SIGUSR1 should go to the 2915 * other thread. 2916 */ 2917 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 2918 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 2919 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 2920 2921 /* Sync up threads after swapping signal masks. */ 2922 pthread_barrier_wait(pbarrier); 2923 2924 /* Wait until our companion has received its SIGUSR1. */ 2925 pthread_barrier_wait(pbarrier); 2926 2927 return (NULL); 2928 } 2929 2930 /* 2931 * Verify that a traced process with blocked signal received the 2932 * signal from kill() once unmasked. 2933 */ 2934 ATF_TC_WITHOUT_HEAD(ptrace__killed_with_sigmask); 2935 ATF_TC_BODY(ptrace__killed_with_sigmask, tc) 2936 { 2937 struct ptrace_lwpinfo pl; 2938 pid_t fpid, wpid; 2939 int status, err; 2940 sigset_t sigmask; 2941 2942 ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0); 2943 ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR); 2944 got_usr1 = 0; 2945 2946 ATF_REQUIRE((fpid = fork()) != -1); 2947 if (fpid == 0) { 2948 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 2949 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 2950 CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0); 2951 2952 trace_me(); 2953 CHILD_REQUIRE(got_usr1 == 0); 2954 2955 /* Allow the pending SIGUSR1 in now. */ 2956 CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0); 2957 /* Wait to receive a SIGUSR1. */ 2958 do { 2959 err = sem_wait(&sigusr1_sem); 2960 CHILD_REQUIRE(err == 0 || errno == EINTR); 2961 } while (err != 0 && errno == EINTR); 2962 CHILD_REQUIRE(got_usr1 == 1); 2963 exit(1); 2964 } 2965 2966 /* The first wait() should report the stop from SIGSTOP. */ 2967 wpid = waitpid(fpid, &status, 0); 2968 ATF_REQUIRE(wpid == fpid); 2969 ATF_REQUIRE(WIFSTOPPED(status)); 2970 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2971 ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1); 2972 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGSTOP); 2973 2974 /* Send blocked SIGUSR1 which should cause a stop. */ 2975 ATF_REQUIRE(kill(fpid, SIGUSR1) == 0); 2976 2977 /* Continue the child ignoring the SIGSTOP. */ 2978 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2979 2980 /* The next wait() should report the kill(SIGUSR1) was received. */ 2981 wpid = waitpid(fpid, &status, 0); 2982 ATF_REQUIRE(wpid == fpid); 2983 ATF_REQUIRE(WIFSTOPPED(status)); 2984 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1); 2985 ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1); 2986 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1); 2987 2988 /* Continue the child, allowing in the SIGUSR1. */ 2989 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2990 2991 /* The last wait() should report normal exit with code 1. */ 2992 wpid = waitpid(fpid, &status, 0); 2993 ATF_REQUIRE(wpid == fpid); 2994 ATF_REQUIRE(WIFEXITED(status)); 2995 ATF_REQUIRE(WEXITSTATUS(status) == 1); 2996 2997 wpid = wait(&status); 2998 ATF_REQUIRE(wpid == -1); 2999 ATF_REQUIRE(errno == ECHILD); 3000 } 3001 3002 /* 3003 * Verify that a traced process with blocked signal received the 3004 * signal from PT_CONTINUE once unmasked. 3005 */ 3006 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_sigmask); 3007 ATF_TC_BODY(ptrace__PT_CONTINUE_with_sigmask, tc) 3008 { 3009 struct ptrace_lwpinfo pl; 3010 pid_t fpid, wpid; 3011 int status, err; 3012 sigset_t sigmask; 3013 3014 ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0); 3015 ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR); 3016 got_usr1 = 0; 3017 3018 ATF_REQUIRE((fpid = fork()) != -1); 3019 if (fpid == 0) { 3020 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 3021 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 3022 CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0); 3023 3024 trace_me(); 3025 CHILD_REQUIRE(got_usr1 == 0); 3026 3027 /* Allow the pending SIGUSR1 in now. */ 3028 CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0); 3029 /* Wait to receive a SIGUSR1. */ 3030 do { 3031 err = sem_wait(&sigusr1_sem); 3032 CHILD_REQUIRE(err == 0 || errno == EINTR); 3033 } while (err != 0 && errno == EINTR); 3034 3035 CHILD_REQUIRE(got_usr1 == 1); 3036 exit(1); 3037 } 3038 3039 /* The first wait() should report the stop from SIGSTOP. */ 3040 wpid = waitpid(fpid, &status, 0); 3041 ATF_REQUIRE(wpid == fpid); 3042 ATF_REQUIRE(WIFSTOPPED(status)); 3043 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3044 ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1); 3045 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGSTOP); 3046 3047 /* Continue the child replacing SIGSTOP with SIGUSR1. */ 3048 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 3049 3050 /* The next wait() should report the SIGUSR1 was received. */ 3051 wpid = waitpid(fpid, &status, 0); 3052 ATF_REQUIRE(wpid == fpid); 3053 ATF_REQUIRE(WIFSTOPPED(status)); 3054 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1); 3055 ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1); 3056 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1); 3057 3058 /* Continue the child, ignoring the SIGUSR1. */ 3059 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3060 3061 /* The last wait() should report normal exit with code 1. */ 3062 wpid = waitpid(fpid, &status, 0); 3063 ATF_REQUIRE(wpid == fpid); 3064 ATF_REQUIRE(WIFEXITED(status)); 3065 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3066 3067 wpid = wait(&status); 3068 ATF_REQUIRE(wpid == -1); 3069 ATF_REQUIRE(errno == ECHILD); 3070 } 3071 3072 /* 3073 * Verify that if ptrace stops due to a signal but continues with 3074 * a different signal that the new signal is routed to a thread 3075 * that can accept it, and that the thread is awakened by the signal 3076 * in a timely manner. 3077 */ 3078 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_thread_sigmask); 3079 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_thread_sigmask, tc) 3080 { 3081 pid_t fpid, wpid; 3082 int status, err; 3083 pthread_t t; 3084 sigset_t sigmask; 3085 pthread_barrier_t barrier; 3086 3087 ATF_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 3088 ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0); 3089 ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR); 3090 3091 ATF_REQUIRE((fpid = fork()) != -1); 3092 if (fpid == 0) { 3093 CHILD_REQUIRE(pthread_create(&t, NULL, signal_thread, (void*)&barrier) == 0); 3094 3095 /* The other thread should receive the first SIGUSR1. */ 3096 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 3097 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 3098 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 3099 3100 trace_me(); 3101 3102 /* Wait until other thread has received its SIGUSR1. */ 3103 pthread_barrier_wait(&barrier); 3104 3105 /* 3106 * Swap ignore duties; the next SIGUSR1 should go to this 3107 * thread. 3108 */ 3109 CHILD_REQUIRE(pthread_sigmask(SIG_UNBLOCK, &sigmask, NULL) == 0); 3110 3111 /* Sync up threads after swapping signal masks. */ 3112 pthread_barrier_wait(&barrier); 3113 3114 /* 3115 * Sync up with test code; we're ready for the next SIGUSR1 3116 * now. 3117 */ 3118 raise(SIGSTOP); 3119 3120 /* Wait for this thread to receive a SIGUSR1. */ 3121 do { 3122 err = sem_wait(&sigusr1_sem); 3123 CHILD_REQUIRE(err == 0 || errno == EINTR); 3124 } while (err != 0 && errno == EINTR); 3125 3126 /* Free the other thread from the barrier. */ 3127 pthread_barrier_wait(&barrier); 3128 3129 CHILD_REQUIRE(pthread_join(t, NULL) == 0); 3130 3131 exit(1); 3132 } 3133 3134 /* The first wait() should report the stop from SIGSTOP. */ 3135 wpid = waitpid(fpid, &status, 0); 3136 ATF_REQUIRE(wpid == fpid); 3137 ATF_REQUIRE(WIFSTOPPED(status)); 3138 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3139 3140 /* Continue the child ignoring the SIGSTOP. */ 3141 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3142 3143 /* 3144 * Send a signal without ptrace that either thread will accept (USR2, 3145 * in this case). 3146 */ 3147 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 3148 3149 /* The second wait() should report a SIGUSR2 was received. */ 3150 wpid = waitpid(fpid, &status, 0); 3151 ATF_REQUIRE(wpid == fpid); 3152 ATF_REQUIRE(WIFSTOPPED(status)); 3153 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 3154 3155 /* Continue the child, changing the signal to USR1. */ 3156 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 3157 3158 /* The next wait() should report the stop from SIGSTOP. */ 3159 wpid = waitpid(fpid, &status, 0); 3160 ATF_REQUIRE(wpid == fpid); 3161 ATF_REQUIRE(WIFSTOPPED(status)); 3162 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3163 3164 /* Continue the child ignoring the SIGSTOP. */ 3165 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3166 3167 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 3168 3169 /* The next wait() should report a SIGUSR2 was received. */ 3170 wpid = waitpid(fpid, &status, 0); 3171 ATF_REQUIRE(wpid == fpid); 3172 ATF_REQUIRE(WIFSTOPPED(status)); 3173 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 3174 3175 /* Continue the child, changing the signal to USR1. */ 3176 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 3177 3178 /* The last wait() should report normal exit with code 1. */ 3179 wpid = waitpid(fpid, &status, 0); 3180 ATF_REQUIRE(wpid == fpid); 3181 ATF_REQUIRE(WIFEXITED(status)); 3182 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3183 3184 wpid = wait(&status); 3185 ATF_REQUIRE(wpid == -1); 3186 ATF_REQUIRE(errno == ECHILD); 3187 } 3188 3189 static void * 3190 raise_sigstop_thread(void *arg __unused) 3191 { 3192 3193 raise(SIGSTOP); 3194 return NULL; 3195 } 3196 3197 static void * 3198 sleep_thread(void *arg __unused) 3199 { 3200 3201 sleep(60); 3202 return NULL; 3203 } 3204 3205 static void 3206 terminate_with_pending_sigstop(bool sigstop_from_main_thread) 3207 { 3208 pid_t fpid, wpid; 3209 int status, i; 3210 cpuset_t setmask; 3211 cpusetid_t setid; 3212 pthread_t t; 3213 3214 /* 3215 * Become the reaper for this process tree. We need to be able to check 3216 * that both child and grandchild have died. 3217 */ 3218 ATF_REQUIRE(procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0); 3219 3220 fpid = fork(); 3221 ATF_REQUIRE(fpid >= 0); 3222 if (fpid == 0) { 3223 fpid = fork(); 3224 CHILD_REQUIRE(fpid >= 0); 3225 if (fpid == 0) { 3226 trace_me(); 3227 3228 /* Pin to CPU 0 to serialize thread execution. */ 3229 CPU_ZERO(&setmask); 3230 CPU_SET(0, &setmask); 3231 CHILD_REQUIRE(cpuset(&setid) == 0); 3232 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 3233 CPU_WHICH_CPUSET, setid, 3234 sizeof(setmask), &setmask) == 0); 3235 3236 if (sigstop_from_main_thread) { 3237 /* 3238 * We expect the SIGKILL sent when our parent 3239 * dies to be delivered to the new thread. 3240 * Raise the SIGSTOP in this thread so the 3241 * threads compete. 3242 */ 3243 CHILD_REQUIRE(pthread_create(&t, NULL, 3244 sleep_thread, NULL) == 0); 3245 raise(SIGSTOP); 3246 } else { 3247 /* 3248 * We expect the SIGKILL to be delivered to 3249 * this thread. After creating the new thread, 3250 * just get off the CPU so the other thread can 3251 * raise the SIGSTOP. 3252 */ 3253 CHILD_REQUIRE(pthread_create(&t, NULL, 3254 raise_sigstop_thread, NULL) == 0); 3255 sleep(60); 3256 } 3257 3258 exit(0); 3259 } 3260 /* First stop is trace_me() immediately after fork. */ 3261 wpid = waitpid(fpid, &status, 0); 3262 CHILD_REQUIRE(wpid == fpid); 3263 CHILD_REQUIRE(WIFSTOPPED(status)); 3264 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3265 3266 CHILD_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3267 3268 /* Second stop is from the raise(SIGSTOP). */ 3269 wpid = waitpid(fpid, &status, 0); 3270 CHILD_REQUIRE(wpid == fpid); 3271 CHILD_REQUIRE(WIFSTOPPED(status)); 3272 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3273 3274 /* 3275 * Terminate tracing process without detaching. Our child 3276 * should be killed. 3277 */ 3278 exit(0); 3279 } 3280 3281 /* 3282 * We should get a normal exit from our immediate child and a SIGKILL 3283 * exit from our grandchild. The latter case is the interesting one. 3284 * Our grandchild should not have stopped due to the SIGSTOP that was 3285 * left dangling when its parent died. 3286 */ 3287 for (i = 0; i < 2; ++i) { 3288 wpid = wait(&status); 3289 if (wpid == fpid) 3290 ATF_REQUIRE(WIFEXITED(status) && 3291 WEXITSTATUS(status) == 0); 3292 else 3293 ATF_REQUIRE(WIFSIGNALED(status) && 3294 WTERMSIG(status) == SIGKILL); 3295 } 3296 } 3297 3298 /* 3299 * These two tests ensure that if the tracing process exits without detaching 3300 * just after the child received a SIGSTOP, the child is cleanly killed and 3301 * doesn't go to sleep due to the SIGSTOP. The parent's death will send a 3302 * SIGKILL to the child. If the SIGKILL and the SIGSTOP are handled by 3303 * different threads, the SIGKILL must win. There are two variants of this 3304 * test, designed to catch the case where the SIGKILL is delivered to the 3305 * younger thread (the first test) and the case where the SIGKILL is delivered 3306 * to the older thread (the second test). This behavior has changed in the 3307 * past, so make no assumption. 3308 */ 3309 ATF_TC(ptrace__parent_terminate_with_pending_sigstop1); 3310 ATF_TC_HEAD(ptrace__parent_terminate_with_pending_sigstop1, tc) 3311 { 3312 3313 atf_tc_set_md_var(tc, "require.user", "root"); 3314 } 3315 ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop1, tc) 3316 { 3317 3318 terminate_with_pending_sigstop(true); 3319 } 3320 3321 ATF_TC(ptrace__parent_terminate_with_pending_sigstop2); 3322 ATF_TC_HEAD(ptrace__parent_terminate_with_pending_sigstop2, tc) 3323 { 3324 3325 atf_tc_set_md_var(tc, "require.user", "root"); 3326 } 3327 ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop2, tc) 3328 { 3329 3330 terminate_with_pending_sigstop(false); 3331 } 3332 3333 /* 3334 * Verify that after ptrace() discards a SIGKILL signal, the event mask 3335 * is not modified. 3336 */ 3337 ATF_TC_WITHOUT_HEAD(ptrace__event_mask_sigkill_discard); 3338 ATF_TC_BODY(ptrace__event_mask_sigkill_discard, tc) 3339 { 3340 struct ptrace_lwpinfo pl; 3341 pid_t fpid, wpid; 3342 int status, event_mask, new_event_mask; 3343 3344 ATF_REQUIRE((fpid = fork()) != -1); 3345 if (fpid == 0) { 3346 trace_me(); 3347 raise(SIGSTOP); 3348 exit(0); 3349 } 3350 3351 /* The first wait() should report the stop from trace_me(). */ 3352 wpid = waitpid(fpid, &status, 0); 3353 ATF_REQUIRE(wpid == fpid); 3354 ATF_REQUIRE(WIFSTOPPED(status)); 3355 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3356 3357 /* Set several unobtrusive event bits. */ 3358 event_mask = PTRACE_EXEC | PTRACE_FORK | PTRACE_LWP; 3359 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, wpid, (caddr_t)&event_mask, 3360 sizeof(event_mask)) == 0); 3361 3362 /* Send a SIGKILL without using ptrace. */ 3363 ATF_REQUIRE(kill(fpid, SIGKILL) == 0); 3364 3365 /* Continue the child ignoring the SIGSTOP. */ 3366 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3367 3368 /* The next stop should be due to the SIGKILL. */ 3369 wpid = waitpid(fpid, &status, 0); 3370 ATF_REQUIRE(wpid == fpid); 3371 ATF_REQUIRE(WIFSTOPPED(status)); 3372 ATF_REQUIRE(WSTOPSIG(status) == SIGKILL); 3373 3374 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3375 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 3376 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGKILL); 3377 3378 /* Continue the child ignoring the SIGKILL. */ 3379 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3380 3381 /* The next wait() should report the stop from SIGSTOP. */ 3382 wpid = waitpid(fpid, &status, 0); 3383 ATF_REQUIRE(wpid == fpid); 3384 ATF_REQUIRE(WIFSTOPPED(status)); 3385 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3386 3387 /* Check the current event mask. It should not have changed. */ 3388 new_event_mask = 0; 3389 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, wpid, (caddr_t)&new_event_mask, 3390 sizeof(new_event_mask)) == 0); 3391 ATF_REQUIRE(event_mask == new_event_mask); 3392 3393 /* Continue the child to let it exit. */ 3394 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3395 3396 /* The last event should be for the child process's exit. */ 3397 wpid = waitpid(fpid, &status, 0); 3398 ATF_REQUIRE(WIFEXITED(status)); 3399 ATF_REQUIRE(WEXITSTATUS(status) == 0); 3400 3401 wpid = wait(&status); 3402 ATF_REQUIRE(wpid == -1); 3403 ATF_REQUIRE(errno == ECHILD); 3404 } 3405 3406 static void * 3407 flock_thread(void *arg) 3408 { 3409 int fd; 3410 3411 fd = *(int *)arg; 3412 (void)flock(fd, LOCK_EX); 3413 (void)flock(fd, LOCK_UN); 3414 return (NULL); 3415 } 3416 3417 /* 3418 * Verify that PT_ATTACH will suspend threads sleeping in an SBDRY section. 3419 * We rely on the fact that the lockf implementation sets SBDRY before blocking 3420 * on a lock. This is a regression test for r318191. 3421 */ 3422 ATF_TC_WITHOUT_HEAD(ptrace__PT_ATTACH_with_SBDRY_thread); 3423 ATF_TC_BODY(ptrace__PT_ATTACH_with_SBDRY_thread, tc) 3424 { 3425 pthread_barrier_t barrier; 3426 pthread_barrierattr_t battr; 3427 char tmpfile[64]; 3428 pid_t child, wpid; 3429 int error, fd, i, status; 3430 3431 ATF_REQUIRE(pthread_barrierattr_init(&battr) == 0); 3432 ATF_REQUIRE(pthread_barrierattr_setpshared(&battr, 3433 PTHREAD_PROCESS_SHARED) == 0); 3434 ATF_REQUIRE(pthread_barrier_init(&barrier, &battr, 2) == 0); 3435 3436 (void)snprintf(tmpfile, sizeof(tmpfile), "./ptrace.XXXXXX"); 3437 fd = mkstemp(tmpfile); 3438 ATF_REQUIRE(fd >= 0); 3439 3440 ATF_REQUIRE((child = fork()) != -1); 3441 if (child == 0) { 3442 pthread_t t[2]; 3443 int cfd; 3444 3445 error = pthread_barrier_wait(&barrier); 3446 if (error != 0 && error != PTHREAD_BARRIER_SERIAL_THREAD) 3447 _exit(1); 3448 3449 cfd = open(tmpfile, O_RDONLY); 3450 if (cfd < 0) 3451 _exit(1); 3452 3453 /* 3454 * We want at least two threads blocked on the file lock since 3455 * the SIGSTOP from PT_ATTACH may kick one of them out of 3456 * sleep. 3457 */ 3458 if (pthread_create(&t[0], NULL, flock_thread, &cfd) != 0) 3459 _exit(1); 3460 if (pthread_create(&t[1], NULL, flock_thread, &cfd) != 0) 3461 _exit(1); 3462 if (pthread_join(t[0], NULL) != 0) 3463 _exit(1); 3464 if (pthread_join(t[1], NULL) != 0) 3465 _exit(1); 3466 _exit(0); 3467 } 3468 3469 ATF_REQUIRE(flock(fd, LOCK_EX) == 0); 3470 3471 error = pthread_barrier_wait(&barrier); 3472 ATF_REQUIRE(error == 0 || error == PTHREAD_BARRIER_SERIAL_THREAD); 3473 3474 /* 3475 * Give the child some time to block. Is there a better way to do this? 3476 */ 3477 sleep(1); 3478 3479 /* 3480 * Attach and give the child 3 seconds to stop. 3481 */ 3482 ATF_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) == 0); 3483 for (i = 0; i < 3; i++) { 3484 wpid = waitpid(child, &status, WNOHANG); 3485 if (wpid == child && WIFSTOPPED(status) && 3486 WSTOPSIG(status) == SIGSTOP) 3487 break; 3488 sleep(1); 3489 } 3490 ATF_REQUIRE_MSG(i < 3, "failed to stop child process after PT_ATTACH"); 3491 3492 ATF_REQUIRE(ptrace(PT_DETACH, child, NULL, 0) == 0); 3493 3494 ATF_REQUIRE(flock(fd, LOCK_UN) == 0); 3495 ATF_REQUIRE(unlink(tmpfile) == 0); 3496 ATF_REQUIRE(close(fd) == 0); 3497 } 3498 3499 static void 3500 sigusr1_step_handler(int sig) 3501 { 3502 3503 CHILD_REQUIRE(sig == SIGUSR1); 3504 raise(SIGABRT); 3505 } 3506 3507 /* 3508 * Verify that PT_STEP with a signal invokes the signal before 3509 * stepping the next instruction (and that the next instruction is 3510 * stepped correctly). 3511 */ 3512 ATF_TC_WITHOUT_HEAD(ptrace__PT_STEP_with_signal); 3513 ATF_TC_BODY(ptrace__PT_STEP_with_signal, tc) 3514 { 3515 struct ptrace_lwpinfo pl; 3516 pid_t fpid, wpid; 3517 int status; 3518 3519 ATF_REQUIRE((fpid = fork()) != -1); 3520 if (fpid == 0) { 3521 trace_me(); 3522 signal(SIGUSR1, sigusr1_step_handler); 3523 raise(SIGABRT); 3524 exit(1); 3525 } 3526 3527 /* The first wait() should report the stop from SIGSTOP. */ 3528 wpid = waitpid(fpid, &status, 0); 3529 ATF_REQUIRE(wpid == fpid); 3530 ATF_REQUIRE(WIFSTOPPED(status)); 3531 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3532 3533 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3534 3535 /* The next stop should report the SIGABRT in the child body. */ 3536 wpid = waitpid(fpid, &status, 0); 3537 ATF_REQUIRE(wpid == fpid); 3538 ATF_REQUIRE(WIFSTOPPED(status)); 3539 ATF_REQUIRE(WSTOPSIG(status) == SIGABRT); 3540 3541 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3542 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 3543 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT); 3544 3545 /* Step the child process inserting SIGUSR1. */ 3546 ATF_REQUIRE(ptrace(PT_STEP, fpid, (caddr_t)1, SIGUSR1) == 0); 3547 3548 /* The next stop should report the SIGABRT in the signal handler. */ 3549 wpid = waitpid(fpid, &status, 0); 3550 ATF_REQUIRE(wpid == fpid); 3551 ATF_REQUIRE(WIFSTOPPED(status)); 3552 ATF_REQUIRE(WSTOPSIG(status) == SIGABRT); 3553 3554 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3555 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 3556 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT); 3557 3558 /* Continue the child process discarding the signal. */ 3559 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3560 3561 /* The next stop should report a trace trap from PT_STEP. */ 3562 wpid = waitpid(fpid, &status, 0); 3563 ATF_REQUIRE(wpid == fpid); 3564 ATF_REQUIRE(WIFSTOPPED(status)); 3565 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3566 3567 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3568 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 3569 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP); 3570 ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_TRACE); 3571 3572 /* Continue the child to let it exit. */ 3573 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3574 3575 /* The last event should be for the child process's exit. */ 3576 wpid = waitpid(fpid, &status, 0); 3577 ATF_REQUIRE(WIFEXITED(status)); 3578 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3579 3580 wpid = wait(&status); 3581 ATF_REQUIRE(wpid == -1); 3582 ATF_REQUIRE(errno == ECHILD); 3583 } 3584 3585 #ifdef HAVE_BREAKPOINT 3586 /* 3587 * Verify that a SIGTRAP event with the TRAP_BRKPT code is reported 3588 * for a breakpoint trap. 3589 */ 3590 ATF_TC_WITHOUT_HEAD(ptrace__breakpoint_siginfo); 3591 ATF_TC_BODY(ptrace__breakpoint_siginfo, tc) 3592 { 3593 struct ptrace_lwpinfo pl; 3594 pid_t fpid, wpid; 3595 int status; 3596 3597 ATF_REQUIRE((fpid = fork()) != -1); 3598 if (fpid == 0) { 3599 trace_me(); 3600 breakpoint(); 3601 exit(1); 3602 } 3603 3604 /* The first wait() should report the stop from SIGSTOP. */ 3605 wpid = waitpid(fpid, &status, 0); 3606 ATF_REQUIRE(wpid == fpid); 3607 ATF_REQUIRE(WIFSTOPPED(status)); 3608 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3609 3610 /* Continue the child ignoring the SIGSTOP. */ 3611 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3612 3613 /* The second wait() should report hitting the breakpoint. */ 3614 wpid = waitpid(fpid, &status, 0); 3615 ATF_REQUIRE(wpid == fpid); 3616 ATF_REQUIRE(WIFSTOPPED(status)); 3617 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3618 3619 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3620 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0); 3621 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP); 3622 ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_BRKPT); 3623 3624 /* Kill the child process. */ 3625 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 3626 3627 /* The last wait() should report the SIGKILL. */ 3628 wpid = waitpid(fpid, &status, 0); 3629 ATF_REQUIRE(wpid == fpid); 3630 ATF_REQUIRE(WIFSIGNALED(status)); 3631 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 3632 3633 wpid = wait(&status); 3634 ATF_REQUIRE(wpid == -1); 3635 ATF_REQUIRE(errno == ECHILD); 3636 } 3637 #endif /* HAVE_BREAKPOINT */ 3638 3639 /* 3640 * Verify that a SIGTRAP event with the TRAP_TRACE code is reported 3641 * for a single-step trap from PT_STEP. 3642 */ 3643 ATF_TC_WITHOUT_HEAD(ptrace__step_siginfo); 3644 ATF_TC_BODY(ptrace__step_siginfo, tc) 3645 { 3646 struct ptrace_lwpinfo pl; 3647 pid_t fpid, wpid; 3648 int status; 3649 3650 ATF_REQUIRE((fpid = fork()) != -1); 3651 if (fpid == 0) { 3652 trace_me(); 3653 exit(1); 3654 } 3655 3656 /* The first wait() should report the stop from SIGSTOP. */ 3657 wpid = waitpid(fpid, &status, 0); 3658 ATF_REQUIRE(wpid == fpid); 3659 ATF_REQUIRE(WIFSTOPPED(status)); 3660 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3661 3662 /* Step the child ignoring the SIGSTOP. */ 3663 ATF_REQUIRE(ptrace(PT_STEP, fpid, (caddr_t)1, 0) == 0); 3664 3665 /* The second wait() should report a single-step trap. */ 3666 wpid = waitpid(fpid, &status, 0); 3667 ATF_REQUIRE(wpid == fpid); 3668 ATF_REQUIRE(WIFSTOPPED(status)); 3669 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3670 3671 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3672 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0); 3673 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP); 3674 ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_TRACE); 3675 3676 /* Continue the child process. */ 3677 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3678 3679 /* The last event should be for the child process's exit. */ 3680 wpid = waitpid(fpid, &status, 0); 3681 ATF_REQUIRE(WIFEXITED(status)); 3682 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3683 3684 wpid = wait(&status); 3685 ATF_REQUIRE(wpid == -1); 3686 ATF_REQUIRE(errno == ECHILD); 3687 } 3688 3689 #if defined(HAVE_BREAKPOINT) && defined(SKIP_BREAK) 3690 static void * 3691 continue_thread(void *arg __unused) 3692 { 3693 breakpoint(); 3694 return (NULL); 3695 } 3696 3697 static __dead2 void 3698 continue_thread_main(void) 3699 { 3700 pthread_t threads[2]; 3701 3702 CHILD_REQUIRE(pthread_create(&threads[0], NULL, continue_thread, 3703 NULL) == 0); 3704 CHILD_REQUIRE(pthread_create(&threads[1], NULL, continue_thread, 3705 NULL) == 0); 3706 CHILD_REQUIRE(pthread_join(threads[0], NULL) == 0); 3707 CHILD_REQUIRE(pthread_join(threads[1], NULL) == 0); 3708 exit(1); 3709 } 3710 3711 /* 3712 * Ensure that PT_CONTINUE clears the status of the thread that 3713 * triggered the stop even if a different thread's LWP was passed to 3714 * PT_CONTINUE. 3715 */ 3716 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_different_thread); 3717 ATF_TC_BODY(ptrace__PT_CONTINUE_different_thread, tc) 3718 { 3719 struct ptrace_lwpinfo pl; 3720 pid_t fpid, wpid; 3721 lwpid_t lwps[2]; 3722 bool hit_break[2]; 3723 struct reg reg; 3724 int i, j, status; 3725 3726 ATF_REQUIRE((fpid = fork()) != -1); 3727 if (fpid == 0) { 3728 trace_me(); 3729 continue_thread_main(); 3730 } 3731 3732 /* The first wait() should report the stop from SIGSTOP. */ 3733 wpid = waitpid(fpid, &status, 0); 3734 ATF_REQUIRE(wpid == fpid); 3735 ATF_REQUIRE(WIFSTOPPED(status)); 3736 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3737 3738 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 3739 sizeof(pl)) != -1); 3740 3741 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 3742 3743 /* Continue the child ignoring the SIGSTOP. */ 3744 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3745 3746 /* One of the new threads should report it's birth. */ 3747 wpid = waitpid(fpid, &status, 0); 3748 ATF_REQUIRE(wpid == fpid); 3749 ATF_REQUIRE(WIFSTOPPED(status)); 3750 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3751 3752 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3753 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 3754 (PL_FLAG_BORN | PL_FLAG_SCX)); 3755 lwps[0] = pl.pl_lwpid; 3756 3757 /* 3758 * Suspend this thread to ensure both threads are alive before 3759 * hitting the breakpoint. 3760 */ 3761 ATF_REQUIRE(ptrace(PT_SUSPEND, lwps[0], NULL, 0) != -1); 3762 3763 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3764 3765 /* Second thread should report it's birth. */ 3766 wpid = waitpid(fpid, &status, 0); 3767 ATF_REQUIRE(wpid == fpid); 3768 ATF_REQUIRE(WIFSTOPPED(status)); 3769 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3770 3771 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3772 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 3773 (PL_FLAG_BORN | PL_FLAG_SCX)); 3774 ATF_REQUIRE(pl.pl_lwpid != lwps[0]); 3775 lwps[1] = pl.pl_lwpid; 3776 3777 /* Resume both threads waiting for breakpoint events. */ 3778 hit_break[0] = hit_break[1] = false; 3779 ATF_REQUIRE(ptrace(PT_RESUME, lwps[0], NULL, 0) != -1); 3780 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3781 3782 /* One thread should report a breakpoint. */ 3783 wpid = waitpid(fpid, &status, 0); 3784 ATF_REQUIRE(wpid == fpid); 3785 ATF_REQUIRE(WIFSTOPPED(status)); 3786 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3787 3788 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3789 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0); 3790 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP && 3791 pl.pl_siginfo.si_code == TRAP_BRKPT); 3792 if (pl.pl_lwpid == lwps[0]) 3793 i = 0; 3794 else 3795 i = 1; 3796 hit_break[i] = true; 3797 ATF_REQUIRE(ptrace(PT_GETREGS, pl.pl_lwpid, (caddr_t)®, 0) != -1); 3798 SKIP_BREAK(®); 3799 ATF_REQUIRE(ptrace(PT_SETREGS, pl.pl_lwpid, (caddr_t)®, 0) != -1); 3800 3801 /* 3802 * Resume both threads but pass the other thread's LWPID to 3803 * PT_CONTINUE. 3804 */ 3805 ATF_REQUIRE(ptrace(PT_CONTINUE, lwps[i ^ 1], (caddr_t)1, 0) == 0); 3806 3807 /* 3808 * Will now get two thread exit events and one more breakpoint 3809 * event. 3810 */ 3811 for (j = 0; j < 3; j++) { 3812 wpid = waitpid(fpid, &status, 0); 3813 ATF_REQUIRE(wpid == fpid); 3814 ATF_REQUIRE(WIFSTOPPED(status)); 3815 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3816 3817 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 3818 sizeof(pl)) != -1); 3819 3820 if (pl.pl_lwpid == lwps[0]) 3821 i = 0; 3822 else 3823 i = 1; 3824 3825 ATF_REQUIRE_MSG(lwps[i] != 0, "event for exited thread"); 3826 if (pl.pl_flags & PL_FLAG_EXITED) { 3827 ATF_REQUIRE_MSG(hit_break[i], 3828 "exited thread did not report breakpoint"); 3829 lwps[i] = 0; 3830 } else { 3831 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0); 3832 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP && 3833 pl.pl_siginfo.si_code == TRAP_BRKPT); 3834 ATF_REQUIRE_MSG(!hit_break[i], 3835 "double breakpoint event"); 3836 hit_break[i] = true; 3837 ATF_REQUIRE(ptrace(PT_GETREGS, pl.pl_lwpid, (caddr_t)®, 3838 0) != -1); 3839 SKIP_BREAK(®); 3840 ATF_REQUIRE(ptrace(PT_SETREGS, pl.pl_lwpid, (caddr_t)®, 3841 0) != -1); 3842 } 3843 3844 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3845 } 3846 3847 /* Both threads should have exited. */ 3848 ATF_REQUIRE(lwps[0] == 0); 3849 ATF_REQUIRE(lwps[1] == 0); 3850 3851 /* The last event should be for the child process's exit. */ 3852 wpid = waitpid(fpid, &status, 0); 3853 ATF_REQUIRE(WIFEXITED(status)); 3854 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3855 3856 wpid = wait(&status); 3857 ATF_REQUIRE(wpid == -1); 3858 ATF_REQUIRE(errno == ECHILD); 3859 } 3860 #endif 3861 3862 /* 3863 * Verify that PT_LWPINFO doesn't return stale siginfo. 3864 */ 3865 ATF_TC_WITHOUT_HEAD(ptrace__PT_LWPINFO_stale_siginfo); 3866 ATF_TC_BODY(ptrace__PT_LWPINFO_stale_siginfo, tc) 3867 { 3868 struct ptrace_lwpinfo pl; 3869 pid_t fpid, wpid; 3870 int events, status; 3871 3872 ATF_REQUIRE((fpid = fork()) != -1); 3873 if (fpid == 0) { 3874 trace_me(); 3875 raise(SIGABRT); 3876 exit(1); 3877 } 3878 3879 /* The first wait() should report the stop from SIGSTOP. */ 3880 wpid = waitpid(fpid, &status, 0); 3881 ATF_REQUIRE(wpid == fpid); 3882 ATF_REQUIRE(WIFSTOPPED(status)); 3883 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3884 3885 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3886 3887 /* The next stop should report the SIGABRT in the child body. */ 3888 wpid = waitpid(fpid, &status, 0); 3889 ATF_REQUIRE(wpid == fpid); 3890 ATF_REQUIRE(WIFSTOPPED(status)); 3891 ATF_REQUIRE(WSTOPSIG(status) == SIGABRT); 3892 3893 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3894 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 3895 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT); 3896 3897 /* 3898 * Continue the process ignoring the signal, but enabling 3899 * syscall traps. 3900 */ 3901 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 3902 3903 /* 3904 * The next stop should report a system call entry from 3905 * exit(). PL_FLAGS_SI should not be set. 3906 */ 3907 wpid = waitpid(fpid, &status, 0); 3908 ATF_REQUIRE(wpid == fpid); 3909 ATF_REQUIRE(WIFSTOPPED(status)); 3910 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3911 3912 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3913 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 3914 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) == 0); 3915 3916 /* Disable syscall tracing and continue the child to let it exit. */ 3917 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 3918 sizeof(events)) == 0); 3919 events &= ~PTRACE_SYSCALL; 3920 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 3921 sizeof(events)) == 0); 3922 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3923 3924 /* The last event should be for the child process's exit. */ 3925 wpid = waitpid(fpid, &status, 0); 3926 ATF_REQUIRE(WIFEXITED(status)); 3927 ATF_REQUIRE(WEXITSTATUS(status) == 1); 3928 3929 wpid = wait(&status); 3930 ATF_REQUIRE(wpid == -1); 3931 ATF_REQUIRE(errno == ECHILD); 3932 } 3933 3934 /* 3935 * A simple test of PT_GET_SC_ARGS and PT_GET_SC_RET. 3936 */ 3937 ATF_TC_WITHOUT_HEAD(ptrace__syscall_args); 3938 ATF_TC_BODY(ptrace__syscall_args, tc) 3939 { 3940 struct ptrace_lwpinfo pl; 3941 struct ptrace_sc_ret psr; 3942 pid_t fpid, wpid; 3943 register_t args[2]; 3944 int events, status; 3945 3946 ATF_REQUIRE((fpid = fork()) != -1); 3947 if (fpid == 0) { 3948 trace_me(); 3949 kill(getpid(), 0); 3950 close(3); 3951 exit(1); 3952 } 3953 3954 /* The first wait() should report the stop from SIGSTOP. */ 3955 wpid = waitpid(fpid, &status, 0); 3956 ATF_REQUIRE(wpid == fpid); 3957 ATF_REQUIRE(WIFSTOPPED(status)); 3958 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 3959 3960 /* 3961 * Continue the process ignoring the signal, but enabling 3962 * syscall traps. 3963 */ 3964 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 3965 3966 /* 3967 * The next stop should be the syscall entry from getpid(). 3968 */ 3969 wpid = waitpid(fpid, &status, 0); 3970 ATF_REQUIRE(wpid == fpid); 3971 ATF_REQUIRE(WIFSTOPPED(status)); 3972 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3973 3974 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3975 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 3976 ATF_REQUIRE(pl.pl_syscall_code == SYS_getpid); 3977 3978 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3979 3980 /* 3981 * The next stop should be the syscall exit from getpid(). 3982 */ 3983 wpid = waitpid(fpid, &status, 0); 3984 ATF_REQUIRE(wpid == fpid); 3985 ATF_REQUIRE(WIFSTOPPED(status)); 3986 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 3987 3988 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 3989 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 3990 ATF_REQUIRE(pl.pl_syscall_code == SYS_getpid); 3991 3992 ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr, 3993 sizeof(psr)) != -1); 3994 ATF_REQUIRE(psr.sr_error == 0); 3995 ATF_REQUIRE(psr.sr_retval[0] == wpid); 3996 3997 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 3998 3999 /* 4000 * The next stop should be the syscall entry from kill(). 4001 */ 4002 wpid = waitpid(fpid, &status, 0); 4003 ATF_REQUIRE(wpid == fpid); 4004 ATF_REQUIRE(WIFSTOPPED(status)); 4005 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 4006 4007 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 4008 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 4009 ATF_REQUIRE(pl.pl_syscall_code == SYS_kill); 4010 ATF_REQUIRE(pl.pl_syscall_narg == 2); 4011 4012 ATF_REQUIRE(ptrace(PT_GET_SC_ARGS, wpid, (caddr_t)args, 4013 sizeof(args)) != -1); 4014 ATF_REQUIRE(args[0] == wpid); 4015 ATF_REQUIRE(args[1] == 0); 4016 4017 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 4018 4019 /* 4020 * The next stop should be the syscall exit from kill(). 4021 */ 4022 wpid = waitpid(fpid, &status, 0); 4023 ATF_REQUIRE(wpid == fpid); 4024 ATF_REQUIRE(WIFSTOPPED(status)); 4025 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 4026 4027 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 4028 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 4029 ATF_REQUIRE(pl.pl_syscall_code == SYS_kill); 4030 4031 ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr, 4032 sizeof(psr)) != -1); 4033 ATF_REQUIRE(psr.sr_error == 0); 4034 4035 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 4036 4037 /* 4038 * The next stop should be the syscall entry from close(). 4039 */ 4040 wpid = waitpid(fpid, &status, 0); 4041 ATF_REQUIRE(wpid == fpid); 4042 ATF_REQUIRE(WIFSTOPPED(status)); 4043 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 4044 4045 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 4046 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 4047 ATF_REQUIRE(pl.pl_syscall_code == SYS_close); 4048 ATF_REQUIRE(pl.pl_syscall_narg == 1); 4049 4050 ATF_REQUIRE(ptrace(PT_GET_SC_ARGS, wpid, (caddr_t)args, 4051 sizeof(args)) != -1); 4052 ATF_REQUIRE(args[0] == 3); 4053 4054 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 4055 4056 /* 4057 * The next stop should be the syscall exit from close(). 4058 */ 4059 wpid = waitpid(fpid, &status, 0); 4060 ATF_REQUIRE(wpid == fpid); 4061 ATF_REQUIRE(WIFSTOPPED(status)); 4062 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 4063 4064 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 4065 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 4066 ATF_REQUIRE(pl.pl_syscall_code == SYS_close); 4067 4068 ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr, 4069 sizeof(psr)) != -1); 4070 ATF_REQUIRE(psr.sr_error == EBADF); 4071 4072 /* Disable syscall tracing and continue the child to let it exit. */ 4073 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 4074 sizeof(events)) == 0); 4075 events &= ~PTRACE_SYSCALL; 4076 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 4077 sizeof(events)) == 0); 4078 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 4079 4080 /* The last event should be for the child process's exit. */ 4081 wpid = waitpid(fpid, &status, 0); 4082 ATF_REQUIRE(WIFEXITED(status)); 4083 ATF_REQUIRE(WEXITSTATUS(status) == 1); 4084 4085 wpid = wait(&status); 4086 ATF_REQUIRE(wpid == -1); 4087 ATF_REQUIRE(errno == ECHILD); 4088 } 4089 4090 /* 4091 * Verify that when the process is traced that it isn't reparent 4092 * to the init process when we close all process descriptors. 4093 */ 4094 ATF_TC(ptrace__proc_reparent); 4095 ATF_TC_HEAD(ptrace__proc_reparent, tc) 4096 { 4097 4098 atf_tc_set_md_var(tc, "timeout", "2"); 4099 } 4100 ATF_TC_BODY(ptrace__proc_reparent, tc) 4101 { 4102 pid_t traced, debuger, wpid; 4103 int pd, status; 4104 4105 traced = pdfork(&pd, 0); 4106 ATF_REQUIRE(traced >= 0); 4107 if (traced == 0) { 4108 raise(SIGSTOP); 4109 exit(0); 4110 } 4111 ATF_REQUIRE(pd >= 0); 4112 4113 debuger = fork(); 4114 ATF_REQUIRE(debuger >= 0); 4115 if (debuger == 0) { 4116 /* The traced process is reparented to debuger. */ 4117 ATF_REQUIRE(ptrace(PT_ATTACH, traced, 0, 0) == 0); 4118 wpid = waitpid(traced, &status, 0); 4119 ATF_REQUIRE(wpid == traced); 4120 ATF_REQUIRE(WIFSTOPPED(status)); 4121 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 4122 ATF_REQUIRE(close(pd) == 0); 4123 ATF_REQUIRE(ptrace(PT_DETACH, traced, (caddr_t)1, 0) == 0); 4124 4125 /* We closed pd so we should not have any child. */ 4126 wpid = wait(&status); 4127 ATF_REQUIRE(wpid == -1); 4128 ATF_REQUIRE(errno == ECHILD); 4129 4130 exit(0); 4131 } 4132 4133 ATF_REQUIRE(close(pd) == 0); 4134 wpid = waitpid(debuger, &status, 0); 4135 ATF_REQUIRE(wpid == debuger); 4136 ATF_REQUIRE(WEXITSTATUS(status) == 0); 4137 4138 /* Check if we still have any child. */ 4139 wpid = wait(&status); 4140 ATF_REQUIRE(wpid == -1); 4141 ATF_REQUIRE(errno == ECHILD); 4142 } 4143 4144 /* 4145 * Ensure that traced processes created with pdfork(2) are visible to 4146 * waitid(P_ALL). 4147 */ 4148 ATF_TC_WITHOUT_HEAD(ptrace__procdesc_wait_child); 4149 ATF_TC_BODY(ptrace__procdesc_wait_child, tc) 4150 { 4151 pid_t child, wpid; 4152 int pd, status; 4153 4154 child = pdfork(&pd, 0); 4155 ATF_REQUIRE(child >= 0); 4156 4157 if (child == 0) { 4158 trace_me(); 4159 (void)raise(SIGSTOP); 4160 exit(0); 4161 } 4162 4163 wpid = waitpid(child, &status, 0); 4164 ATF_REQUIRE(wpid == child); 4165 ATF_REQUIRE(WIFSTOPPED(status)); 4166 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 4167 4168 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 4169 4170 wpid = wait(&status); 4171 ATF_REQUIRE(wpid == child); 4172 ATF_REQUIRE(WIFSTOPPED(status)); 4173 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 4174 4175 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 4176 4177 /* 4178 * If process was created by pdfork, the return code have to 4179 * be collected through process descriptor. 4180 */ 4181 wpid = wait(&status); 4182 ATF_REQUIRE(wpid == -1); 4183 ATF_REQUIRE(errno == ECHILD); 4184 4185 ATF_REQUIRE(close(pd) != -1); 4186 } 4187 4188 /* 4189 * Ensure that traced processes created with pdfork(2) are not visible 4190 * after returning to parent - waitid(P_ALL). 4191 */ 4192 ATF_TC_WITHOUT_HEAD(ptrace__procdesc_reparent_wait_child); 4193 ATF_TC_BODY(ptrace__procdesc_reparent_wait_child, tc) 4194 { 4195 pid_t traced, debuger, wpid; 4196 int pd, status; 4197 4198 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) 4199 atf_tc_skip("https://bugs.freebsd.org/243605"); 4200 4201 traced = pdfork(&pd, 0); 4202 ATF_REQUIRE(traced >= 0); 4203 if (traced == 0) { 4204 raise(SIGSTOP); 4205 exit(0); 4206 } 4207 ATF_REQUIRE(pd >= 0); 4208 4209 debuger = fork(); 4210 ATF_REQUIRE(debuger >= 0); 4211 if (debuger == 0) { 4212 /* The traced process is reparented to debuger. */ 4213 ATF_REQUIRE(ptrace(PT_ATTACH, traced, 0, 0) == 0); 4214 wpid = waitpid(traced, &status, 0); 4215 ATF_REQUIRE(wpid == traced); 4216 ATF_REQUIRE(WIFSTOPPED(status)); 4217 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 4218 4219 /* Allow process to die. */ 4220 ATF_REQUIRE(ptrace(PT_CONTINUE, traced, (caddr_t)1, 0) == 0); 4221 wpid = waitpid(traced, &status, 0); 4222 ATF_REQUIRE(wpid == traced); 4223 ATF_REQUIRE(WIFEXITED(status)); 4224 ATF_REQUIRE(WEXITSTATUS(status) == 0); 4225 4226 /* Reparent back to the orginal process. */ 4227 ATF_REQUIRE(close(pd) == 0); 4228 exit(0); 4229 } 4230 4231 wpid = waitpid(debuger, &status, 0); 4232 ATF_REQUIRE(wpid == debuger); 4233 ATF_REQUIRE(WEXITSTATUS(status) == 0); 4234 4235 /* 4236 * We have a child but it has a process descriptori 4237 * so we should not be able to collect it process. 4238 */ 4239 wpid = wait(&status); 4240 ATF_REQUIRE(wpid == -1); 4241 ATF_REQUIRE(errno == ECHILD); 4242 4243 ATF_REQUIRE(close(pd) == 0); 4244 } 4245 4246 ATF_TP_ADD_TCS(tp) 4247 { 4248 4249 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_trace_me); 4250 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_attach); 4251 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_child_debugger); 4252 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_unrelated_debugger); 4253 ATF_TP_ADD_TC(tp, ptrace__parent_exits_before_child); 4254 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached); 4255 ATF_TP_ADD_TC(tp, ptrace__follow_fork_child_detached); 4256 ATF_TP_ADD_TC(tp, ptrace__follow_fork_parent_detached); 4257 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached_unrelated_debugger); 4258 ATF_TP_ADD_TC(tp, 4259 ptrace__follow_fork_child_detached_unrelated_debugger); 4260 ATF_TP_ADD_TC(tp, 4261 ptrace__follow_fork_parent_detached_unrelated_debugger); 4262 ATF_TP_ADD_TC(tp, ptrace__getppid); 4263 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_fork); 4264 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_vfork); 4265 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_thread); 4266 ATF_TP_ADD_TC(tp, ptrace__lwp_events); 4267 ATF_TP_ADD_TC(tp, ptrace__lwp_events_exec); 4268 ATF_TP_ADD_TC(tp, ptrace__siginfo); 4269 ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_disable); 4270 ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_enable); 4271 ATF_TP_ADD_TC(tp, ptrace__event_mask); 4272 ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork); 4273 ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork_follow); 4274 #ifdef HAVE_BREAKPOINT 4275 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_breakpoint); 4276 #endif 4277 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_system_call); 4278 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_threads); 4279 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_signal); 4280 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_stop); 4281 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_with_signal_full_sigqueue); 4282 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_system_call_entry); 4283 ATF_TP_ADD_TC(tp, 4284 ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit); 4285 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_full_sigqueue); 4286 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue); 4287 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_change_sig); 4288 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_sigtrap_system_call_entry); 4289 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_mix); 4290 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_kqueue); 4291 ATF_TP_ADD_TC(tp, ptrace__killed_with_sigmask); 4292 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_sigmask); 4293 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_thread_sigmask); 4294 ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop1); 4295 ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop2); 4296 ATF_TP_ADD_TC(tp, ptrace__event_mask_sigkill_discard); 4297 ATF_TP_ADD_TC(tp, ptrace__PT_ATTACH_with_SBDRY_thread); 4298 ATF_TP_ADD_TC(tp, ptrace__PT_STEP_with_signal); 4299 #ifdef HAVE_BREAKPOINT 4300 ATF_TP_ADD_TC(tp, ptrace__breakpoint_siginfo); 4301 #endif 4302 ATF_TP_ADD_TC(tp, ptrace__step_siginfo); 4303 #if defined(HAVE_BREAKPOINT) && defined(SKIP_BREAK) 4304 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_different_thread); 4305 #endif 4306 ATF_TP_ADD_TC(tp, ptrace__PT_LWPINFO_stale_siginfo); 4307 ATF_TP_ADD_TC(tp, ptrace__syscall_args); 4308 ATF_TP_ADD_TC(tp, ptrace__proc_reparent); 4309 ATF_TP_ADD_TC(tp, ptrace__procdesc_wait_child); 4310 ATF_TP_ADD_TC(tp, ptrace__procdesc_reparent_wait_child); 4311 4312 return (atf_no_error()); 4313 } 4314