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