tests/sys/kern/ptrace_test.c

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