tests/sys/kern/ptrace_test.c

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