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