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