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