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/ptrace.h> 32 #include <sys/sysctl.h> 33 #include <sys/user.h> 34 #include <sys/wait.h> 35 #include <errno.h> 36 #include <signal.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <unistd.h> 40 #include <atf-c.h> 41 42 /* 43 * A variant of ATF_REQUIRE that is suitable for use in child 44 * processes. This only works if the parent process is tripped up by 45 * the early exit and fails some requirement itself. 46 */ 47 #define CHILD_REQUIRE(exp) do { \ 48 if (!(exp)) \ 49 child_fail_require(__FILE__, __LINE__, \ 50 #exp " not met"); \ 51 } while (0) 52 53 static __dead2 void 54 child_fail_require(const char *file, int line, const char *str) 55 { 56 char buf[128]; 57 58 snprintf(buf, sizeof(buf), "%s:%d: %s\n", file, line, str); 59 write(2, buf, strlen(buf)); 60 _exit(32); 61 } 62 63 static void 64 trace_me(void) 65 { 66 67 /* Attach the parent process as a tracer of this process. */ 68 CHILD_REQUIRE(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 69 70 /* Trigger a stop. */ 71 raise(SIGSTOP); 72 } 73 74 static void 75 attach_child(pid_t pid) 76 { 77 pid_t wpid; 78 int status; 79 80 ATF_REQUIRE(ptrace(PT_ATTACH, pid, NULL, 0) == 0); 81 82 wpid = waitpid(pid, &status, 0); 83 ATF_REQUIRE(wpid == pid); 84 ATF_REQUIRE(WIFSTOPPED(status)); 85 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 86 } 87 88 static void 89 wait_for_zombie(pid_t pid) 90 { 91 92 /* 93 * Wait for a process to exit. This is kind of gross, but 94 * there is not a better way. 95 */ 96 for (;;) { 97 struct kinfo_proc kp; 98 size_t len; 99 int mib[4]; 100 101 mib[0] = CTL_KERN; 102 mib[1] = KERN_PROC; 103 mib[2] = KERN_PROC_PID; 104 mib[3] = pid; 105 len = sizeof(kp); 106 if (sysctl(mib, nitems(mib), &kp, &len, NULL, 0) == -1) { 107 /* The KERN_PROC_PID sysctl fails for zombies. */ 108 ATF_REQUIRE(errno == ESRCH); 109 break; 110 } 111 usleep(5000); 112 } 113 } 114 115 /* 116 * Verify that a parent debugger process "sees" the exit of a debugged 117 * process exactly once when attached via PT_TRACE_ME. 118 */ 119 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_trace_me); 120 ATF_TC_BODY(ptrace__parent_wait_after_trace_me, tc) 121 { 122 pid_t child, wpid; 123 int status; 124 125 ATF_REQUIRE((child = fork()) != -1); 126 if (child == 0) { 127 /* Child process. */ 128 trace_me(); 129 130 exit(1); 131 } 132 133 /* Parent process. */ 134 135 /* The first wait() should report the stop from SIGSTOP. */ 136 wpid = waitpid(child, &status, 0); 137 ATF_REQUIRE(wpid == child); 138 ATF_REQUIRE(WIFSTOPPED(status)); 139 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 140 141 /* Continue the child ignoring the SIGSTOP. */ 142 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 143 144 /* The second wait() should report the exit status. */ 145 wpid = waitpid(child, &status, 0); 146 ATF_REQUIRE(wpid == child); 147 ATF_REQUIRE(WIFEXITED(status)); 148 ATF_REQUIRE(WEXITSTATUS(status) == 1); 149 150 /* The child should no longer exist. */ 151 wpid = waitpid(child, &status, 0); 152 ATF_REQUIRE(wpid == -1); 153 ATF_REQUIRE(errno == ECHILD); 154 } 155 156 /* 157 * Verify that a parent debugger process "sees" the exit of a debugged 158 * process exactly once when attached via PT_ATTACH. 159 */ 160 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_attach); 161 ATF_TC_BODY(ptrace__parent_wait_after_attach, tc) 162 { 163 pid_t child, wpid; 164 int cpipe[2], status; 165 char c; 166 167 ATF_REQUIRE(pipe(cpipe) == 0); 168 ATF_REQUIRE((child = fork()) != -1); 169 if (child == 0) { 170 /* Child process. */ 171 close(cpipe[0]); 172 173 /* Wait for the parent to attach. */ 174 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == 0); 175 176 exit(1); 177 } 178 close(cpipe[1]); 179 180 /* Parent process. */ 181 182 /* Attach to the child process. */ 183 attach_child(child); 184 185 /* Continue the child ignoring the SIGSTOP. */ 186 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 187 188 /* Signal the child to exit. */ 189 close(cpipe[0]); 190 191 /* The second wait() should report the exit status. */ 192 wpid = waitpid(child, &status, 0); 193 ATF_REQUIRE(wpid == child); 194 ATF_REQUIRE(WIFEXITED(status)); 195 ATF_REQUIRE(WEXITSTATUS(status) == 1); 196 197 /* The child should no longer exist. */ 198 wpid = waitpid(child, &status, 0); 199 ATF_REQUIRE(wpid == -1); 200 ATF_REQUIRE(errno == ECHILD); 201 } 202 203 /* 204 * Verify that a parent process "sees" the exit of a debugged process only 205 * after the debugger has seen it. 206 */ 207 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_child_debugger); 208 ATF_TC_BODY(ptrace__parent_sees_exit_after_child_debugger, tc) 209 { 210 pid_t child, debugger, wpid; 211 int cpipe[2], dpipe[2], status; 212 char c; 213 214 ATF_REQUIRE(pipe(cpipe) == 0); 215 ATF_REQUIRE((child = fork()) != -1); 216 217 if (child == 0) { 218 /* Child process. */ 219 close(cpipe[0]); 220 221 /* Wait for parent to be ready. */ 222 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 223 224 exit(1); 225 } 226 close(cpipe[1]); 227 228 ATF_REQUIRE(pipe(dpipe) == 0); 229 ATF_REQUIRE((debugger = fork()) != -1); 230 231 if (debugger == 0) { 232 /* Debugger process. */ 233 close(dpipe[0]); 234 235 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 236 237 wpid = waitpid(child, &status, 0); 238 CHILD_REQUIRE(wpid == child); 239 CHILD_REQUIRE(WIFSTOPPED(status)); 240 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 241 242 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 243 244 /* Signal parent that debugger is attached. */ 245 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 246 247 /* Wait for parent's failed wait. */ 248 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == 0); 249 250 wpid = waitpid(child, &status, 0); 251 CHILD_REQUIRE(wpid == child); 252 CHILD_REQUIRE(WIFEXITED(status)); 253 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 254 255 exit(0); 256 } 257 close(dpipe[1]); 258 259 /* Parent process. */ 260 261 /* Wait for the debugger to attach to the child. */ 262 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 263 264 /* Release the child. */ 265 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 266 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 267 close(cpipe[0]); 268 269 wait_for_zombie(child); 270 271 /* 272 * This wait should return a pid of 0 to indicate no status to 273 * report. The parent should see the child as non-exited 274 * until the debugger sees the exit. 275 */ 276 wpid = waitpid(child, &status, WNOHANG); 277 ATF_REQUIRE(wpid == 0); 278 279 /* Signal the debugger to wait for the child. */ 280 close(dpipe[0]); 281 282 /* Wait for the debugger. */ 283 wpid = waitpid(debugger, &status, 0); 284 ATF_REQUIRE(wpid == debugger); 285 ATF_REQUIRE(WIFEXITED(status)); 286 ATF_REQUIRE(WEXITSTATUS(status) == 0); 287 288 /* The child process should now be ready. */ 289 wpid = waitpid(child, &status, WNOHANG); 290 ATF_REQUIRE(wpid == child); 291 ATF_REQUIRE(WIFEXITED(status)); 292 ATF_REQUIRE(WEXITSTATUS(status) == 1); 293 } 294 295 /* 296 * Verify that a parent process "sees" the exit of a debugged process 297 * only after a non-direct-child debugger has seen it. In particular, 298 * various wait() calls in the parent must avoid failing with ESRCH by 299 * checking the parent's orphan list for the debugee. 300 */ 301 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_unrelated_debugger); 302 ATF_TC_BODY(ptrace__parent_sees_exit_after_unrelated_debugger, tc) 303 { 304 pid_t child, debugger, fpid, wpid; 305 int cpipe[2], dpipe[2], status; 306 char c; 307 308 ATF_REQUIRE(pipe(cpipe) == 0); 309 ATF_REQUIRE((child = fork()) != -1); 310 311 if (child == 0) { 312 /* Child process. */ 313 close(cpipe[0]); 314 315 /* Wait for parent to be ready. */ 316 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 317 318 exit(1); 319 } 320 close(cpipe[1]); 321 322 ATF_REQUIRE(pipe(dpipe) == 0); 323 ATF_REQUIRE((debugger = fork()) != -1); 324 325 if (debugger == 0) { 326 /* Debugger parent. */ 327 328 /* 329 * Fork again and drop the debugger parent so that the 330 * debugger is not a child of the main parent. 331 */ 332 CHILD_REQUIRE((fpid = fork()) != -1); 333 if (fpid != 0) 334 exit(2); 335 336 /* Debugger process. */ 337 close(dpipe[0]); 338 339 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 340 341 wpid = waitpid(child, &status, 0); 342 CHILD_REQUIRE(wpid == child); 343 CHILD_REQUIRE(WIFSTOPPED(status)); 344 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 345 346 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 347 348 /* Signal parent that debugger is attached. */ 349 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 350 351 /* Wait for parent's failed wait. */ 352 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == sizeof(c)); 353 354 wpid = waitpid(child, &status, 0); 355 CHILD_REQUIRE(wpid == child); 356 CHILD_REQUIRE(WIFEXITED(status)); 357 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 358 359 exit(0); 360 } 361 close(dpipe[1]); 362 363 /* Parent process. */ 364 365 /* Wait for the debugger parent process to exit. */ 366 wpid = waitpid(debugger, &status, 0); 367 ATF_REQUIRE(wpid == debugger); 368 ATF_REQUIRE(WIFEXITED(status)); 369 ATF_REQUIRE(WEXITSTATUS(status) == 2); 370 371 /* A WNOHANG wait here should see the non-exited child. */ 372 wpid = waitpid(child, &status, WNOHANG); 373 ATF_REQUIRE(wpid == 0); 374 375 /* Wait for the debugger to attach to the child. */ 376 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 377 378 /* Release the child. */ 379 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 380 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 381 close(cpipe[0]); 382 383 wait_for_zombie(child); 384 385 /* 386 * This wait should return a pid of 0 to indicate no status to 387 * report. The parent should see the child as non-exited 388 * until the debugger sees the exit. 389 */ 390 wpid = waitpid(child, &status, WNOHANG); 391 ATF_REQUIRE(wpid == 0); 392 393 /* Signal the debugger to wait for the child. */ 394 ATF_REQUIRE(write(dpipe[0], &c, sizeof(c)) == sizeof(c)); 395 396 /* Wait for the debugger. */ 397 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == 0); 398 close(dpipe[0]); 399 400 /* The child process should now be ready. */ 401 wpid = waitpid(child, &status, WNOHANG); 402 ATF_REQUIRE(wpid == child); 403 ATF_REQUIRE(WIFEXITED(status)); 404 ATF_REQUIRE(WEXITSTATUS(status) == 1); 405 } 406 407 /* 408 * The parent process should always act the same regardless of how the 409 * debugger is attached to it. 410 */ 411 static __dead2 void 412 follow_fork_parent(void) 413 { 414 pid_t fpid, wpid; 415 int status; 416 417 CHILD_REQUIRE((fpid = fork()) != -1); 418 419 if (fpid == 0) 420 /* Child */ 421 exit(2); 422 423 wpid = waitpid(fpid, &status, 0); 424 CHILD_REQUIRE(wpid == fpid); 425 CHILD_REQUIRE(WIFEXITED(status)); 426 CHILD_REQUIRE(WEXITSTATUS(status) == 2); 427 428 exit(1); 429 } 430 431 /* 432 * Helper routine for follow fork tests. This waits for two stops 433 * that report both "sides" of a fork. It returns the pid of the new 434 * child process. 435 */ 436 static pid_t 437 handle_fork_events(pid_t parent) 438 { 439 struct ptrace_lwpinfo pl; 440 bool fork_reported[2]; 441 pid_t child, wpid; 442 int i, status; 443 444 fork_reported[0] = false; 445 fork_reported[1] = false; 446 child = -1; 447 448 /* 449 * Each process should report a fork event. The parent should 450 * report a PL_FLAG_FORKED event, and the child should report 451 * a PL_FLAG_CHILD event. 452 */ 453 for (i = 0; i < 2; i++) { 454 wpid = wait(&status); 455 ATF_REQUIRE(wpid > 0); 456 ATF_REQUIRE(WIFSTOPPED(status)); 457 458 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 459 sizeof(pl)) != -1); 460 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 461 0); 462 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 463 (PL_FLAG_FORKED | PL_FLAG_CHILD)); 464 if (pl.pl_flags & PL_FLAG_CHILD) { 465 ATF_REQUIRE(wpid != parent); 466 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 467 ATF_REQUIRE(!fork_reported[1]); 468 if (child == -1) 469 child = wpid; 470 else 471 ATF_REQUIRE(child == wpid); 472 fork_reported[1] = true; 473 } else { 474 ATF_REQUIRE(wpid == parent); 475 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 476 ATF_REQUIRE(!fork_reported[0]); 477 if (child == -1) 478 child = pl.pl_child_pid; 479 else 480 ATF_REQUIRE(child == pl.pl_child_pid); 481 fork_reported[0] = true; 482 } 483 } 484 485 return (child); 486 } 487 488 /* 489 * Verify that a new child process is stopped after a followed fork and 490 * that the traced parent sees the exit of the child after the debugger 491 * when both processes remain attached to the debugger. 492 */ 493 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached); 494 ATF_TC_BODY(ptrace__follow_fork_both_attached, tc) 495 { 496 pid_t children[0], fpid, wpid; 497 int status; 498 499 ATF_REQUIRE((fpid = fork()) != -1); 500 if (fpid == 0) { 501 trace_me(); 502 follow_fork_parent(); 503 } 504 505 /* Parent process. */ 506 children[0] = fpid; 507 508 /* The first wait() should report the stop from SIGSTOP. */ 509 wpid = waitpid(children[0], &status, 0); 510 ATF_REQUIRE(wpid == children[0]); 511 ATF_REQUIRE(WIFSTOPPED(status)); 512 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 513 514 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 515 516 /* Continue the child ignoring the SIGSTOP. */ 517 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 518 519 children[1] = handle_fork_events(children[0]); 520 ATF_REQUIRE(children[1] > 0); 521 522 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 523 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 524 525 /* 526 * The child can't exit until the grandchild reports status, so the 527 * grandchild should report its exit first to the debugger. 528 */ 529 wpid = wait(&status); 530 ATF_REQUIRE(wpid == children[1]); 531 ATF_REQUIRE(WIFEXITED(status)); 532 ATF_REQUIRE(WEXITSTATUS(status) == 2); 533 534 wpid = wait(&status); 535 ATF_REQUIRE(wpid == children[0]); 536 ATF_REQUIRE(WIFEXITED(status)); 537 ATF_REQUIRE(WEXITSTATUS(status) == 1); 538 539 wpid = wait(&status); 540 ATF_REQUIRE(wpid == -1); 541 ATF_REQUIRE(errno == ECHILD); 542 } 543 544 /* 545 * Verify that a new child process is stopped after a followed fork 546 * and that the traced parent sees the exit of the child when the new 547 * child process is detached after it reports its fork. 548 */ 549 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached); 550 ATF_TC_BODY(ptrace__follow_fork_child_detached, tc) 551 { 552 pid_t children[0], fpid, wpid; 553 int status; 554 555 ATF_REQUIRE((fpid = fork()) != -1); 556 if (fpid == 0) { 557 trace_me(); 558 follow_fork_parent(); 559 } 560 561 /* Parent process. */ 562 children[0] = fpid; 563 564 /* The first wait() should report the stop from SIGSTOP. */ 565 wpid = waitpid(children[0], &status, 0); 566 ATF_REQUIRE(wpid == children[0]); 567 ATF_REQUIRE(WIFSTOPPED(status)); 568 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 569 570 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 571 572 /* Continue the child ignoring the SIGSTOP. */ 573 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 574 575 children[1] = handle_fork_events(children[0]); 576 ATF_REQUIRE(children[1] > 0); 577 578 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 579 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 580 581 /* 582 * Should not see any status from the grandchild now, only the 583 * child. 584 */ 585 wpid = wait(&status); 586 ATF_REQUIRE(wpid == children[0]); 587 ATF_REQUIRE(WIFEXITED(status)); 588 ATF_REQUIRE(WEXITSTATUS(status) == 1); 589 590 wpid = wait(&status); 591 ATF_REQUIRE(wpid == -1); 592 ATF_REQUIRE(errno == ECHILD); 593 } 594 595 /* 596 * Verify that a new child process is stopped after a followed fork 597 * and that the traced parent sees the exit of the child when the 598 * traced parent is detached after the fork. 599 */ 600 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached); 601 ATF_TC_BODY(ptrace__follow_fork_parent_detached, tc) 602 { 603 pid_t children[0], fpid, wpid; 604 int status; 605 606 ATF_REQUIRE((fpid = fork()) != -1); 607 if (fpid == 0) { 608 trace_me(); 609 follow_fork_parent(); 610 } 611 612 /* Parent process. */ 613 children[0] = fpid; 614 615 /* The first wait() should report the stop from SIGSTOP. */ 616 wpid = waitpid(children[0], &status, 0); 617 ATF_REQUIRE(wpid == children[0]); 618 ATF_REQUIRE(WIFSTOPPED(status)); 619 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 620 621 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 622 623 /* Continue the child ignoring the SIGSTOP. */ 624 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 625 626 children[1] = handle_fork_events(children[0]); 627 ATF_REQUIRE(children[1] > 0); 628 629 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 630 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 631 632 /* 633 * The child can't exit until the grandchild reports status, so the 634 * grandchild should report its exit first to the debugger. 635 * 636 * Even though the child process is detached, it is still a 637 * child of the debugger, so it will still report it's exit 638 * after the grandchild. 639 */ 640 wpid = wait(&status); 641 ATF_REQUIRE(wpid == children[1]); 642 ATF_REQUIRE(WIFEXITED(status)); 643 ATF_REQUIRE(WEXITSTATUS(status) == 2); 644 645 wpid = wait(&status); 646 ATF_REQUIRE(wpid == children[0]); 647 ATF_REQUIRE(WIFEXITED(status)); 648 ATF_REQUIRE(WEXITSTATUS(status) == 1); 649 650 wpid = wait(&status); 651 ATF_REQUIRE(wpid == -1); 652 ATF_REQUIRE(errno == ECHILD); 653 } 654 655 static void 656 attach_fork_parent(int cpipe[2]) 657 { 658 pid_t fpid; 659 660 close(cpipe[0]); 661 662 /* Double-fork to disassociate from the debugger. */ 663 CHILD_REQUIRE((fpid = fork()) != -1); 664 if (fpid != 0) 665 exit(3); 666 667 /* Send the pid of the disassociated child to the debugger. */ 668 fpid = getpid(); 669 CHILD_REQUIRE(write(cpipe[1], &fpid, sizeof(fpid)) == sizeof(fpid)); 670 671 /* Wait for the debugger to attach. */ 672 CHILD_REQUIRE(read(cpipe[1], &fpid, sizeof(fpid)) == 0); 673 } 674 675 /* 676 * Verify that a new child process is stopped after a followed fork and 677 * that the traced parent sees the exit of the child after the debugger 678 * when both processes remain attached to the debugger. In this test 679 * the parent that forks is not a direct child of the debugger. 680 */ 681 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached_unrelated_debugger); 682 ATF_TC_BODY(ptrace__follow_fork_both_attached_unrelated_debugger, tc) 683 { 684 pid_t children[0], fpid, wpid; 685 int cpipe[2], status; 686 687 ATF_REQUIRE(pipe(cpipe) == 0); 688 ATF_REQUIRE((fpid = fork()) != -1); 689 if (fpid == 0) { 690 attach_fork_parent(cpipe); 691 follow_fork_parent(); 692 } 693 694 /* Parent process. */ 695 close(cpipe[1]); 696 697 /* Wait for the direct child to exit. */ 698 wpid = waitpid(fpid, &status, 0); 699 ATF_REQUIRE(wpid == fpid); 700 ATF_REQUIRE(WIFEXITED(status)); 701 ATF_REQUIRE(WEXITSTATUS(status) == 3); 702 703 /* Read the pid of the fork parent. */ 704 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 705 sizeof(children[0])); 706 707 /* Attach to the fork parent. */ 708 attach_child(children[0]); 709 710 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 711 712 /* Continue the fork parent ignoring the SIGSTOP. */ 713 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 714 715 /* Signal the fork parent to continue. */ 716 close(cpipe[0]); 717 718 children[1] = handle_fork_events(children[0]); 719 ATF_REQUIRE(children[1] > 0); 720 721 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 722 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 723 724 /* 725 * The fork parent can't exit until the child reports status, 726 * so the child should report its exit first to the debugger. 727 */ 728 wpid = wait(&status); 729 ATF_REQUIRE(wpid == children[1]); 730 ATF_REQUIRE(WIFEXITED(status)); 731 ATF_REQUIRE(WEXITSTATUS(status) == 2); 732 733 wpid = wait(&status); 734 ATF_REQUIRE(wpid == children[0]); 735 ATF_REQUIRE(WIFEXITED(status)); 736 ATF_REQUIRE(WEXITSTATUS(status) == 1); 737 738 wpid = wait(&status); 739 ATF_REQUIRE(wpid == -1); 740 ATF_REQUIRE(errno == ECHILD); 741 } 742 743 /* 744 * Verify that a new child process is stopped after a followed fork 745 * and that the traced parent sees the exit of the child when the new 746 * child process is detached after it reports its fork. In this test 747 * the parent that forks is not a direct child of the debugger. 748 */ 749 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached_unrelated_debugger); 750 ATF_TC_BODY(ptrace__follow_fork_child_detached_unrelated_debugger, tc) 751 { 752 pid_t children[0], fpid, wpid; 753 int cpipe[2], status; 754 755 ATF_REQUIRE(pipe(cpipe) == 0); 756 ATF_REQUIRE((fpid = fork()) != -1); 757 if (fpid == 0) { 758 attach_fork_parent(cpipe); 759 follow_fork_parent(); 760 } 761 762 /* Parent process. */ 763 close(cpipe[1]); 764 765 /* Wait for the direct child to exit. */ 766 wpid = waitpid(fpid, &status, 0); 767 ATF_REQUIRE(wpid == fpid); 768 ATF_REQUIRE(WIFEXITED(status)); 769 ATF_REQUIRE(WEXITSTATUS(status) == 3); 770 771 /* Read the pid of the fork parent. */ 772 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 773 sizeof(children[0])); 774 775 /* Attach to the fork parent. */ 776 attach_child(children[0]); 777 778 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 779 780 /* Continue the fork parent ignoring the SIGSTOP. */ 781 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 782 783 /* Signal the fork parent to continue. */ 784 close(cpipe[0]); 785 786 children[1] = handle_fork_events(children[0]); 787 ATF_REQUIRE(children[1] > 0); 788 789 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 790 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 791 792 /* 793 * Should not see any status from the child now, only the fork 794 * parent. 795 */ 796 wpid = wait(&status); 797 ATF_REQUIRE(wpid == children[0]); 798 ATF_REQUIRE(WIFEXITED(status)); 799 ATF_REQUIRE(WEXITSTATUS(status) == 1); 800 801 wpid = wait(&status); 802 ATF_REQUIRE(wpid == -1); 803 ATF_REQUIRE(errno == ECHILD); 804 } 805 806 /* 807 * Verify that a new child process is stopped after a followed fork 808 * and that the traced parent sees the exit of the child when the 809 * traced parent is detached after the fork. In this test the parent 810 * that forks is not a direct child of the debugger. 811 */ 812 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached_unrelated_debugger); 813 ATF_TC_BODY(ptrace__follow_fork_parent_detached_unrelated_debugger, tc) 814 { 815 pid_t children[0], fpid, wpid; 816 int cpipe[2], status; 817 818 ATF_REQUIRE(pipe(cpipe) == 0); 819 ATF_REQUIRE((fpid = fork()) != -1); 820 if (fpid == 0) { 821 attach_fork_parent(cpipe); 822 follow_fork_parent(); 823 } 824 825 /* Parent process. */ 826 close(cpipe[1]); 827 828 /* Wait for the direct child to exit. */ 829 wpid = waitpid(fpid, &status, 0); 830 ATF_REQUIRE(wpid == fpid); 831 ATF_REQUIRE(WIFEXITED(status)); 832 ATF_REQUIRE(WEXITSTATUS(status) == 3); 833 834 /* Read the pid of the fork parent. */ 835 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 836 sizeof(children[0])); 837 838 /* Attach to the fork parent. */ 839 attach_child(children[0]); 840 841 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 842 843 /* Continue the fork parent ignoring the SIGSTOP. */ 844 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 845 846 /* Signal the fork parent to continue. */ 847 close(cpipe[0]); 848 849 children[1] = handle_fork_events(children[0]); 850 ATF_REQUIRE(children[1] > 0); 851 852 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 853 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 854 855 /* 856 * Should not see any status from the fork parent now, only 857 * the child. 858 */ 859 wpid = wait(&status); 860 ATF_REQUIRE(wpid == children[1]); 861 ATF_REQUIRE(WIFEXITED(status)); 862 ATF_REQUIRE(WEXITSTATUS(status) == 2); 863 864 wpid = wait(&status); 865 ATF_REQUIRE(wpid == -1); 866 ATF_REQUIRE(errno == ECHILD); 867 } 868 869 ATF_TP_ADD_TCS(tp) 870 { 871 872 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_trace_me); 873 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_attach); 874 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_child_debugger); 875 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_unrelated_debugger); 876 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached); 877 ATF_TP_ADD_TC(tp, ptrace__follow_fork_child_detached); 878 ATF_TP_ADD_TC(tp, ptrace__follow_fork_parent_detached); 879 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached_unrelated_debugger); 880 ATF_TP_ADD_TC(tp, 881 ptrace__follow_fork_child_detached_unrelated_debugger); 882 ATF_TP_ADD_TC(tp, 883 ptrace__follow_fork_parent_detached_unrelated_debugger); 884 885 return (atf_no_error()); 886 } 887