ptrace_test.c revision 315963
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: stable/10/tests/sys/kern/ptrace_test.c 315963 2017-03-25 20:14:08Z badger $"); 29 30#include <sys/param.h> 31#include <sys/cpuset.h> 32#include <sys/event.h> 33#include <sys/time.h> 34#include <sys/procctl.h> 35#include <sys/ptrace.h> 36#include <sys/queue.h> 37#include <sys/runq.h> 38#include <sys/syscall.h> 39#include <sys/sysctl.h> 40#include <sys/user.h> 41#include <sys/wait.h> 42#include <errno.h> 43#include <machine/cpufunc.h> 44#include <pthread.h> 45#include <sched.h> 46#include <semaphore.h> 47#include <signal.h> 48#include <stdio.h> 49#include <stdlib.h> 50#include <unistd.h> 51#include <atf-c.h> 52 53/* 54 * A variant of ATF_REQUIRE that is suitable for use in child 55 * processes. This only works if the parent process is tripped up by 56 * the early exit and fails some requirement itself. 57 */ 58#define CHILD_REQUIRE(exp) do { \ 59 if (!(exp)) \ 60 child_fail_require(__FILE__, __LINE__, \ 61 #exp " not met"); \ 62 } while (0) 63 64static __dead2 void 65child_fail_require(const char *file, int line, const char *str) 66{ 67 char buf[128]; 68 69 snprintf(buf, sizeof(buf), "%s:%d: %s\n", file, line, str); 70 write(2, buf, strlen(buf)); 71 _exit(32); 72} 73 74static void 75trace_me(void) 76{ 77 78 /* Attach the parent process as a tracer of this process. */ 79 CHILD_REQUIRE(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 80 81 /* Trigger a stop. */ 82 raise(SIGSTOP); 83} 84 85static void 86attach_child(pid_t pid) 87{ 88 pid_t wpid; 89 int status; 90 91 ATF_REQUIRE(ptrace(PT_ATTACH, pid, NULL, 0) == 0); 92 93 wpid = waitpid(pid, &status, 0); 94 ATF_REQUIRE(wpid == pid); 95 ATF_REQUIRE(WIFSTOPPED(status)); 96 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 97} 98 99static void 100wait_for_zombie(pid_t pid) 101{ 102 103 /* 104 * Wait for a process to exit. This is kind of gross, but 105 * there is not a better way. 106 */ 107 for (;;) { 108 struct kinfo_proc kp; 109 size_t len; 110 int mib[4]; 111 112 mib[0] = CTL_KERN; 113 mib[1] = KERN_PROC; 114 mib[2] = KERN_PROC_PID; 115 mib[3] = pid; 116 len = sizeof(kp); 117 if (sysctl(mib, nitems(mib), &kp, &len, NULL, 0) == -1) { 118 /* The KERN_PROC_PID sysctl fails for zombies. */ 119 ATF_REQUIRE(errno == ESRCH); 120 break; 121 } 122 usleep(5000); 123 } 124} 125 126/* 127 * Verify that a parent debugger process "sees" the exit of a debugged 128 * process exactly once when attached via PT_TRACE_ME. 129 */ 130ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_trace_me); 131ATF_TC_BODY(ptrace__parent_wait_after_trace_me, tc) 132{ 133 pid_t child, wpid; 134 int status; 135 136 ATF_REQUIRE((child = fork()) != -1); 137 if (child == 0) { 138 /* Child process. */ 139 trace_me(); 140 141 exit(1); 142 } 143 144 /* Parent process. */ 145 146 /* The first wait() should report the stop from SIGSTOP. */ 147 wpid = waitpid(child, &status, 0); 148 ATF_REQUIRE(wpid == child); 149 ATF_REQUIRE(WIFSTOPPED(status)); 150 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 151 152 /* Continue the child ignoring the SIGSTOP. */ 153 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 154 155 /* The second wait() should report the exit status. */ 156 wpid = waitpid(child, &status, 0); 157 ATF_REQUIRE(wpid == child); 158 ATF_REQUIRE(WIFEXITED(status)); 159 ATF_REQUIRE(WEXITSTATUS(status) == 1); 160 161 /* The child should no longer exist. */ 162 wpid = waitpid(child, &status, 0); 163 ATF_REQUIRE(wpid == -1); 164 ATF_REQUIRE(errno == ECHILD); 165} 166 167/* 168 * Verify that a parent debugger process "sees" the exit of a debugged 169 * process exactly once when attached via PT_ATTACH. 170 */ 171ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_attach); 172ATF_TC_BODY(ptrace__parent_wait_after_attach, tc) 173{ 174 pid_t child, wpid; 175 int cpipe[2], status; 176 char c; 177 178 ATF_REQUIRE(pipe(cpipe) == 0); 179 ATF_REQUIRE((child = fork()) != -1); 180 if (child == 0) { 181 /* Child process. */ 182 close(cpipe[0]); 183 184 /* Wait for the parent to attach. */ 185 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == 0); 186 187 exit(1); 188 } 189 close(cpipe[1]); 190 191 /* Parent process. */ 192 193 /* Attach to the child process. */ 194 attach_child(child); 195 196 /* Continue the child ignoring the SIGSTOP. */ 197 ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 198 199 /* Signal the child to exit. */ 200 close(cpipe[0]); 201 202 /* The second wait() should report the exit status. */ 203 wpid = waitpid(child, &status, 0); 204 ATF_REQUIRE(wpid == child); 205 ATF_REQUIRE(WIFEXITED(status)); 206 ATF_REQUIRE(WEXITSTATUS(status) == 1); 207 208 /* The child should no longer exist. */ 209 wpid = waitpid(child, &status, 0); 210 ATF_REQUIRE(wpid == -1); 211 ATF_REQUIRE(errno == ECHILD); 212} 213 214/* 215 * Verify that a parent process "sees" the exit of a debugged process only 216 * after the debugger has seen it. 217 */ 218ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_child_debugger); 219ATF_TC_BODY(ptrace__parent_sees_exit_after_child_debugger, tc) 220{ 221 pid_t child, debugger, wpid; 222 int cpipe[2], dpipe[2], status; 223 char c; 224 225 ATF_REQUIRE(pipe(cpipe) == 0); 226 ATF_REQUIRE((child = fork()) != -1); 227 228 if (child == 0) { 229 /* Child process. */ 230 close(cpipe[0]); 231 232 /* Wait for parent to be ready. */ 233 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 234 235 exit(1); 236 } 237 close(cpipe[1]); 238 239 ATF_REQUIRE(pipe(dpipe) == 0); 240 ATF_REQUIRE((debugger = fork()) != -1); 241 242 if (debugger == 0) { 243 /* Debugger process. */ 244 close(dpipe[0]); 245 246 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 247 248 wpid = waitpid(child, &status, 0); 249 CHILD_REQUIRE(wpid == child); 250 CHILD_REQUIRE(WIFSTOPPED(status)); 251 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 252 253 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 254 255 /* Signal parent that debugger is attached. */ 256 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 257 258 /* Wait for parent's failed wait. */ 259 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == 0); 260 261 wpid = waitpid(child, &status, 0); 262 CHILD_REQUIRE(wpid == child); 263 CHILD_REQUIRE(WIFEXITED(status)); 264 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 265 266 exit(0); 267 } 268 close(dpipe[1]); 269 270 /* Parent process. */ 271 272 /* Wait for the debugger to attach to the child. */ 273 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 274 275 /* Release the child. */ 276 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 277 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 278 close(cpipe[0]); 279 280 wait_for_zombie(child); 281 282 /* 283 * This wait should return a pid of 0 to indicate no status to 284 * report. The parent should see the child as non-exited 285 * until the debugger sees the exit. 286 */ 287 wpid = waitpid(child, &status, WNOHANG); 288 ATF_REQUIRE(wpid == 0); 289 290 /* Signal the debugger to wait for the child. */ 291 close(dpipe[0]); 292 293 /* Wait for the debugger. */ 294 wpid = waitpid(debugger, &status, 0); 295 ATF_REQUIRE(wpid == debugger); 296 ATF_REQUIRE(WIFEXITED(status)); 297 ATF_REQUIRE(WEXITSTATUS(status) == 0); 298 299 /* The child process should now be ready. */ 300 wpid = waitpid(child, &status, WNOHANG); 301 ATF_REQUIRE(wpid == child); 302 ATF_REQUIRE(WIFEXITED(status)); 303 ATF_REQUIRE(WEXITSTATUS(status) == 1); 304} 305 306/* 307 * Verify that a parent process "sees" the exit of a debugged process 308 * only after a non-direct-child debugger has seen it. In particular, 309 * various wait() calls in the parent must avoid failing with ESRCH by 310 * checking the parent's orphan list for the debugee. 311 */ 312ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_unrelated_debugger); 313ATF_TC_BODY(ptrace__parent_sees_exit_after_unrelated_debugger, tc) 314{ 315 pid_t child, debugger, fpid, wpid; 316 int cpipe[2], dpipe[2], status; 317 char c; 318 319 ATF_REQUIRE(pipe(cpipe) == 0); 320 ATF_REQUIRE((child = fork()) != -1); 321 322 if (child == 0) { 323 /* Child process. */ 324 close(cpipe[0]); 325 326 /* Wait for parent to be ready. */ 327 CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c)); 328 329 exit(1); 330 } 331 close(cpipe[1]); 332 333 ATF_REQUIRE(pipe(dpipe) == 0); 334 ATF_REQUIRE((debugger = fork()) != -1); 335 336 if (debugger == 0) { 337 /* Debugger parent. */ 338 339 /* 340 * Fork again and drop the debugger parent so that the 341 * debugger is not a child of the main parent. 342 */ 343 CHILD_REQUIRE((fpid = fork()) != -1); 344 if (fpid != 0) 345 exit(2); 346 347 /* Debugger process. */ 348 close(dpipe[0]); 349 350 CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1); 351 352 wpid = waitpid(child, &status, 0); 353 CHILD_REQUIRE(wpid == child); 354 CHILD_REQUIRE(WIFSTOPPED(status)); 355 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 356 357 CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1); 358 359 /* Signal parent that debugger is attached. */ 360 CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c)); 361 362 /* Wait for parent's failed wait. */ 363 CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == sizeof(c)); 364 365 wpid = waitpid(child, &status, 0); 366 CHILD_REQUIRE(wpid == child); 367 CHILD_REQUIRE(WIFEXITED(status)); 368 CHILD_REQUIRE(WEXITSTATUS(status) == 1); 369 370 exit(0); 371 } 372 close(dpipe[1]); 373 374 /* Parent process. */ 375 376 /* Wait for the debugger parent process to exit. */ 377 wpid = waitpid(debugger, &status, 0); 378 ATF_REQUIRE(wpid == debugger); 379 ATF_REQUIRE(WIFEXITED(status)); 380 ATF_REQUIRE(WEXITSTATUS(status) == 2); 381 382 /* A WNOHANG wait here should see the non-exited child. */ 383 wpid = waitpid(child, &status, WNOHANG); 384 ATF_REQUIRE(wpid == 0); 385 386 /* Wait for the debugger to attach to the child. */ 387 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c)); 388 389 /* Release the child. */ 390 ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c)); 391 ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0); 392 close(cpipe[0]); 393 394 wait_for_zombie(child); 395 396 /* 397 * This wait should return a pid of 0 to indicate no status to 398 * report. The parent should see the child as non-exited 399 * until the debugger sees the exit. 400 */ 401 wpid = waitpid(child, &status, WNOHANG); 402 ATF_REQUIRE(wpid == 0); 403 404 /* Signal the debugger to wait for the child. */ 405 ATF_REQUIRE(write(dpipe[0], &c, sizeof(c)) == sizeof(c)); 406 407 /* Wait for the debugger. */ 408 ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == 0); 409 close(dpipe[0]); 410 411 /* The child process should now be ready. */ 412 wpid = waitpid(child, &status, WNOHANG); 413 ATF_REQUIRE(wpid == child); 414 ATF_REQUIRE(WIFEXITED(status)); 415 ATF_REQUIRE(WEXITSTATUS(status) == 1); 416} 417 418/* 419 * The parent process should always act the same regardless of how the 420 * debugger is attached to it. 421 */ 422static __dead2 void 423follow_fork_parent(bool use_vfork) 424{ 425 pid_t fpid, wpid; 426 int status; 427 428 if (use_vfork) 429 CHILD_REQUIRE((fpid = vfork()) != -1); 430 else 431 CHILD_REQUIRE((fpid = fork()) != -1); 432 433 if (fpid == 0) 434 /* Child */ 435 exit(2); 436 437 wpid = waitpid(fpid, &status, 0); 438 CHILD_REQUIRE(wpid == fpid); 439 CHILD_REQUIRE(WIFEXITED(status)); 440 CHILD_REQUIRE(WEXITSTATUS(status) == 2); 441 442 exit(1); 443} 444 445/* 446 * Helper routine for follow fork tests. This waits for two stops 447 * that report both "sides" of a fork. It returns the pid of the new 448 * child process. 449 */ 450static pid_t 451handle_fork_events(pid_t parent, struct ptrace_lwpinfo *ppl) 452{ 453 struct ptrace_lwpinfo pl; 454 bool fork_reported[2]; 455 pid_t child, wpid; 456 int i, status; 457 458 fork_reported[0] = false; 459 fork_reported[1] = false; 460 child = -1; 461 462 /* 463 * Each process should report a fork event. The parent should 464 * report a PL_FLAG_FORKED event, and the child should report 465 * a PL_FLAG_CHILD event. 466 */ 467 for (i = 0; i < 2; i++) { 468 wpid = wait(&status); 469 ATF_REQUIRE(wpid > 0); 470 ATF_REQUIRE(WIFSTOPPED(status)); 471 472 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 473 sizeof(pl)) != -1); 474 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 475 0); 476 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) != 477 (PL_FLAG_FORKED | PL_FLAG_CHILD)); 478 if (pl.pl_flags & PL_FLAG_CHILD) { 479 ATF_REQUIRE(wpid != parent); 480 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 481 ATF_REQUIRE(!fork_reported[1]); 482 if (child == -1) 483 child = wpid; 484 else 485 ATF_REQUIRE(child == wpid); 486 if (ppl != NULL) 487 ppl[1] = pl; 488 fork_reported[1] = true; 489 } else { 490 ATF_REQUIRE(wpid == parent); 491 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 492 ATF_REQUIRE(!fork_reported[0]); 493 if (child == -1) 494 child = pl.pl_child_pid; 495 else 496 ATF_REQUIRE(child == pl.pl_child_pid); 497 if (ppl != NULL) 498 ppl[0] = pl; 499 fork_reported[0] = true; 500 } 501 } 502 503 return (child); 504} 505 506/* 507 * Verify that a new child process is stopped after a followed fork and 508 * that the traced parent sees the exit of the child after the debugger 509 * when both processes remain attached to the debugger. 510 */ 511ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached); 512ATF_TC_BODY(ptrace__follow_fork_both_attached, tc) 513{ 514 pid_t children[0], fpid, wpid; 515 int status; 516 517 ATF_REQUIRE((fpid = fork()) != -1); 518 if (fpid == 0) { 519 trace_me(); 520 follow_fork_parent(false); 521 } 522 523 /* Parent process. */ 524 children[0] = fpid; 525 526 /* The first wait() should report the stop from SIGSTOP. */ 527 wpid = waitpid(children[0], &status, 0); 528 ATF_REQUIRE(wpid == children[0]); 529 ATF_REQUIRE(WIFSTOPPED(status)); 530 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 531 532 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 533 534 /* Continue the child ignoring the SIGSTOP. */ 535 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 536 537 children[1] = handle_fork_events(children[0], NULL); 538 ATF_REQUIRE(children[1] > 0); 539 540 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 541 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 542 543 /* 544 * The child can't exit until the grandchild reports status, so the 545 * grandchild should report its exit first to the debugger. 546 */ 547 wpid = wait(&status); 548 ATF_REQUIRE(wpid == children[1]); 549 ATF_REQUIRE(WIFEXITED(status)); 550 ATF_REQUIRE(WEXITSTATUS(status) == 2); 551 552 wpid = wait(&status); 553 ATF_REQUIRE(wpid == children[0]); 554 ATF_REQUIRE(WIFEXITED(status)); 555 ATF_REQUIRE(WEXITSTATUS(status) == 1); 556 557 wpid = wait(&status); 558 ATF_REQUIRE(wpid == -1); 559 ATF_REQUIRE(errno == ECHILD); 560} 561 562/* 563 * Verify that a new child process is stopped after a followed fork 564 * and that the traced parent sees the exit of the child when the new 565 * child process is detached after it reports its fork. 566 */ 567ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached); 568ATF_TC_BODY(ptrace__follow_fork_child_detached, tc) 569{ 570 pid_t children[0], fpid, wpid; 571 int status; 572 573 ATF_REQUIRE((fpid = fork()) != -1); 574 if (fpid == 0) { 575 trace_me(); 576 follow_fork_parent(false); 577 } 578 579 /* Parent process. */ 580 children[0] = fpid; 581 582 /* The first wait() should report the stop from SIGSTOP. */ 583 wpid = waitpid(children[0], &status, 0); 584 ATF_REQUIRE(wpid == children[0]); 585 ATF_REQUIRE(WIFSTOPPED(status)); 586 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 587 588 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 589 590 /* Continue the child ignoring the SIGSTOP. */ 591 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 592 593 children[1] = handle_fork_events(children[0], NULL); 594 ATF_REQUIRE(children[1] > 0); 595 596 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 597 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 598 599 /* 600 * Should not see any status from the grandchild now, only the 601 * child. 602 */ 603 wpid = wait(&status); 604 ATF_REQUIRE(wpid == children[0]); 605 ATF_REQUIRE(WIFEXITED(status)); 606 ATF_REQUIRE(WEXITSTATUS(status) == 1); 607 608 wpid = wait(&status); 609 ATF_REQUIRE(wpid == -1); 610 ATF_REQUIRE(errno == ECHILD); 611} 612 613/* 614 * Verify that a new child process is stopped after a followed fork 615 * and that the traced parent sees the exit of the child when the 616 * traced parent is detached after the fork. 617 */ 618ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached); 619ATF_TC_BODY(ptrace__follow_fork_parent_detached, tc) 620{ 621 pid_t children[0], fpid, wpid; 622 int status; 623 624 ATF_REQUIRE((fpid = fork()) != -1); 625 if (fpid == 0) { 626 trace_me(); 627 follow_fork_parent(false); 628 } 629 630 /* Parent process. */ 631 children[0] = fpid; 632 633 /* The first wait() should report the stop from SIGSTOP. */ 634 wpid = waitpid(children[0], &status, 0); 635 ATF_REQUIRE(wpid == children[0]); 636 ATF_REQUIRE(WIFSTOPPED(status)); 637 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 638 639 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 640 641 /* Continue the child ignoring the SIGSTOP. */ 642 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 643 644 children[1] = handle_fork_events(children[0], NULL); 645 ATF_REQUIRE(children[1] > 0); 646 647 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 648 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 649 650 /* 651 * The child can't exit until the grandchild reports status, so the 652 * grandchild should report its exit first to the debugger. 653 * 654 * Even though the child process is detached, it is still a 655 * child of the debugger, so it will still report it's exit 656 * after the grandchild. 657 */ 658 wpid = wait(&status); 659 ATF_REQUIRE(wpid == children[1]); 660 ATF_REQUIRE(WIFEXITED(status)); 661 ATF_REQUIRE(WEXITSTATUS(status) == 2); 662 663 wpid = wait(&status); 664 ATF_REQUIRE(wpid == children[0]); 665 ATF_REQUIRE(WIFEXITED(status)); 666 ATF_REQUIRE(WEXITSTATUS(status) == 1); 667 668 wpid = wait(&status); 669 ATF_REQUIRE(wpid == -1); 670 ATF_REQUIRE(errno == ECHILD); 671} 672 673static void 674attach_fork_parent(int cpipe[2]) 675{ 676 pid_t fpid; 677 678 close(cpipe[0]); 679 680 /* Double-fork to disassociate from the debugger. */ 681 CHILD_REQUIRE((fpid = fork()) != -1); 682 if (fpid != 0) 683 exit(3); 684 685 /* Send the pid of the disassociated child to the debugger. */ 686 fpid = getpid(); 687 CHILD_REQUIRE(write(cpipe[1], &fpid, sizeof(fpid)) == sizeof(fpid)); 688 689 /* Wait for the debugger to attach. */ 690 CHILD_REQUIRE(read(cpipe[1], &fpid, sizeof(fpid)) == 0); 691} 692 693/* 694 * Verify that a new child process is stopped after a followed fork and 695 * that the traced parent sees the exit of the child after the debugger 696 * when both processes remain attached to the debugger. In this test 697 * the parent that forks is not a direct child of the debugger. 698 */ 699ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached_unrelated_debugger); 700ATF_TC_BODY(ptrace__follow_fork_both_attached_unrelated_debugger, tc) 701{ 702 pid_t children[0], fpid, wpid; 703 int cpipe[2], status; 704 705 ATF_REQUIRE(pipe(cpipe) == 0); 706 ATF_REQUIRE((fpid = fork()) != -1); 707 if (fpid == 0) { 708 attach_fork_parent(cpipe); 709 follow_fork_parent(false); 710 } 711 712 /* Parent process. */ 713 close(cpipe[1]); 714 715 /* Wait for the direct child to exit. */ 716 wpid = waitpid(fpid, &status, 0); 717 ATF_REQUIRE(wpid == fpid); 718 ATF_REQUIRE(WIFEXITED(status)); 719 ATF_REQUIRE(WEXITSTATUS(status) == 3); 720 721 /* Read the pid of the fork parent. */ 722 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 723 sizeof(children[0])); 724 725 /* Attach to the fork parent. */ 726 attach_child(children[0]); 727 728 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 729 730 /* Continue the fork parent ignoring the SIGSTOP. */ 731 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 732 733 /* Signal the fork parent to continue. */ 734 close(cpipe[0]); 735 736 children[1] = handle_fork_events(children[0], NULL); 737 ATF_REQUIRE(children[1] > 0); 738 739 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 740 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 741 742 /* 743 * The fork parent can't exit until the child reports status, 744 * so the child should report its exit first to the debugger. 745 */ 746 wpid = wait(&status); 747 ATF_REQUIRE(wpid == children[1]); 748 ATF_REQUIRE(WIFEXITED(status)); 749 ATF_REQUIRE(WEXITSTATUS(status) == 2); 750 751 wpid = wait(&status); 752 ATF_REQUIRE(wpid == children[0]); 753 ATF_REQUIRE(WIFEXITED(status)); 754 ATF_REQUIRE(WEXITSTATUS(status) == 1); 755 756 wpid = wait(&status); 757 ATF_REQUIRE(wpid == -1); 758 ATF_REQUIRE(errno == ECHILD); 759} 760 761/* 762 * Verify that a new child process is stopped after a followed fork 763 * and that the traced parent sees the exit of the child when the new 764 * child process is detached after it reports its fork. In this test 765 * the parent that forks is not a direct child of the debugger. 766 */ 767ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached_unrelated_debugger); 768ATF_TC_BODY(ptrace__follow_fork_child_detached_unrelated_debugger, tc) 769{ 770 pid_t children[0], fpid, wpid; 771 int cpipe[2], status; 772 773 ATF_REQUIRE(pipe(cpipe) == 0); 774 ATF_REQUIRE((fpid = fork()) != -1); 775 if (fpid == 0) { 776 attach_fork_parent(cpipe); 777 follow_fork_parent(false); 778 } 779 780 /* Parent process. */ 781 close(cpipe[1]); 782 783 /* Wait for the direct child to exit. */ 784 wpid = waitpid(fpid, &status, 0); 785 ATF_REQUIRE(wpid == fpid); 786 ATF_REQUIRE(WIFEXITED(status)); 787 ATF_REQUIRE(WEXITSTATUS(status) == 3); 788 789 /* Read the pid of the fork parent. */ 790 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 791 sizeof(children[0])); 792 793 /* Attach to the fork parent. */ 794 attach_child(children[0]); 795 796 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 797 798 /* Continue the fork parent ignoring the SIGSTOP. */ 799 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 800 801 /* Signal the fork parent to continue. */ 802 close(cpipe[0]); 803 804 children[1] = handle_fork_events(children[0], NULL); 805 ATF_REQUIRE(children[1] > 0); 806 807 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 808 ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1); 809 810 /* 811 * Should not see any status from the child now, only the fork 812 * parent. 813 */ 814 wpid = wait(&status); 815 ATF_REQUIRE(wpid == children[0]); 816 ATF_REQUIRE(WIFEXITED(status)); 817 ATF_REQUIRE(WEXITSTATUS(status) == 1); 818 819 wpid = wait(&status); 820 ATF_REQUIRE(wpid == -1); 821 ATF_REQUIRE(errno == ECHILD); 822} 823 824/* 825 * Verify that a new child process is stopped after a followed fork 826 * and that the traced parent sees the exit of the child when the 827 * traced parent is detached after the fork. In this test the parent 828 * that forks is not a direct child of the debugger. 829 */ 830ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached_unrelated_debugger); 831ATF_TC_BODY(ptrace__follow_fork_parent_detached_unrelated_debugger, tc) 832{ 833 pid_t children[0], fpid, wpid; 834 int cpipe[2], status; 835 836 ATF_REQUIRE(pipe(cpipe) == 0); 837 ATF_REQUIRE((fpid = fork()) != -1); 838 if (fpid == 0) { 839 attach_fork_parent(cpipe); 840 follow_fork_parent(false); 841 } 842 843 /* Parent process. */ 844 close(cpipe[1]); 845 846 /* Wait for the direct child to exit. */ 847 wpid = waitpid(fpid, &status, 0); 848 ATF_REQUIRE(wpid == fpid); 849 ATF_REQUIRE(WIFEXITED(status)); 850 ATF_REQUIRE(WEXITSTATUS(status) == 3); 851 852 /* Read the pid of the fork parent. */ 853 ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) == 854 sizeof(children[0])); 855 856 /* Attach to the fork parent. */ 857 attach_child(children[0]); 858 859 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 860 861 /* Continue the fork parent ignoring the SIGSTOP. */ 862 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 863 864 /* Signal the fork parent to continue. */ 865 close(cpipe[0]); 866 867 children[1] = handle_fork_events(children[0], NULL); 868 ATF_REQUIRE(children[1] > 0); 869 870 ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1); 871 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 872 873 /* 874 * Should not see any status from the fork parent now, only 875 * the child. 876 */ 877 wpid = wait(&status); 878 ATF_REQUIRE(wpid == children[1]); 879 ATF_REQUIRE(WIFEXITED(status)); 880 ATF_REQUIRE(WEXITSTATUS(status) == 2); 881 882 wpid = wait(&status); 883 ATF_REQUIRE(wpid == -1); 884 ATF_REQUIRE(errno == ECHILD); 885} 886 887/* 888 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 889 * child process created via fork() reports the correct value. 890 */ 891ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_fork); 892ATF_TC_BODY(ptrace__new_child_pl_syscall_code_fork, tc) 893{ 894 struct ptrace_lwpinfo pl[2]; 895 pid_t children[2], fpid, wpid; 896 int status; 897 898 ATF_REQUIRE((fpid = fork()) != -1); 899 if (fpid == 0) { 900 trace_me(); 901 follow_fork_parent(false); 902 } 903 904 /* Parent process. */ 905 children[0] = fpid; 906 907 /* The first wait() should report the stop from SIGSTOP. */ 908 wpid = waitpid(children[0], &status, 0); 909 ATF_REQUIRE(wpid == children[0]); 910 ATF_REQUIRE(WIFSTOPPED(status)); 911 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 912 913 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 914 915 /* Continue the child ignoring the SIGSTOP. */ 916 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 917 918 /* Wait for both halves of the fork event to get reported. */ 919 children[1] = handle_fork_events(children[0], pl); 920 ATF_REQUIRE(children[1] > 0); 921 922 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0); 923 ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0); 924 ATF_REQUIRE(pl[0].pl_syscall_code == SYS_fork); 925 ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code); 926 ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg); 927 928 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 929 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 930 931 /* 932 * The child can't exit until the grandchild reports status, so the 933 * grandchild should report its exit first to the debugger. 934 */ 935 wpid = wait(&status); 936 ATF_REQUIRE(wpid == children[1]); 937 ATF_REQUIRE(WIFEXITED(status)); 938 ATF_REQUIRE(WEXITSTATUS(status) == 2); 939 940 wpid = wait(&status); 941 ATF_REQUIRE(wpid == children[0]); 942 ATF_REQUIRE(WIFEXITED(status)); 943 ATF_REQUIRE(WEXITSTATUS(status) == 1); 944 945 wpid = wait(&status); 946 ATF_REQUIRE(wpid == -1); 947 ATF_REQUIRE(errno == ECHILD); 948} 949 950/* 951 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 952 * child process created via vfork() reports the correct value. 953 */ 954ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_vfork); 955ATF_TC_BODY(ptrace__new_child_pl_syscall_code_vfork, tc) 956{ 957 struct ptrace_lwpinfo pl[2]; 958 pid_t children[2], fpid, wpid; 959 int status; 960 961 ATF_REQUIRE((fpid = fork()) != -1); 962 if (fpid == 0) { 963 trace_me(); 964 follow_fork_parent(true); 965 } 966 967 /* Parent process. */ 968 children[0] = fpid; 969 970 /* The first wait() should report the stop from SIGSTOP. */ 971 wpid = waitpid(children[0], &status, 0); 972 ATF_REQUIRE(wpid == children[0]); 973 ATF_REQUIRE(WIFSTOPPED(status)); 974 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 975 976 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1); 977 978 /* Continue the child ignoring the SIGSTOP. */ 979 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 980 981 /* Wait for both halves of the fork event to get reported. */ 982 children[1] = handle_fork_events(children[0], pl); 983 ATF_REQUIRE(children[1] > 0); 984 985 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0); 986 ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0); 987 ATF_REQUIRE(pl[0].pl_syscall_code == SYS_vfork); 988 ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code); 989 ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg); 990 991 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 992 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 993 994 /* 995 * The child can't exit until the grandchild reports status, so the 996 * grandchild should report its exit first to the debugger. 997 */ 998 wpid = wait(&status); 999 ATF_REQUIRE(wpid == children[1]); 1000 ATF_REQUIRE(WIFEXITED(status)); 1001 ATF_REQUIRE(WEXITSTATUS(status) == 2); 1002 1003 wpid = wait(&status); 1004 ATF_REQUIRE(wpid == children[0]); 1005 ATF_REQUIRE(WIFEXITED(status)); 1006 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1007 1008 wpid = wait(&status); 1009 ATF_REQUIRE(wpid == -1); 1010 ATF_REQUIRE(errno == ECHILD); 1011} 1012 1013static void * 1014simple_thread(void *arg __unused) 1015{ 1016 1017 pthread_exit(NULL); 1018} 1019 1020static __dead2 void 1021simple_thread_main(void) 1022{ 1023 pthread_t thread; 1024 1025 CHILD_REQUIRE(pthread_create(&thread, NULL, simple_thread, NULL) == 0); 1026 CHILD_REQUIRE(pthread_join(thread, NULL) == 0); 1027 exit(1); 1028} 1029 1030/* 1031 * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new 1032 * thread reports the correct value. 1033 */ 1034ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_thread); 1035ATF_TC_BODY(ptrace__new_child_pl_syscall_code_thread, tc) 1036{ 1037 struct ptrace_lwpinfo pl; 1038 pid_t fpid, wpid; 1039 lwpid_t mainlwp; 1040 int status; 1041 1042 ATF_REQUIRE((fpid = fork()) != -1); 1043 if (fpid == 0) { 1044 trace_me(); 1045 simple_thread_main(); 1046 } 1047 1048 /* The first wait() should report the stop from SIGSTOP. */ 1049 wpid = waitpid(fpid, &status, 0); 1050 ATF_REQUIRE(wpid == fpid); 1051 ATF_REQUIRE(WIFSTOPPED(status)); 1052 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1053 1054 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1055 sizeof(pl)) != -1); 1056 mainlwp = pl.pl_lwpid; 1057 1058 /* 1059 * Continue the child ignoring the SIGSTOP and tracing all 1060 * system call exits. 1061 */ 1062 ATF_REQUIRE(ptrace(PT_TO_SCX, fpid, (caddr_t)1, 0) != -1); 1063 1064 /* 1065 * Wait for the new thread to arrive. pthread_create() might 1066 * invoke any number of system calls. For now we just wait 1067 * for the new thread to arrive and make sure it reports a 1068 * valid system call code. If ptrace grows thread event 1069 * reporting then this test can be made more precise. 1070 */ 1071 for (;;) { 1072 wpid = waitpid(fpid, &status, 0); 1073 ATF_REQUIRE(wpid == fpid); 1074 ATF_REQUIRE(WIFSTOPPED(status)); 1075 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1076 1077 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1078 sizeof(pl)) != -1); 1079 ATF_REQUIRE((pl.pl_flags & PL_FLAG_SCX) != 0); 1080 ATF_REQUIRE(pl.pl_syscall_code != 0); 1081 if (pl.pl_lwpid != mainlwp) 1082 /* New thread seen. */ 1083 break; 1084 1085 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1086 } 1087 1088 /* Wait for the child to exit. */ 1089 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1090 for (;;) { 1091 wpid = waitpid(fpid, &status, 0); 1092 ATF_REQUIRE(wpid == fpid); 1093 if (WIFEXITED(status)) 1094 break; 1095 1096 ATF_REQUIRE(WIFSTOPPED(status)); 1097 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1098 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1099 } 1100 1101 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1102 1103 wpid = wait(&status); 1104 ATF_REQUIRE(wpid == -1); 1105 ATF_REQUIRE(errno == ECHILD); 1106} 1107 1108/* 1109 * Verify that the expected LWP events are reported for a child thread. 1110 */ 1111ATF_TC_WITHOUT_HEAD(ptrace__lwp_events); 1112ATF_TC_BODY(ptrace__lwp_events, tc) 1113{ 1114 struct ptrace_lwpinfo pl; 1115 pid_t fpid, wpid; 1116 lwpid_t lwps[2]; 1117 int status; 1118 1119 ATF_REQUIRE((fpid = fork()) != -1); 1120 if (fpid == 0) { 1121 trace_me(); 1122 simple_thread_main(); 1123 } 1124 1125 /* The first wait() should report the stop from SIGSTOP. */ 1126 wpid = waitpid(fpid, &status, 0); 1127 ATF_REQUIRE(wpid == fpid); 1128 ATF_REQUIRE(WIFSTOPPED(status)); 1129 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1130 1131 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1132 sizeof(pl)) != -1); 1133 lwps[0] = pl.pl_lwpid; 1134 1135 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1136 1137 /* Continue the child ignoring the SIGSTOP. */ 1138 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1139 1140 /* The first event should be for the child thread's birth. */ 1141 wpid = waitpid(fpid, &status, 0); 1142 ATF_REQUIRE(wpid == fpid); 1143 ATF_REQUIRE(WIFSTOPPED(status)); 1144 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1145 1146 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1147 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1148 (PL_FLAG_BORN | PL_FLAG_SCX)); 1149 ATF_REQUIRE(pl.pl_lwpid != lwps[0]); 1150 lwps[1] = pl.pl_lwpid; 1151 1152 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1153 1154 /* The next event should be for the child thread's death. */ 1155 wpid = waitpid(fpid, &status, 0); 1156 ATF_REQUIRE(wpid == fpid); 1157 ATF_REQUIRE(WIFSTOPPED(status)); 1158 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1159 1160 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1161 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) == 1162 (PL_FLAG_EXITED | PL_FLAG_SCE)); 1163 ATF_REQUIRE(pl.pl_lwpid == lwps[1]); 1164 1165 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1166 1167 /* The last event should be for the child process's exit. */ 1168 wpid = waitpid(fpid, &status, 0); 1169 ATF_REQUIRE(WIFEXITED(status)); 1170 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1171 1172 wpid = wait(&status); 1173 ATF_REQUIRE(wpid == -1); 1174 ATF_REQUIRE(errno == ECHILD); 1175} 1176 1177static void * 1178exec_thread(void *arg __unused) 1179{ 1180 1181 execl("/usr/bin/true", "true", NULL); 1182 exit(127); 1183} 1184 1185static __dead2 void 1186exec_thread_main(void) 1187{ 1188 pthread_t thread; 1189 1190 CHILD_REQUIRE(pthread_create(&thread, NULL, exec_thread, NULL) == 0); 1191 for (;;) 1192 sleep(60); 1193 exit(1); 1194} 1195 1196/* 1197 * Verify that the expected LWP events are reported for a multithreaded 1198 * process that calls execve(2). 1199 */ 1200ATF_TC_WITHOUT_HEAD(ptrace__lwp_events_exec); 1201ATF_TC_BODY(ptrace__lwp_events_exec, tc) 1202{ 1203 struct ptrace_lwpinfo pl; 1204 pid_t fpid, wpid; 1205 lwpid_t lwps[2]; 1206 int status; 1207 1208 ATF_REQUIRE((fpid = fork()) != -1); 1209 if (fpid == 0) { 1210 trace_me(); 1211 exec_thread_main(); 1212 } 1213 1214 /* The first wait() should report the stop from SIGSTOP. */ 1215 wpid = waitpid(fpid, &status, 0); 1216 ATF_REQUIRE(wpid == fpid); 1217 ATF_REQUIRE(WIFSTOPPED(status)); 1218 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1219 1220 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1221 sizeof(pl)) != -1); 1222 lwps[0] = pl.pl_lwpid; 1223 1224 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1225 1226 /* Continue the child ignoring the SIGSTOP. */ 1227 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1228 1229 /* The first event should be for the child thread's birth. */ 1230 wpid = waitpid(fpid, &status, 0); 1231 ATF_REQUIRE(wpid == fpid); 1232 ATF_REQUIRE(WIFSTOPPED(status)); 1233 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1234 1235 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1236 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1237 (PL_FLAG_BORN | PL_FLAG_SCX)); 1238 ATF_REQUIRE(pl.pl_lwpid != lwps[0]); 1239 lwps[1] = pl.pl_lwpid; 1240 1241 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1242 1243 /* 1244 * The next event should be for the main thread's death due to 1245 * single threading from execve(). 1246 */ 1247 wpid = waitpid(fpid, &status, 0); 1248 ATF_REQUIRE(wpid == fpid); 1249 ATF_REQUIRE(WIFSTOPPED(status)); 1250 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1251 1252 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1253 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) == 1254 (PL_FLAG_EXITED)); 1255 ATF_REQUIRE(pl.pl_lwpid == lwps[0]); 1256 1257 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1258 1259 /* The next event should be for the child process's exec. */ 1260 wpid = waitpid(fpid, &status, 0); 1261 ATF_REQUIRE(WIFSTOPPED(status)); 1262 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1263 1264 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1265 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) == 1266 (PL_FLAG_EXEC | PL_FLAG_SCX)); 1267 ATF_REQUIRE(pl.pl_lwpid == lwps[1]); 1268 1269 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1270 1271 /* The last event should be for the child process's exit. */ 1272 wpid = waitpid(fpid, &status, 0); 1273 ATF_REQUIRE(WIFEXITED(status)); 1274 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1275 1276 wpid = wait(&status); 1277 ATF_REQUIRE(wpid == -1); 1278 ATF_REQUIRE(errno == ECHILD); 1279} 1280 1281static void 1282handler(int sig __unused) 1283{ 1284} 1285 1286static void 1287signal_main(void) 1288{ 1289 1290 signal(SIGINFO, handler); 1291 raise(SIGINFO); 1292 exit(0); 1293} 1294 1295/* 1296 * Verify that the expected ptrace event is reported for a signal. 1297 */ 1298ATF_TC_WITHOUT_HEAD(ptrace__siginfo); 1299ATF_TC_BODY(ptrace__siginfo, tc) 1300{ 1301 struct ptrace_lwpinfo pl; 1302 pid_t fpid, wpid; 1303 int status; 1304 1305 ATF_REQUIRE((fpid = fork()) != -1); 1306 if (fpid == 0) { 1307 trace_me(); 1308 signal_main(); 1309 } 1310 1311 /* The first wait() should report the stop from SIGSTOP. */ 1312 wpid = waitpid(fpid, &status, 0); 1313 ATF_REQUIRE(wpid == fpid); 1314 ATF_REQUIRE(WIFSTOPPED(status)); 1315 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1316 1317 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1318 1319 /* The next event should be for the SIGINFO. */ 1320 wpid = waitpid(fpid, &status, 0); 1321 ATF_REQUIRE(WIFSTOPPED(status)); 1322 ATF_REQUIRE(WSTOPSIG(status) == SIGINFO); 1323 1324 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1325 ATF_REQUIRE(pl.pl_event == PL_EVENT_SIGNAL); 1326 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 1327 ATF_REQUIRE(pl.pl_siginfo.si_code == SI_LWP); 1328 ATF_REQUIRE(pl.pl_siginfo.si_pid == wpid); 1329 1330 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1331 1332 /* The last event should be for the child process's exit. */ 1333 wpid = waitpid(fpid, &status, 0); 1334 ATF_REQUIRE(WIFEXITED(status)); 1335 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1336 1337 wpid = wait(&status); 1338 ATF_REQUIRE(wpid == -1); 1339 ATF_REQUIRE(errno == ECHILD); 1340} 1341 1342/* 1343 * Verify that the expected ptrace events are reported for PTRACE_EXEC. 1344 */ 1345ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_disable); 1346ATF_TC_BODY(ptrace__ptrace_exec_disable, tc) 1347{ 1348 pid_t fpid, wpid; 1349 int events, status; 1350 1351 ATF_REQUIRE((fpid = fork()) != -1); 1352 if (fpid == 0) { 1353 trace_me(); 1354 exec_thread(NULL); 1355 } 1356 1357 /* The first wait() should report the stop from SIGSTOP. */ 1358 wpid = waitpid(fpid, &status, 0); 1359 ATF_REQUIRE(wpid == fpid); 1360 ATF_REQUIRE(WIFSTOPPED(status)); 1361 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1362 1363 events = 0; 1364 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1365 sizeof(events)) == 0); 1366 1367 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1368 1369 /* Should get one event at exit. */ 1370 wpid = waitpid(fpid, &status, 0); 1371 ATF_REQUIRE(WIFEXITED(status)); 1372 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1373 1374 wpid = wait(&status); 1375 ATF_REQUIRE(wpid == -1); 1376 ATF_REQUIRE(errno == ECHILD); 1377} 1378 1379ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_enable); 1380ATF_TC_BODY(ptrace__ptrace_exec_enable, tc) 1381{ 1382 struct ptrace_lwpinfo pl; 1383 pid_t fpid, wpid; 1384 int events, status; 1385 1386 ATF_REQUIRE((fpid = fork()) != -1); 1387 if (fpid == 0) { 1388 trace_me(); 1389 exec_thread(NULL); 1390 } 1391 1392 /* The first wait() should report the stop from SIGSTOP. */ 1393 wpid = waitpid(fpid, &status, 0); 1394 ATF_REQUIRE(wpid == fpid); 1395 ATF_REQUIRE(WIFSTOPPED(status)); 1396 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1397 1398 events = PTRACE_EXEC; 1399 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1400 sizeof(events)) == 0); 1401 1402 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1403 1404 /* The next event should be for the child process's exec. */ 1405 wpid = waitpid(fpid, &status, 0); 1406 ATF_REQUIRE(WIFSTOPPED(status)); 1407 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1408 1409 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1410 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) == 1411 (PL_FLAG_EXEC | PL_FLAG_SCX)); 1412 1413 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1414 1415 /* The last event should be for the child process's exit. */ 1416 wpid = waitpid(fpid, &status, 0); 1417 ATF_REQUIRE(WIFEXITED(status)); 1418 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1419 1420 wpid = wait(&status); 1421 ATF_REQUIRE(wpid == -1); 1422 ATF_REQUIRE(errno == ECHILD); 1423} 1424 1425ATF_TC_WITHOUT_HEAD(ptrace__event_mask); 1426ATF_TC_BODY(ptrace__event_mask, tc) 1427{ 1428 pid_t fpid, wpid; 1429 int events, status; 1430 1431 ATF_REQUIRE((fpid = fork()) != -1); 1432 if (fpid == 0) { 1433 trace_me(); 1434 exit(0); 1435 } 1436 1437 /* The first wait() should report the stop from SIGSTOP. */ 1438 wpid = waitpid(fpid, &status, 0); 1439 ATF_REQUIRE(wpid == fpid); 1440 ATF_REQUIRE(WIFSTOPPED(status)); 1441 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1442 1443 /* PT_FOLLOW_FORK should toggle the state of PTRACE_FORK. */ 1444 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 1) != -1); 1445 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1446 sizeof(events)) == 0); 1447 ATF_REQUIRE(events & PTRACE_FORK); 1448 ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 0) != -1); 1449 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1450 sizeof(events)) == 0); 1451 ATF_REQUIRE(!(events & PTRACE_FORK)); 1452 1453 /* PT_LWP_EVENTS should toggle the state of PTRACE_LWP. */ 1454 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 1) != -1); 1455 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1456 sizeof(events)) == 0); 1457 ATF_REQUIRE(events & PTRACE_LWP); 1458 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 0) != -1); 1459 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1460 sizeof(events)) == 0); 1461 ATF_REQUIRE(!(events & PTRACE_LWP)); 1462 1463 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1464 1465 /* Should get one event at exit. */ 1466 wpid = waitpid(fpid, &status, 0); 1467 ATF_REQUIRE(WIFEXITED(status)); 1468 ATF_REQUIRE(WEXITSTATUS(status) == 0); 1469 1470 wpid = wait(&status); 1471 ATF_REQUIRE(wpid == -1); 1472 ATF_REQUIRE(errno == ECHILD); 1473} 1474 1475/* 1476 * Verify that the expected ptrace events are reported for PTRACE_VFORK. 1477 */ 1478ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork); 1479ATF_TC_BODY(ptrace__ptrace_vfork, tc) 1480{ 1481 struct ptrace_lwpinfo pl; 1482 pid_t fpid, wpid; 1483 int events, status; 1484 1485 ATF_REQUIRE((fpid = fork()) != -1); 1486 if (fpid == 0) { 1487 trace_me(); 1488 follow_fork_parent(true); 1489 } 1490 1491 /* The first wait() should report the stop from SIGSTOP. */ 1492 wpid = waitpid(fpid, &status, 0); 1493 ATF_REQUIRE(wpid == fpid); 1494 ATF_REQUIRE(WIFSTOPPED(status)); 1495 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1496 1497 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events, 1498 sizeof(events)) == 0); 1499 events |= PTRACE_VFORK; 1500 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events, 1501 sizeof(events)) == 0); 1502 1503 /* Continue the child ignoring the SIGSTOP. */ 1504 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1); 1505 1506 /* The next event should report the end of the vfork. */ 1507 wpid = wait(&status); 1508 ATF_REQUIRE(wpid == fpid); 1509 ATF_REQUIRE(WIFSTOPPED(status)); 1510 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1511 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1512 ATF_REQUIRE((pl.pl_flags & PL_FLAG_VFORK_DONE) != 0); 1513 1514 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1); 1515 1516 wpid = wait(&status); 1517 ATF_REQUIRE(wpid == fpid); 1518 ATF_REQUIRE(WIFEXITED(status)); 1519 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1520 1521 wpid = wait(&status); 1522 ATF_REQUIRE(wpid == -1); 1523 ATF_REQUIRE(errno == ECHILD); 1524} 1525 1526ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork_follow); 1527ATF_TC_BODY(ptrace__ptrace_vfork_follow, tc) 1528{ 1529 struct ptrace_lwpinfo pl[2]; 1530 pid_t children[2], fpid, wpid; 1531 int events, status; 1532 1533 ATF_REQUIRE((fpid = fork()) != -1); 1534 if (fpid == 0) { 1535 trace_me(); 1536 follow_fork_parent(true); 1537 } 1538 1539 /* Parent process. */ 1540 children[0] = fpid; 1541 1542 /* The first wait() should report the stop from SIGSTOP. */ 1543 wpid = waitpid(children[0], &status, 0); 1544 ATF_REQUIRE(wpid == children[0]); 1545 ATF_REQUIRE(WIFSTOPPED(status)); 1546 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1547 1548 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, children[0], (caddr_t)&events, 1549 sizeof(events)) == 0); 1550 events |= PTRACE_FORK | PTRACE_VFORK; 1551 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, children[0], (caddr_t)&events, 1552 sizeof(events)) == 0); 1553 1554 /* Continue the child ignoring the SIGSTOP. */ 1555 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1556 1557 /* Wait for both halves of the fork event to get reported. */ 1558 children[1] = handle_fork_events(children[0], pl); 1559 ATF_REQUIRE(children[1] > 0); 1560 1561 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORKED) != 0); 1562 1563 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1564 ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1); 1565 1566 /* 1567 * The child can't exit until the grandchild reports status, so the 1568 * grandchild should report its exit first to the debugger. 1569 */ 1570 wpid = waitpid(children[1], &status, 0); 1571 ATF_REQUIRE(wpid == children[1]); 1572 ATF_REQUIRE(WIFEXITED(status)); 1573 ATF_REQUIRE(WEXITSTATUS(status) == 2); 1574 1575 /* 1576 * The child should report it's vfork() completion before it 1577 * exits. 1578 */ 1579 wpid = wait(&status); 1580 ATF_REQUIRE(wpid == children[0]); 1581 ATF_REQUIRE(WIFSTOPPED(status)); 1582 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1583 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl[0], sizeof(pl[0])) != 1584 -1); 1585 ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORK_DONE) != 0); 1586 1587 ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1); 1588 1589 wpid = wait(&status); 1590 ATF_REQUIRE(wpid == children[0]); 1591 ATF_REQUIRE(WIFEXITED(status)); 1592 ATF_REQUIRE(WEXITSTATUS(status) == 1); 1593 1594 wpid = wait(&status); 1595 ATF_REQUIRE(wpid == -1); 1596 ATF_REQUIRE(errno == ECHILD); 1597} 1598 1599/* 1600 * XXX: There's nothing inherently platform specific about this test, however a 1601 * userspace visible breakpoint() is a prerequisite. 1602 */ 1603 #if defined(__amd64__) || defined(__i386__) || defined(__sparc64__) 1604/* 1605 * Verify that no more events are reported after PT_KILL except for the 1606 * process exit when stopped due to a breakpoint trap. 1607 */ 1608ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_breakpoint); 1609ATF_TC_BODY(ptrace__PT_KILL_breakpoint, tc) 1610{ 1611 pid_t fpid, wpid; 1612 int status; 1613 1614 ATF_REQUIRE((fpid = fork()) != -1); 1615 if (fpid == 0) { 1616 trace_me(); 1617 breakpoint(); 1618 exit(1); 1619 } 1620 1621 /* The first wait() should report the stop from SIGSTOP. */ 1622 wpid = waitpid(fpid, &status, 0); 1623 ATF_REQUIRE(wpid == fpid); 1624 ATF_REQUIRE(WIFSTOPPED(status)); 1625 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1626 1627 /* Continue the child ignoring the SIGSTOP. */ 1628 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1629 1630 /* The second wait() should report hitting the breakpoint. */ 1631 wpid = waitpid(fpid, &status, 0); 1632 ATF_REQUIRE(wpid == fpid); 1633 ATF_REQUIRE(WIFSTOPPED(status)); 1634 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1635 1636 /* Kill the child process. */ 1637 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1638 1639 /* The last wait() should report the SIGKILL. */ 1640 wpid = waitpid(fpid, &status, 0); 1641 ATF_REQUIRE(wpid == fpid); 1642 ATF_REQUIRE(WIFSIGNALED(status)); 1643 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1644 1645 wpid = wait(&status); 1646 ATF_REQUIRE(wpid == -1); 1647 ATF_REQUIRE(errno == ECHILD); 1648} 1649#endif /* defined(__amd64__) || defined(__i386__) || defined(__sparc64__) */ 1650 1651/* 1652 * Verify that no more events are reported after PT_KILL except for the 1653 * process exit when stopped inside of a system call. 1654 */ 1655ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_system_call); 1656ATF_TC_BODY(ptrace__PT_KILL_system_call, tc) 1657{ 1658 struct ptrace_lwpinfo pl; 1659 pid_t fpid, wpid; 1660 int status; 1661 1662 ATF_REQUIRE((fpid = fork()) != -1); 1663 if (fpid == 0) { 1664 trace_me(); 1665 getpid(); 1666 exit(1); 1667 } 1668 1669 /* The first wait() should report the stop from SIGSTOP. */ 1670 wpid = waitpid(fpid, &status, 0); 1671 ATF_REQUIRE(wpid == fpid); 1672 ATF_REQUIRE(WIFSTOPPED(status)); 1673 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1674 1675 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 1676 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1677 1678 /* The second wait() should report a system call entry for getpid(). */ 1679 wpid = waitpid(fpid, &status, 0); 1680 ATF_REQUIRE(wpid == fpid); 1681 ATF_REQUIRE(WIFSTOPPED(status)); 1682 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1683 1684 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1685 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 1686 1687 /* Kill the child process. */ 1688 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1689 1690 /* The last wait() should report the SIGKILL. */ 1691 wpid = waitpid(fpid, &status, 0); 1692 ATF_REQUIRE(wpid == fpid); 1693 ATF_REQUIRE(WIFSIGNALED(status)); 1694 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1695 1696 wpid = wait(&status); 1697 ATF_REQUIRE(wpid == -1); 1698 ATF_REQUIRE(errno == ECHILD); 1699} 1700 1701/* 1702 * Verify that no more events are reported after PT_KILL except for the 1703 * process exit when killing a multithreaded process. 1704 */ 1705ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_threads); 1706ATF_TC_BODY(ptrace__PT_KILL_threads, tc) 1707{ 1708 struct ptrace_lwpinfo pl; 1709 pid_t fpid, wpid; 1710 lwpid_t main_lwp; 1711 int status; 1712 1713 ATF_REQUIRE((fpid = fork()) != -1); 1714 if (fpid == 0) { 1715 trace_me(); 1716 simple_thread_main(); 1717 } 1718 1719 /* The first wait() should report the stop from SIGSTOP. */ 1720 wpid = waitpid(fpid, &status, 0); 1721 ATF_REQUIRE(wpid == fpid); 1722 ATF_REQUIRE(WIFSTOPPED(status)); 1723 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1724 1725 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1726 sizeof(pl)) != -1); 1727 main_lwp = pl.pl_lwpid; 1728 1729 ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0); 1730 1731 /* Continue the child ignoring the SIGSTOP. */ 1732 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1733 1734 /* The first event should be for the child thread's birth. */ 1735 wpid = waitpid(fpid, &status, 0); 1736 ATF_REQUIRE(wpid == fpid); 1737 ATF_REQUIRE(WIFSTOPPED(status)); 1738 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1739 1740 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1741 ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) == 1742 (PL_FLAG_BORN | PL_FLAG_SCX)); 1743 ATF_REQUIRE(pl.pl_lwpid != main_lwp); 1744 1745 /* Kill the child process. */ 1746 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1747 1748 /* The last wait() should report the SIGKILL. */ 1749 wpid = waitpid(fpid, &status, 0); 1750 ATF_REQUIRE(wpid == fpid); 1751 ATF_REQUIRE(WIFSIGNALED(status)); 1752 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1753 1754 wpid = wait(&status); 1755 ATF_REQUIRE(wpid == -1); 1756 ATF_REQUIRE(errno == ECHILD); 1757} 1758 1759static void * 1760mask_usr1_thread(void *arg) 1761{ 1762 pthread_barrier_t *pbarrier; 1763 sigset_t sigmask; 1764 1765 pbarrier = (pthread_barrier_t*)arg; 1766 1767 sigemptyset(&sigmask); 1768 sigaddset(&sigmask, SIGUSR1); 1769 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 1770 1771 /* Sync up with other thread after sigmask updated. */ 1772 pthread_barrier_wait(pbarrier); 1773 1774 for (;;) 1775 sleep(60); 1776 1777 return (NULL); 1778} 1779 1780/* 1781 * Verify that the SIGKILL from PT_KILL takes priority over other signals 1782 * and prevents spurious stops due to those other signals. 1783 */ 1784ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_competing_signal); 1785ATF_TC_BODY(ptrace__PT_KILL_competing_signal, tc) 1786{ 1787 pid_t fpid, wpid; 1788 int status; 1789 cpuset_t setmask; 1790 pthread_t t; 1791 pthread_barrier_t barrier; 1792 struct sched_param sched_param; 1793 1794 ATF_REQUIRE((fpid = fork()) != -1); 1795 if (fpid == 0) { 1796 /* Bind to one CPU so only one thread at a time will run. */ 1797 CPU_ZERO(&setmask); 1798 CPU_SET(0, &setmask); 1799 cpusetid_t setid; 1800 CHILD_REQUIRE(cpuset(&setid) == 0); 1801 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 1802 CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0); 1803 1804 CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 1805 1806 CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread, 1807 (void*)&barrier) == 0); 1808 1809 /* 1810 * Give the main thread higher priority. The test always 1811 * assumes that, if both threads are able to run, the main 1812 * thread runs first. 1813 */ 1814 sched_param.sched_priority = 1815 (sched_get_priority_max(SCHED_FIFO) + 1816 sched_get_priority_min(SCHED_FIFO)) / 2; 1817 CHILD_REQUIRE(pthread_setschedparam(pthread_self(), 1818 SCHED_FIFO, &sched_param) == 0); 1819 sched_param.sched_priority -= RQ_PPQ; 1820 CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO, 1821 &sched_param) == 0); 1822 1823 sigset_t sigmask; 1824 sigemptyset(&sigmask); 1825 sigaddset(&sigmask, SIGUSR2); 1826 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 1827 1828 /* Sync up with other thread after sigmask updated. */ 1829 pthread_barrier_wait(&barrier); 1830 1831 trace_me(); 1832 1833 for (;;) 1834 sleep(60); 1835 1836 exit(1); 1837 } 1838 1839 /* The first wait() should report the stop from SIGSTOP. */ 1840 wpid = waitpid(fpid, &status, 0); 1841 ATF_REQUIRE(wpid == fpid); 1842 ATF_REQUIRE(WIFSTOPPED(status)); 1843 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1844 1845 /* Continue the child ignoring the SIGSTOP. */ 1846 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 1847 1848 /* Send a signal that only the second thread can handle. */ 1849 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 1850 1851 /* The second wait() should report the SIGUSR2. */ 1852 wpid = waitpid(fpid, &status, 0); 1853 ATF_REQUIRE(wpid == fpid); 1854 ATF_REQUIRE(WIFSTOPPED(status)); 1855 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 1856 1857 /* Send a signal that only the first thread can handle. */ 1858 ATF_REQUIRE(kill(fpid, SIGUSR1) == 0); 1859 1860 /* Replace the SIGUSR2 with a kill. */ 1861 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 1862 1863 /* The last wait() should report the SIGKILL (not the SIGUSR signal). */ 1864 wpid = waitpid(fpid, &status, 0); 1865 ATF_REQUIRE(wpid == fpid); 1866 ATF_REQUIRE(WIFSIGNALED(status)); 1867 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 1868 1869 wpid = wait(&status); 1870 ATF_REQUIRE(wpid == -1); 1871 ATF_REQUIRE(errno == ECHILD); 1872} 1873 1874/* 1875 * Verify that the SIGKILL from PT_KILL takes priority over other stop events 1876 * and prevents spurious stops caused by those events. 1877 */ 1878ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_competing_stop); 1879ATF_TC_BODY(ptrace__PT_KILL_competing_stop, tc) 1880{ 1881 pid_t fpid, wpid; 1882 int status; 1883 cpuset_t setmask; 1884 pthread_t t; 1885 pthread_barrier_t barrier; 1886 lwpid_t main_lwp; 1887 struct ptrace_lwpinfo pl; 1888 struct sched_param sched_param; 1889 1890 ATF_REQUIRE((fpid = fork()) != -1); 1891 if (fpid == 0) { 1892 trace_me(); 1893 1894 /* Bind to one CPU so only one thread at a time will run. */ 1895 CPU_ZERO(&setmask); 1896 CPU_SET(0, &setmask); 1897 cpusetid_t setid; 1898 CHILD_REQUIRE(cpuset(&setid) == 0); 1899 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 1900 CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0); 1901 1902 CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 1903 1904 CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread, 1905 (void*)&barrier) == 0); 1906 1907 /* 1908 * Give the main thread higher priority. The test always 1909 * assumes that, if both threads are able to run, the main 1910 * thread runs first. 1911 */ 1912 sched_param.sched_priority = 1913 (sched_get_priority_max(SCHED_FIFO) + 1914 sched_get_priority_min(SCHED_FIFO)) / 2; 1915 CHILD_REQUIRE(pthread_setschedparam(pthread_self(), 1916 SCHED_FIFO, &sched_param) == 0); 1917 sched_param.sched_priority -= RQ_PPQ; 1918 CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO, 1919 &sched_param) == 0); 1920 1921 sigset_t sigmask; 1922 sigemptyset(&sigmask); 1923 sigaddset(&sigmask, SIGUSR2); 1924 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 1925 1926 /* Sync up with other thread after sigmask updated. */ 1927 pthread_barrier_wait(&barrier); 1928 1929 /* Sync up with the test before doing the getpid(). */ 1930 raise(SIGSTOP); 1931 1932 getpid(); 1933 exit(1); 1934 } 1935 1936 /* The first wait() should report the stop from SIGSTOP. */ 1937 wpid = waitpid(fpid, &status, 0); 1938 ATF_REQUIRE(wpid == fpid); 1939 ATF_REQUIRE(WIFSTOPPED(status)); 1940 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1941 1942 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 1943 main_lwp = pl.pl_lwpid; 1944 1945 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 1946 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1947 1948 /* 1949 * Continue until child is done with setup, which is indicated with 1950 * SIGSTOP. Ignore system calls in the meantime. 1951 */ 1952 for (;;) { 1953 wpid = waitpid(fpid, &status, 0); 1954 ATF_REQUIRE(wpid == fpid); 1955 ATF_REQUIRE(WIFSTOPPED(status)); 1956 if (WSTOPSIG(status) == SIGTRAP) { 1957 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1958 sizeof(pl)) != -1); 1959 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 1960 } else { 1961 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 1962 break; 1963 } 1964 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1965 } 1966 1967 /* Proceed, allowing main thread to hit syscall entry for getpid(). */ 1968 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1969 1970 wpid = waitpid(fpid, &status, 0); 1971 ATF_REQUIRE(wpid == fpid); 1972 ATF_REQUIRE(WIFSTOPPED(status)); 1973 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1974 1975 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1976 sizeof(pl)) != -1); 1977 ATF_REQUIRE(pl.pl_lwpid == main_lwp); 1978 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 1979 /* Prevent the main thread from hitting its syscall exit for now. */ 1980 ATF_REQUIRE(ptrace(PT_SUSPEND, main_lwp, 0, 0) == 0); 1981 1982 /* 1983 * Proceed, allowing second thread to hit syscall exit for 1984 * pthread_barrier_wait(). 1985 */ 1986 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 1987 1988 wpid = waitpid(fpid, &status, 0); 1989 ATF_REQUIRE(wpid == fpid); 1990 ATF_REQUIRE(WIFSTOPPED(status)); 1991 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 1992 1993 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, 1994 sizeof(pl)) != -1); 1995 ATF_REQUIRE(pl.pl_lwpid != main_lwp); 1996 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 1997 1998 /* Send a signal that only the second thread can handle. */ 1999 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2000 2001 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2002 2003 /* The next wait() should report the SIGUSR2. */ 2004 wpid = waitpid(fpid, &status, 0); 2005 ATF_REQUIRE(wpid == fpid); 2006 ATF_REQUIRE(WIFSTOPPED(status)); 2007 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2008 2009 /* Allow the main thread to try to finish its system call. */ 2010 ATF_REQUIRE(ptrace(PT_RESUME, main_lwp, 0, 0) == 0); 2011 2012 /* 2013 * At this point, the main thread is in the middle of a system call and 2014 * has been resumed. The second thread has taken a SIGUSR2 which will 2015 * be replaced with a SIGKILL below. The main thread will get to run 2016 * first. It should notice the kill request (even though the signal 2017 * replacement occurred in the other thread) and exit accordingly. It 2018 * should not stop for the system call exit event. 2019 */ 2020 2021 /* Replace the SIGUSR2 with a kill. */ 2022 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 2023 2024 /* The last wait() should report the SIGKILL (not a syscall exit). */ 2025 wpid = waitpid(fpid, &status, 0); 2026 ATF_REQUIRE(wpid == fpid); 2027 ATF_REQUIRE(WIFSIGNALED(status)); 2028 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 2029 2030 wpid = wait(&status); 2031 ATF_REQUIRE(wpid == -1); 2032 ATF_REQUIRE(errno == ECHILD); 2033} 2034 2035static void 2036sigusr1_handler(int sig) 2037{ 2038 2039 CHILD_REQUIRE(sig == SIGUSR1); 2040 _exit(2); 2041} 2042 2043/* 2044 * Verify that even if the signal queue is full for a child process, 2045 * a PT_KILL will kill the process. 2046 */ 2047ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_with_signal_full_sigqueue); 2048ATF_TC_BODY(ptrace__PT_KILL_with_signal_full_sigqueue, tc) 2049{ 2050 pid_t fpid, wpid; 2051 int status; 2052 int max_pending_per_proc; 2053 size_t len; 2054 int i; 2055 2056 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2057 2058 ATF_REQUIRE((fpid = fork()) != -1); 2059 if (fpid == 0) { 2060 trace_me(); 2061 exit(1); 2062 } 2063 2064 /* The first wait() should report the stop from SIGSTOP. */ 2065 wpid = waitpid(fpid, &status, 0); 2066 ATF_REQUIRE(wpid == fpid); 2067 ATF_REQUIRE(WIFSTOPPED(status)); 2068 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2069 2070 len = sizeof(max_pending_per_proc); 2071 ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc", 2072 &max_pending_per_proc, &len, NULL, 0) == 0); 2073 2074 /* Fill the signal queue. */ 2075 for (i = 0; i < max_pending_per_proc; ++i) 2076 ATF_REQUIRE(kill(fpid, SIGUSR1) == 0); 2077 2078 /* Kill the child process. */ 2079 ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0); 2080 2081 /* The last wait() should report the SIGKILL. */ 2082 wpid = waitpid(fpid, &status, 0); 2083 ATF_REQUIRE(wpid == fpid); 2084 ATF_REQUIRE(WIFSIGNALED(status)); 2085 ATF_REQUIRE(WTERMSIG(status) == SIGKILL); 2086 2087 wpid = wait(&status); 2088 ATF_REQUIRE(wpid == -1); 2089 ATF_REQUIRE(errno == ECHILD); 2090} 2091 2092/* 2093 * Verify that when stopped at a system call entry, a signal can be 2094 * requested with PT_CONTINUE which will be delivered once the system 2095 * call is complete. 2096 */ 2097ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry); 2098ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry, tc) 2099{ 2100 struct ptrace_lwpinfo pl; 2101 pid_t fpid, wpid; 2102 int status; 2103 2104 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2105 2106 ATF_REQUIRE((fpid = fork()) != -1); 2107 if (fpid == 0) { 2108 trace_me(); 2109 getpid(); 2110 exit(1); 2111 } 2112 2113 /* The first wait() should report the stop from SIGSTOP. */ 2114 wpid = waitpid(fpid, &status, 0); 2115 ATF_REQUIRE(wpid == fpid); 2116 ATF_REQUIRE(WIFSTOPPED(status)); 2117 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2118 2119 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2120 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2121 2122 /* The second wait() should report a system call entry for getpid(). */ 2123 wpid = waitpid(fpid, &status, 0); 2124 ATF_REQUIRE(wpid == fpid); 2125 ATF_REQUIRE(WIFSTOPPED(status)); 2126 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2127 2128 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2129 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2130 2131 /* Continue the child process with a signal. */ 2132 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2133 2134 for (;;) { 2135 /* 2136 * The last wait() should report exit 2, i.e., a normal _exit 2137 * from the signal handler. In the meantime, catch and proceed 2138 * past any syscall stops. 2139 */ 2140 wpid = waitpid(fpid, &status, 0); 2141 ATF_REQUIRE(wpid == fpid); 2142 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2143 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2144 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2145 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2146 } else { 2147 ATF_REQUIRE(WIFEXITED(status)); 2148 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2149 break; 2150 } 2151 } 2152 2153 wpid = wait(&status); 2154 ATF_REQUIRE(wpid == -1); 2155 ATF_REQUIRE(errno == ECHILD); 2156} 2157 2158static void 2159sigusr1_counting_handler(int sig) 2160{ 2161 static int counter = 0; 2162 2163 CHILD_REQUIRE(sig == SIGUSR1); 2164 counter++; 2165 if (counter == 2) 2166 _exit(2); 2167} 2168 2169/* 2170 * Verify that, when continuing from a stop at system call entry and exit, 2171 * a signal can be requested from both stops, and both will be delivered when 2172 * the system call is complete. 2173 */ 2174ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit); 2175ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit, tc) 2176{ 2177 struct ptrace_lwpinfo pl; 2178 pid_t fpid, wpid; 2179 int status; 2180 2181 ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR); 2182 2183 ATF_REQUIRE((fpid = fork()) != -1); 2184 if (fpid == 0) { 2185 trace_me(); 2186 getpid(); 2187 exit(1); 2188 } 2189 2190 /* The first wait() should report the stop from SIGSTOP. */ 2191 wpid = waitpid(fpid, &status, 0); 2192 ATF_REQUIRE(wpid == fpid); 2193 ATF_REQUIRE(WIFSTOPPED(status)); 2194 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2195 2196 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2197 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2198 2199 /* The second wait() should report a system call entry for getpid(). */ 2200 wpid = waitpid(fpid, &status, 0); 2201 ATF_REQUIRE(wpid == fpid); 2202 ATF_REQUIRE(WIFSTOPPED(status)); 2203 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2204 2205 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2206 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2207 2208 /* Continue the child process with a signal. */ 2209 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2210 2211 /* The third wait() should report a system call exit for getpid(). */ 2212 wpid = waitpid(fpid, &status, 0); 2213 ATF_REQUIRE(wpid == fpid); 2214 ATF_REQUIRE(WIFSTOPPED(status)); 2215 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2216 2217 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2218 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 2219 2220 /* Continue the child process with a signal. */ 2221 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2222 2223 for (;;) { 2224 /* 2225 * The last wait() should report exit 2, i.e., a normal _exit 2226 * from the signal handler. In the meantime, catch and proceed 2227 * past any syscall stops. 2228 */ 2229 wpid = waitpid(fpid, &status, 0); 2230 ATF_REQUIRE(wpid == fpid); 2231 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2232 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2233 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2234 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2235 } else { 2236 ATF_REQUIRE(WIFEXITED(status)); 2237 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2238 break; 2239 } 2240 } 2241 2242 wpid = wait(&status); 2243 ATF_REQUIRE(wpid == -1); 2244 ATF_REQUIRE(errno == ECHILD); 2245} 2246 2247/* 2248 * Verify that even if the signal queue is full for a child process, 2249 * a PT_CONTINUE with a signal will not result in loss of that signal. 2250 */ 2251ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_full_sigqueue); 2252ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_full_sigqueue, tc) 2253{ 2254 pid_t fpid, wpid; 2255 int status; 2256 int max_pending_per_proc; 2257 size_t len; 2258 int i; 2259 2260 ATF_REQUIRE(signal(SIGUSR2, handler) != SIG_ERR); 2261 ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR); 2262 2263 ATF_REQUIRE((fpid = fork()) != -1); 2264 if (fpid == 0) { 2265 trace_me(); 2266 exit(1); 2267 } 2268 2269 /* The first wait() should report the stop from SIGSTOP. */ 2270 wpid = waitpid(fpid, &status, 0); 2271 ATF_REQUIRE(wpid == fpid); 2272 ATF_REQUIRE(WIFSTOPPED(status)); 2273 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2274 2275 len = sizeof(max_pending_per_proc); 2276 ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc", 2277 &max_pending_per_proc, &len, NULL, 0) == 0); 2278 2279 /* Fill the signal queue. */ 2280 for (i = 0; i < max_pending_per_proc; ++i) 2281 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2282 2283 /* Continue with signal. */ 2284 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2285 2286 for (;;) { 2287 wpid = waitpid(fpid, &status, 0); 2288 ATF_REQUIRE(wpid == fpid); 2289 if (WIFSTOPPED(status)) { 2290 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2291 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2292 } else { 2293 /* 2294 * The last wait() should report normal _exit from the 2295 * SIGUSR1 handler. 2296 */ 2297 ATF_REQUIRE(WIFEXITED(status)); 2298 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2299 break; 2300 } 2301 } 2302 2303 wpid = wait(&status); 2304 ATF_REQUIRE(wpid == -1); 2305 ATF_REQUIRE(errno == ECHILD); 2306} 2307 2308/* 2309 * Verify that, after stopping due to a signal, that signal can be 2310 * replaced with another signal. 2311 */ 2312ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_change_sig); 2313ATF_TC_BODY(ptrace__PT_CONTINUE_change_sig, tc) 2314{ 2315 struct ptrace_lwpinfo pl; 2316 pid_t fpid, wpid; 2317 int status; 2318 2319 ATF_REQUIRE((fpid = fork()) != -1); 2320 if (fpid == 0) { 2321 trace_me(); 2322 sleep(20); 2323 exit(1); 2324 } 2325 2326 /* The first wait() should report the stop from SIGSTOP. */ 2327 wpid = waitpid(fpid, &status, 0); 2328 ATF_REQUIRE(wpid == fpid); 2329 ATF_REQUIRE(WIFSTOPPED(status)); 2330 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2331 2332 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2333 2334 /* Send a signal without ptrace. */ 2335 ATF_REQUIRE(kill(fpid, SIGINT) == 0); 2336 2337 /* The second wait() should report a SIGINT was received. */ 2338 wpid = waitpid(fpid, &status, 0); 2339 ATF_REQUIRE(wpid == fpid); 2340 ATF_REQUIRE(WIFSTOPPED(status)); 2341 ATF_REQUIRE(WSTOPSIG(status) == SIGINT); 2342 2343 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2344 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 2345 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGINT); 2346 2347 /* Continue the child process with a different signal. */ 2348 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTERM) == 0); 2349 2350 /* 2351 * The last wait() should report having died due to the new 2352 * signal, SIGTERM. 2353 */ 2354 wpid = waitpid(fpid, &status, 0); 2355 ATF_REQUIRE(wpid == fpid); 2356 ATF_REQUIRE(WIFSIGNALED(status)); 2357 ATF_REQUIRE(WTERMSIG(status) == SIGTERM); 2358 2359 wpid = wait(&status); 2360 ATF_REQUIRE(wpid == -1); 2361 ATF_REQUIRE(errno == ECHILD); 2362} 2363 2364/* 2365 * Verify that a signal can be passed through to the child even when there 2366 * was no true signal originally. Such cases arise when a SIGTRAP is 2367 * invented for e.g, system call stops. 2368 */ 2369ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry); 2370ATF_TC_BODY(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry, tc) 2371{ 2372 struct ptrace_lwpinfo pl; 2373 pid_t fpid, wpid; 2374 int status; 2375 2376 ATF_REQUIRE((fpid = fork()) != -1); 2377 if (fpid == 0) { 2378 trace_me(); 2379 getpid(); 2380 exit(1); 2381 } 2382 2383 /* The first wait() should report the stop from SIGSTOP. */ 2384 wpid = waitpid(fpid, &status, 0); 2385 ATF_REQUIRE(wpid == fpid); 2386 ATF_REQUIRE(WIFSTOPPED(status)); 2387 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2388 2389 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2390 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2391 2392 /* The second wait() should report a system call entry for getpid(). */ 2393 wpid = waitpid(fpid, &status, 0); 2394 ATF_REQUIRE(wpid == fpid); 2395 ATF_REQUIRE(WIFSTOPPED(status)); 2396 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2397 2398 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2399 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2400 2401 /* Continue the child process with a SIGTRAP. */ 2402 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTRAP) == 0); 2403 2404 for (;;) { 2405 /* 2406 * The last wait() should report exit due to SIGTRAP. In the 2407 * meantime, catch and proceed past any syscall stops. 2408 */ 2409 wpid = waitpid(fpid, &status, 0); 2410 ATF_REQUIRE(wpid == fpid); 2411 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2412 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2413 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2414 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2415 } else { 2416 ATF_REQUIRE(WIFSIGNALED(status)); 2417 ATF_REQUIRE(WTERMSIG(status) == SIGTRAP); 2418 break; 2419 } 2420 } 2421 2422 wpid = wait(&status); 2423 ATF_REQUIRE(wpid == -1); 2424 ATF_REQUIRE(errno == ECHILD); 2425 2426} 2427 2428/* 2429 * A mixed bag PT_CONTINUE with signal test. 2430 */ 2431ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_mix); 2432ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_mix, tc) 2433{ 2434 struct ptrace_lwpinfo pl; 2435 pid_t fpid, wpid; 2436 int status; 2437 2438 ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR); 2439 2440 ATF_REQUIRE((fpid = fork()) != -1); 2441 if (fpid == 0) { 2442 trace_me(); 2443 getpid(); 2444 exit(1); 2445 } 2446 2447 /* The first wait() should report the stop from SIGSTOP. */ 2448 wpid = waitpid(fpid, &status, 0); 2449 ATF_REQUIRE(wpid == fpid); 2450 ATF_REQUIRE(WIFSTOPPED(status)); 2451 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2452 2453 /* Continue the child ignoring the SIGSTOP and tracing system calls. */ 2454 ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0); 2455 2456 /* The second wait() should report a system call entry for getpid(). */ 2457 wpid = waitpid(fpid, &status, 0); 2458 ATF_REQUIRE(wpid == fpid); 2459 ATF_REQUIRE(WIFSTOPPED(status)); 2460 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2461 2462 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2463 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE); 2464 2465 /* Continue with the first SIGUSR1. */ 2466 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2467 2468 /* The next wait() should report a system call exit for getpid(). */ 2469 wpid = waitpid(fpid, &status, 0); 2470 ATF_REQUIRE(wpid == fpid); 2471 ATF_REQUIRE(WIFSTOPPED(status)); 2472 ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP); 2473 2474 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2475 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX); 2476 2477 /* Send an ABRT without ptrace. */ 2478 ATF_REQUIRE(kill(fpid, SIGABRT) == 0); 2479 2480 /* Continue normally. */ 2481 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2482 2483 /* The next wait() should report the SIGABRT. */ 2484 wpid = waitpid(fpid, &status, 0); 2485 ATF_REQUIRE(wpid == fpid); 2486 ATF_REQUIRE(WIFSTOPPED(status)); 2487 ATF_REQUIRE(WSTOPSIG(status) == SIGABRT); 2488 2489 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2490 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 2491 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT); 2492 2493 /* Continue, replacing the SIGABRT with another SIGUSR1. */ 2494 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2495 2496 for (;;) { 2497 /* 2498 * The last wait() should report exit 2, i.e., a normal _exit 2499 * from the signal handler. In the meantime, catch and proceed 2500 * past any syscall stops. 2501 */ 2502 wpid = waitpid(fpid, &status, 0); 2503 ATF_REQUIRE(wpid == fpid); 2504 if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { 2505 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2506 ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)); 2507 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2508 } else { 2509 ATF_REQUIRE(WIFEXITED(status)); 2510 ATF_REQUIRE(WEXITSTATUS(status) == 2); 2511 break; 2512 } 2513 } 2514 2515 wpid = wait(&status); 2516 ATF_REQUIRE(wpid == -1); 2517 ATF_REQUIRE(errno == ECHILD); 2518 2519} 2520 2521/* 2522 * Verify a signal delivered by ptrace is noticed by kevent(2). 2523 */ 2524ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_kqueue); 2525ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_kqueue, tc) 2526{ 2527 pid_t fpid, wpid; 2528 int status, kq, nevents; 2529 struct kevent kev; 2530 2531 ATF_REQUIRE(signal(SIGUSR1, SIG_IGN) != SIG_ERR); 2532 2533 ATF_REQUIRE((fpid = fork()) != -1); 2534 if (fpid == 0) { 2535 CHILD_REQUIRE((kq = kqueue()) > 0); 2536 EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_ADD, 0, 0, 0); 2537 CHILD_REQUIRE(kevent(kq, &kev, 1, NULL, 0, NULL) == 0); 2538 2539 trace_me(); 2540 2541 for (;;) { 2542 nevents = kevent(kq, NULL, 0, &kev, 1, NULL); 2543 if (nevents == -1 && errno == EINTR) 2544 continue; 2545 CHILD_REQUIRE(nevents > 0); 2546 CHILD_REQUIRE(kev.filter == EVFILT_SIGNAL); 2547 CHILD_REQUIRE(kev.ident == SIGUSR1); 2548 break; 2549 } 2550 2551 exit(1); 2552 } 2553 2554 /* The first wait() should report the stop from SIGSTOP. */ 2555 wpid = waitpid(fpid, &status, 0); 2556 ATF_REQUIRE(wpid == fpid); 2557 ATF_REQUIRE(WIFSTOPPED(status)); 2558 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2559 2560 /* Continue with the SIGUSR1. */ 2561 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2562 2563 /* 2564 * The last wait() should report normal exit with code 1. 2565 */ 2566 wpid = waitpid(fpid, &status, 0); 2567 ATF_REQUIRE(wpid == fpid); 2568 ATF_REQUIRE(WIFEXITED(status)); 2569 ATF_REQUIRE(WEXITSTATUS(status) == 1); 2570 2571 wpid = wait(&status); 2572 ATF_REQUIRE(wpid == -1); 2573 ATF_REQUIRE(errno == ECHILD); 2574} 2575 2576static sem_t sigusr1_sem; 2577 2578static void 2579sigusr1_sempost_handler(int sig __unused) 2580{ 2581 2582 CHILD_REQUIRE(sem_post(&sigusr1_sem) == 0); 2583} 2584 2585static void * 2586signal_thread(void *arg) 2587{ 2588 int err; 2589 sigset_t sigmask; 2590 2591 pthread_barrier_t *pbarrier = (pthread_barrier_t*)arg; 2592 2593 /* Wait for this thread to receive a SIGUSR1. */ 2594 do { 2595 err = sem_wait(&sigusr1_sem); 2596 CHILD_REQUIRE(err == 0 || errno == EINTR); 2597 } while (err != 0 && errno == EINTR); 2598 2599 /* Free our companion thread from the barrier. */ 2600 pthread_barrier_wait(pbarrier); 2601 2602 /* 2603 * Swap ignore duties; the next SIGUSR1 should go to the 2604 * other thread. 2605 */ 2606 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 2607 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 2608 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 2609 2610 /* Sync up threads after swapping signal masks. */ 2611 pthread_barrier_wait(pbarrier); 2612 2613 /* Wait until our companion has received its SIGUSR1. */ 2614 pthread_barrier_wait(pbarrier); 2615 2616 return (NULL); 2617} 2618 2619/* 2620 * Verify that if ptrace stops due to a signal but continues with 2621 * a different signal that the new signal is routed to a thread 2622 * that can accept it, and that that thread is awakened by the signal 2623 * in a timely manner. 2624 */ 2625ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_thread_sigmask); 2626ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_thread_sigmask, tc) 2627{ 2628 pid_t fpid, wpid; 2629 int status, err; 2630 pthread_t t; 2631 sigset_t sigmask; 2632 pthread_barrier_t barrier; 2633 2634 ATF_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0); 2635 ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0); 2636 ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR); 2637 2638 ATF_REQUIRE((fpid = fork()) != -1); 2639 if (fpid == 0) { 2640 CHILD_REQUIRE(pthread_create(&t, NULL, signal_thread, (void*)&barrier) == 0); 2641 2642 /* The other thread should receive the first SIGUSR1. */ 2643 CHILD_REQUIRE(sigemptyset(&sigmask) == 0); 2644 CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0); 2645 CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0); 2646 2647 trace_me(); 2648 2649 /* Wait until other thread has received its SIGUSR1. */ 2650 pthread_barrier_wait(&barrier); 2651 2652 /* 2653 * Swap ignore duties; the next SIGUSR1 should go to this 2654 * thread. 2655 */ 2656 CHILD_REQUIRE(pthread_sigmask(SIG_UNBLOCK, &sigmask, NULL) == 0); 2657 2658 /* Sync up threads after swapping signal masks. */ 2659 pthread_barrier_wait(&barrier); 2660 2661 /* 2662 * Sync up with test code; we're ready for the next SIGUSR1 2663 * now. 2664 */ 2665 raise(SIGSTOP); 2666 2667 /* Wait for this thread to receive a SIGUSR1. */ 2668 do { 2669 err = sem_wait(&sigusr1_sem); 2670 CHILD_REQUIRE(err == 0 || errno == EINTR); 2671 } while (err != 0 && errno == EINTR); 2672 2673 /* Free the other thread from the barrier. */ 2674 pthread_barrier_wait(&barrier); 2675 2676 CHILD_REQUIRE(pthread_join(t, NULL) == 0); 2677 2678 exit(1); 2679 } 2680 2681 /* The first wait() should report the stop from SIGSTOP. */ 2682 wpid = waitpid(fpid, &status, 0); 2683 ATF_REQUIRE(wpid == fpid); 2684 ATF_REQUIRE(WIFSTOPPED(status)); 2685 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2686 2687 /* Continue the child ignoring the SIGSTOP. */ 2688 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2689 2690 /* 2691 * Send a signal without ptrace that either thread will accept (USR2, 2692 * in this case). 2693 */ 2694 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2695 2696 /* The second wait() should report a SIGUSR2 was received. */ 2697 wpid = waitpid(fpid, &status, 0); 2698 ATF_REQUIRE(wpid == fpid); 2699 ATF_REQUIRE(WIFSTOPPED(status)); 2700 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2701 2702 /* Continue the child, changing the signal to USR1. */ 2703 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2704 2705 /* The next wait() should report the stop from SIGSTOP. */ 2706 wpid = waitpid(fpid, &status, 0); 2707 ATF_REQUIRE(wpid == fpid); 2708 ATF_REQUIRE(WIFSTOPPED(status)); 2709 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2710 2711 /* Continue the child ignoring the SIGSTOP. */ 2712 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2713 2714 ATF_REQUIRE(kill(fpid, SIGUSR2) == 0); 2715 2716 /* The next wait() should report a SIGUSR2 was received. */ 2717 wpid = waitpid(fpid, &status, 0); 2718 ATF_REQUIRE(wpid == fpid); 2719 ATF_REQUIRE(WIFSTOPPED(status)); 2720 ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2); 2721 2722 /* Continue the child, changing the signal to USR1. */ 2723 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0); 2724 2725 /* The last wait() should report normal exit with code 1. */ 2726 wpid = waitpid(fpid, &status, 0); 2727 ATF_REQUIRE(wpid == fpid); 2728 ATF_REQUIRE(WIFEXITED(status)); 2729 ATF_REQUIRE(WEXITSTATUS(status) == 1); 2730 2731 wpid = wait(&status); 2732 ATF_REQUIRE(wpid == -1); 2733 ATF_REQUIRE(errno == ECHILD); 2734} 2735 2736static void * 2737raise_sigstop_thread(void *arg __unused) 2738{ 2739 2740 raise(SIGSTOP); 2741 return NULL; 2742} 2743 2744static void * 2745sleep_thread(void *arg __unused) 2746{ 2747 2748 sleep(60); 2749 return NULL; 2750} 2751 2752static void 2753terminate_with_pending_sigstop(bool sigstop_from_main_thread) 2754{ 2755 pid_t fpid, wpid; 2756 int status, i; 2757 cpuset_t setmask; 2758 cpusetid_t setid; 2759 pthread_t t; 2760 2761 /* 2762 * Become the reaper for this process tree. We need to be able to check 2763 * that both child and grandchild have died. 2764 */ 2765 ATF_REQUIRE(procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0); 2766 2767 fpid = fork(); 2768 ATF_REQUIRE(fpid >= 0); 2769 if (fpid == 0) { 2770 fpid = fork(); 2771 CHILD_REQUIRE(fpid >= 0); 2772 if (fpid == 0) { 2773 trace_me(); 2774 2775 /* Pin to CPU 0 to serialize thread execution. */ 2776 CPU_ZERO(&setmask); 2777 CPU_SET(0, &setmask); 2778 CHILD_REQUIRE(cpuset(&setid) == 0); 2779 CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET, 2780 CPU_WHICH_CPUSET, setid, 2781 sizeof(setmask), &setmask) == 0); 2782 2783 if (sigstop_from_main_thread) { 2784 /* 2785 * We expect the SIGKILL sent when our parent 2786 * dies to be delivered to the new thread. 2787 * Raise the SIGSTOP in this thread so the 2788 * threads compete. 2789 */ 2790 CHILD_REQUIRE(pthread_create(&t, NULL, 2791 sleep_thread, NULL) == 0); 2792 raise(SIGSTOP); 2793 } else { 2794 /* 2795 * We expect the SIGKILL to be delivered to 2796 * this thread. After creating the new thread, 2797 * just get off the CPU so the other thread can 2798 * raise the SIGSTOP. 2799 */ 2800 CHILD_REQUIRE(pthread_create(&t, NULL, 2801 raise_sigstop_thread, NULL) == 0); 2802 sleep(60); 2803 } 2804 2805 exit(0); 2806 } 2807 /* First stop is trace_me() immediately after fork. */ 2808 wpid = waitpid(fpid, &status, 0); 2809 CHILD_REQUIRE(wpid == fpid); 2810 CHILD_REQUIRE(WIFSTOPPED(status)); 2811 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2812 2813 CHILD_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2814 2815 /* Second stop is from the raise(SIGSTOP). */ 2816 wpid = waitpid(fpid, &status, 0); 2817 CHILD_REQUIRE(wpid == fpid); 2818 CHILD_REQUIRE(WIFSTOPPED(status)); 2819 CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2820 2821 /* 2822 * Terminate tracing process without detaching. Our child 2823 * should be killed. 2824 */ 2825 exit(0); 2826 } 2827 2828 /* 2829 * We should get a normal exit from our immediate child and a SIGKILL 2830 * exit from our grandchild. The latter case is the interesting one. 2831 * Our grandchild should not have stopped due to the SIGSTOP that was 2832 * left dangling when its parent died. 2833 */ 2834 for (i = 0; i < 2; ++i) { 2835 wpid = wait(&status); 2836 if (wpid == fpid) 2837 ATF_REQUIRE(WIFEXITED(status) && 2838 WEXITSTATUS(status) == 0); 2839 else 2840 ATF_REQUIRE(WIFSIGNALED(status) && 2841 WTERMSIG(status) == SIGKILL); 2842 } 2843} 2844 2845/* 2846 * These two tests ensure that if the tracing process exits without detaching 2847 * just after the child received a SIGSTOP, the child is cleanly killed and 2848 * doesn't go to sleep due to the SIGSTOP. The parent's death will send a 2849 * SIGKILL to the child. If the SIGKILL and the SIGSTOP are handled by 2850 * different threads, the SIGKILL must win. There are two variants of this 2851 * test, designed to catch the case where the SIGKILL is delivered to the 2852 * younger thread (the first test) and the case where the SIGKILL is delivered 2853 * to the older thread (the second test). This behavior has changed in the 2854 * past, so make no assumption. 2855 */ 2856ATF_TC_WITHOUT_HEAD(ptrace__parent_terminate_with_pending_sigstop1); 2857ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop1, tc) 2858{ 2859 2860 terminate_with_pending_sigstop(true); 2861} 2862ATF_TC_WITHOUT_HEAD(ptrace__parent_terminate_with_pending_sigstop2); 2863ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop2, tc) 2864{ 2865 2866 terminate_with_pending_sigstop(false); 2867} 2868 2869/* 2870 * Verify that after ptrace() discards a SIGKILL signal, the event mask 2871 * is not modified. 2872 */ 2873ATF_TC_WITHOUT_HEAD(ptrace__event_mask_sigkill_discard); 2874ATF_TC_BODY(ptrace__event_mask_sigkill_discard, tc) 2875{ 2876 struct ptrace_lwpinfo pl; 2877 pid_t fpid, wpid; 2878 int status, event_mask, new_event_mask; 2879 2880 ATF_REQUIRE((fpid = fork()) != -1); 2881 if (fpid == 0) { 2882 trace_me(); 2883 raise(SIGSTOP); 2884 exit(0); 2885 } 2886 2887 /* The first wait() should report the stop from trace_me(). */ 2888 wpid = waitpid(fpid, &status, 0); 2889 ATF_REQUIRE(wpid == fpid); 2890 ATF_REQUIRE(WIFSTOPPED(status)); 2891 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2892 2893 /* Set several unobtrusive event bits. */ 2894 event_mask = PTRACE_EXEC | PTRACE_FORK | PTRACE_LWP; 2895 ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, wpid, (caddr_t)&event_mask, 2896 sizeof(event_mask)) == 0); 2897 2898 /* Send a SIGKILL without using ptrace. */ 2899 ATF_REQUIRE(kill(fpid, SIGKILL) == 0); 2900 2901 /* Continue the child ignoring the SIGSTOP. */ 2902 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2903 2904 /* The next stop should be due to the SIGKILL. */ 2905 wpid = waitpid(fpid, &status, 0); 2906 ATF_REQUIRE(wpid == fpid); 2907 ATF_REQUIRE(WIFSTOPPED(status)); 2908 ATF_REQUIRE(WSTOPSIG(status) == SIGKILL); 2909 2910 ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1); 2911 ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI); 2912 ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGKILL); 2913 2914 /* Continue the child ignoring the SIGKILL. */ 2915 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2916 2917 /* The next wait() should report the stop from SIGSTOP. */ 2918 wpid = waitpid(fpid, &status, 0); 2919 ATF_REQUIRE(wpid == fpid); 2920 ATF_REQUIRE(WIFSTOPPED(status)); 2921 ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP); 2922 2923 /* Check the current event mask. It should not have changed. */ 2924 new_event_mask = 0; 2925 ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, wpid, (caddr_t)&new_event_mask, 2926 sizeof(new_event_mask)) == 0); 2927 ATF_REQUIRE(event_mask == new_event_mask); 2928 2929 /* Continue the child to let it exit. */ 2930 ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0); 2931 2932 /* The last event should be for the child process's exit. */ 2933 wpid = waitpid(fpid, &status, 0); 2934 ATF_REQUIRE(WIFEXITED(status)); 2935 ATF_REQUIRE(WEXITSTATUS(status) == 0); 2936 2937 wpid = wait(&status); 2938 ATF_REQUIRE(wpid == -1); 2939 ATF_REQUIRE(errno == ECHILD); 2940} 2941 2942ATF_TP_ADD_TCS(tp) 2943{ 2944 2945 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_trace_me); 2946 ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_attach); 2947 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_child_debugger); 2948 ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_unrelated_debugger); 2949 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached); 2950 ATF_TP_ADD_TC(tp, ptrace__follow_fork_child_detached); 2951 ATF_TP_ADD_TC(tp, ptrace__follow_fork_parent_detached); 2952 ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached_unrelated_debugger); 2953 ATF_TP_ADD_TC(tp, 2954 ptrace__follow_fork_child_detached_unrelated_debugger); 2955 ATF_TP_ADD_TC(tp, 2956 ptrace__follow_fork_parent_detached_unrelated_debugger); 2957 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_fork); 2958 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_vfork); 2959 ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_thread); 2960 ATF_TP_ADD_TC(tp, ptrace__lwp_events); 2961 ATF_TP_ADD_TC(tp, ptrace__lwp_events_exec); 2962 ATF_TP_ADD_TC(tp, ptrace__siginfo); 2963 ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_disable); 2964 ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_enable); 2965 ATF_TP_ADD_TC(tp, ptrace__event_mask); 2966 ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork); 2967 ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork_follow); 2968#if defined(__amd64__) || defined(__i386__) || defined(__sparc64__) 2969 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_breakpoint); 2970#endif 2971 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_system_call); 2972 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_threads); 2973 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_signal); 2974 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_stop); 2975 ATF_TP_ADD_TC(tp, ptrace__PT_KILL_with_signal_full_sigqueue); 2976 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_system_call_entry); 2977 ATF_TP_ADD_TC(tp, 2978 ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit); 2979 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_full_sigqueue); 2980 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_change_sig); 2981 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_sigtrap_system_call_entry); 2982 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_mix); 2983 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_kqueue); 2984 ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_thread_sigmask); 2985 ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop1); 2986 ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop2); 2987 ATF_TP_ADD_TC(tp, ptrace__event_mask_sigkill_discard); 2988 2989 return (atf_no_error()); 2990} 2991