test/test42.c

   1 /* Tests for MINIX3 ptrace(2) - by D.C. van Moolenbroek */
   2 #include <setjmp.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <signal.h>
   7 #include <unistd.h>
   8 #include <errno.h>
   9 #include <sys/wait.h>
  10 #include <sys/select.h>
  11 #include <sys/ptrace.h>
  12 #include <sys/syslimits.h>
  13
  14 #define ITERATIONS 3
  15 int max_error = 4;
  16 #include "common.h"
  17
  18 #define my_e(n) { \
  19         if (child) exit(n); printf("Attach type %d, ", attach); e(n); }
  20
  21
  22 #define _WIFSTOPPED(s) (WIFSTOPPED(s) && !WIFSIGNALED(s) && !WIFEXITED(s))
  23 #define _WIFSIGNALED(s) (!WIFSTOPPED(s) && WIFSIGNALED(s) && !WIFEXITED(s))
  24 #define _WIFEXITED(s) (!WIFSTOPPED(s) && !WIFSIGNALED(s) && WIFEXITED(s))
  25
  26 #define timed_test(func) (timed_test_func(#func, func));
  27
  28 int main(int argc, char **argv);
  29 void test(int m, int a);
  30 void timed_test_func(const char *s, void (* func)(void));
  31 void timed_test_timeout(int signum);
  32 pid_t traced_fork(void (*c) (void));
  33 pid_t traced_pfork(void (*c) (void));
  34 void WRITE(int value);
  35 int READ(void);
  36 void traced_wait(void);
  37 void detach_running(pid_t pid);
  38 void dummy_handler(int sig);
  39 void exit_handler(int sig);
  40 void count_handler(int sig);
  41 void catch_handler(int sig);
  42 void test_wait_child(void);
  43 void test_wait(void);
  44 void test_exec_child(void);
  45 void test_exec(void);
  46 void test_step_child(void);
  47 void test_step(void);
  48 void test_sig_child(void);
  49 void test_sig(void);
  50 void test_exit_child(void);
  51 void test_exit(void);
  52 void test_term_child(void);
  53 void test_term(void);
  54 void test_catch_child(void);
  55 void test_catch(void);
  56 void test_kill_child(void);
  57 void test_kill(void);
  58 void test_attach_child(void);
  59 void test_attach(void);
  60 void test_detach_child(void);
  61 void test_detach(void);
  62 void test_death_child(void);
  63 void test_death(void);
  64 void test_zdeath_child(void);
  65 void test_zdeath(void);
  66 void test_syscall_child(void);
  67 void test_syscall(void);
  68 void test_tracefork_child(void);
  69 void test_tracefork(void);
  70 void sigexec(int setflag, int opt, int *traps, int *stop);
  71 void test_trapexec(void);
  72 void test_altexec(void);
  73 void test_noexec(void);
  74 void test_defexec(void);
  75 void test_reattach_child(void);
  76 void test_reattach(void);
  77
  78 static char *executable;
  79 static int child = 0, attach;
  80 static pid_t ppid;
  81 static int pfd[4];
  82 static int sigs, caught;
  83
  84 int main(argc, argv)
  85 int argc;
  86 char **argv;
  87 {
  88   int i, m = 0xFFFFFF, n = 0xF;
  89   char cp_cmd[NAME_MAX + 10];
  90
  91   if (strcmp(argv[0], "DO CHECK") == 0) {
  92         exit(42);
  93   }
  94
  95   start(42);
  96
  97   executable = argv[0];
  98
  99   snprintf(cp_cmd, sizeof(cp_cmd), "cp ../%s .", executable);
 100   system(cp_cmd);
 101
 102   if (argc >= 2) m = atoi(argv[1]);
 103   if (argc >= 3) n = atoi(argv[2]);
 104
 105   for (i = 0; i < ITERATIONS; i++) {
 106         if (n & 001) test(m, 0);
 107         if (n & 002) test(m, 1);
 108         if (n & 004) test(m, 2);
 109         if (n & 010) test(m, 3);
 110   }
 111
 112   quit();
 113   return(-1);                   /* impossible */
 114 }
 115
 116 void test(m, a)
 117 int m;
 118 int a;
 119 {
 120   attach = a;
 121
 122   if (m & 00000001) timed_test(test_wait);
 123   if (m & 00000002) timed_test(test_exec);
 124 #if !defined(__arm__)
 125   /* BJG: single-stepping isn't implemented on ARM */
 126   if (m & 00000004) timed_test(test_step);
 127 #endif
 128   if (m & 00000010) timed_test(test_sig);
 129   if (m & 00000020) timed_test(test_exit);
 130   if (m & 00000040) timed_test(test_term);
 131   if (m & 00000100) timed_test(test_catch);
 132   if (m & 00000200) timed_test(test_kill);
 133   if (m & 00000400) timed_test(test_attach);
 134   if (m & 00001000) timed_test(test_detach);
 135   if (m & 00002000) timed_test(test_death);
 136   if (m & 00004000) timed_test(test_zdeath);
 137   if (m & 00010000) timed_test(test_syscall);
 138   if (m & 00020000) timed_test(test_tracefork);
 139   if (m & 00040000) timed_test(test_trapexec);
 140   if (m & 00100000) timed_test(test_altexec);
 141   if (m & 00200000) timed_test(test_noexec);
 142   if (m & 00400000) timed_test(test_defexec);
 143   if (m & 01000000) test_reattach(); /* not timed, catches SIGALRM */
 144 }
 145
 146 static jmp_buf timed_test_context;
 147
 148 void timed_test_timeout(int signum)
 149 {
 150   longjmp(timed_test_context, -1);
 151   my_e(700);
 152   quit();
 153   exit(-1);
 154 }
 155
 156 void timed_test_func(const char *s, void (* func)(void))
 157 {
 158   if (setjmp(timed_test_context) == 0)
 159   {
 160     /* the function gets 60 seconds to complete */
 161     if (signal(SIGALRM, timed_test_timeout) == SIG_ERR) { my_e(701); return; }
 162     alarm(60);
 163     func();
 164     alarm(0);
 165   }
 166   else
 167   {
 168     /* report timeout as error */
 169     printf("timeout in %s\n", s);
 170     my_e(702);
 171   }
 172 }
 173
 174 pid_t traced_fork(c)
 175 void(*c) (void);
 176 {
 177   pid_t pid;
 178   int r, status;
 179
 180   if (pipe(pfd) != 0) my_e(200);
 181   if (pipe(&pfd[2]) != 0) my_e(201);
 182
 183   switch (attach) {
 184   case 0:                       /* let child volunteer to be traced */
 185         pid = fork();
 186
 187         if (pid < 0) my_e(202);
 188
 189         if (pid == 0) {
 190                 child = 1;
 191
 192                 if (ptrace(T_OK, 0, 0, 0) != 0) my_e(203);
 193
 194                 WRITE(0);
 195
 196                 c();
 197
 198                 my_e(204);
 199         }
 200
 201         if (READ() != 0) my_e(205);
 202
 203         break;
 204
 205   case 1:                       /* attach to child process */
 206         pid = fork();
 207
 208         if (pid < 0) my_e(206);
 209
 210         if (pid == 0) {
 211                 child = 1;
 212
 213                 if (READ() != 0) my_e(207);
 214
 215                 c();
 216
 217                 my_e(208);
 218         }
 219
 220         if (ptrace(T_ATTACH, pid, 0, 0) != 0) my_e(209);
 221
 222         if (waitpid(pid, &status, 0) != pid) my_e(210);
 223         if (!_WIFSTOPPED(status)) my_e(211);
 224         if (WSTOPSIG(status) != SIGSTOP) my_e(212);
 225
 226         if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(213);
 227
 228         WRITE(0);
 229
 230         break;
 231
 232   case 2:                       /* attach to non-child process */
 233         ppid = fork();
 234
 235         if (ppid < 0) my_e(214);
 236
 237         if (ppid == 0) {
 238                 pid = fork();
 239
 240                 if (pid < 0) exit(215);
 241
 242                 if (pid == 0) {
 243                         child = 1;
 244
 245                         if (READ() != 0) my_e(216);
 246
 247                         c();
 248
 249                         my_e(217);
 250                 }
 251
 252                 child = 1;
 253
 254                 WRITE(pid);
 255
 256                 if (waitpid(pid, &status, 0) != pid) my_e(218);
 257                 if (_WIFSTOPPED(status)) my_e(219);
 258                 if (_WIFEXITED(status) && (r = WEXITSTATUS(status)) != 42) my_e(r);
 259
 260                 exit(0);
 261         }
 262
 263         pid = READ();
 264
 265         if (ptrace(T_ATTACH, pid, 0, 0) != 0) my_e(220);
 266
 267         if (waitpid(pid, &status, 0) != pid) my_e(221);
 268         if (!_WIFSTOPPED(status)) my_e(222);
 269         if (WSTOPSIG(status) != SIGSTOP) my_e(223);
 270
 271         if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(224);
 272
 273         WRITE(0);
 274
 275         break;
 276
 277   case 3:                       /* attach by forking from child */
 278         ppid = fork();
 279
 280         if (ppid < 0) my_e(225);
 281
 282         if (ppid == 0) {
 283                 child = 1;
 284
 285                 if (ptrace(T_OK, 0, 0, 0) != 0) my_e(226);
 286
 287                 WRITE(0);
 288
 289                 if (READ() != 0) my_e(227);
 290
 291                 pid = fork();
 292
 293                 if (pid < 0) my_e(228);
 294
 295                 if (pid == 0) {
 296                         c();
 297
 298                         my_e(229);
 299                 }
 300
 301                 WRITE(pid);
 302
 303                 if (waitpid(pid, &status, 0) != pid) my_e(230);
 304                 if (_WIFSTOPPED(status)) my_e(231);
 305                 if (_WIFEXITED(status) && (r = WEXITSTATUS(status)) != 42) my_e(r);
 306
 307                 exit(0);
 308         }
 309
 310         if (READ() != 0) my_e(232);
 311
 312         if (kill(ppid, SIGSTOP) != 0) my_e(233);
 313
 314         if (waitpid(ppid, &status, 0) != ppid) my_e(234);
 315         if (!_WIFSTOPPED(status)) my_e(235);
 316         if (WSTOPSIG(status) != SIGSTOP) my_e(236);
 317
 318         if (ptrace(T_SETOPT, ppid, 0, TO_TRACEFORK) != 0) my_e(237);
 319
 320         if (ptrace(T_RESUME, ppid, 0, 0) != 0) my_e(238);
 321
 322         WRITE(0);
 323
 324         pid = READ();
 325
 326         if (waitpid(pid, &status, 0) != pid) my_e(239);
 327         if (!_WIFSTOPPED(status)) my_e(240);
 328         if (WSTOPSIG(status) != SIGSTOP) my_e(241);
 329
 330         if (ptrace(T_SETOPT, pid, 0, 0) != 0) my_e(242);
 331         if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(243);
 332
 333         detach_running(ppid);
 334
 335         break;
 336   }
 337
 338   return pid;
 339 }
 340
 341 pid_t traced_pfork(c)
 342 void(*c) (void);
 343 {
 344   pid_t pid;
 345
 346   if (pipe(pfd) != 0) my_e(300);
 347   if (pipe(&pfd[2]) != 0) my_e(301);
 348
 349   pid = fork();
 350
 351   if (pid < 0) my_e(302);
 352
 353   if (pid == 0) {
 354         child = 1;
 355
 356         c();
 357
 358         my_e(303);
 359   }
 360
 361   return pid;
 362 }
 363
 364 void WRITE(value)
 365 int value;
 366 {
 367   if (write(pfd[child*2+1], &value, sizeof(value)) != sizeof(value)) my_e(400);
 368 }
 369
 370 int READ()
 371 {
 372   int value;
 373
 374   if (read(pfd[2-child*2], &value, sizeof(value)) != sizeof(value)) my_e(401);
 375
 376   return value;
 377 }
 378
 379 void traced_wait()
 380 {
 381   int r, status;
 382
 383   if (attach == 2) {
 384         if (waitpid(ppid, &status, 0) != ppid) my_e(500);
 385         if (!_WIFEXITED(status)) my_e(501);
 386         if ((r = WEXITSTATUS(status)) != 0) my_e(r);
 387   }
 388   else {
 389         /* Quick hack to clean up detached children */
 390         waitpid(-1, NULL, WNOHANG);
 391   }
 392
 393   close(pfd[0]);
 394   close(pfd[1]);
 395   close(pfd[2]);
 396   close(pfd[3]);
 397 }
 398
 399 void detach_running(pid)
 400 pid_t pid;
 401 {
 402 /* Detach from a process that is not already stopped. This is the way to do it.
 403  * We have to stop the child in order to detach from it, but as the child may
 404  * have other signals pending for the tracer, we cannot assume we get our own
 405  * signal back immediately. However, because we know that the kill is instant
 406  * and resuming with pending signals will only stop the process immediately
 407  * again, we can use T_RESUME for all the signals until we get our own signal,
 408  * and then detach. A complicating factor is that anywhere during this
 409  * procedure, the child may die (e.g. by getting a SIGKILL). In our tests, this
 410  * will not happen.
 411  */
 412   int status;
 413
 414   if (kill(pid, SIGSTOP) != 0) my_e(600);
 415
 416   if (waitpid(pid, &status, 0) != pid) my_e(601);
 417
 418   while (_WIFSTOPPED(status)) {
 419         if (WSTOPSIG(status) == SIGSTOP) {
 420                 if (ptrace(T_DETACH, pid, 0, 0) != 0) my_e(602);
 421
 422                 return;
 423         }
 424
 425         if (ptrace(T_RESUME, pid, 0, WSTOPSIG(status)) != 0) my_e(603);
 426
 427         if (waitpid(pid, &status, 0) != pid) my_e(604);
 428   }
 429
 430   /* Apparently the process exited. */
 431   if (!_WIFEXITED(status) && !_WIFSIGNALED(status)) my_e(605);
 432
 433   /* In our tests, that should not happen. */
 434   my_e(606);
 435 }
 436
 437 void dummy_handler(sig)
 438 int sig;
 439 {
 440 }
 441
 442 void exit_handler(sig)
 443 int sig;
 444 {
 445   exit(42);
 446 }
 447
 448 void count_handler(sig)
 449 int sig;
 450 {
 451   sigs++;
 452 }
 453
 454 void catch_handler(sig)
 455 int sig;
 456 {
 457   sigset_t set;
 458   int bit;
 459
 460   switch (sig) {
 461   case SIGUSR1: bit = 1; break;
 462   case SIGUSR2: bit = 2; break;
 463   case SIGTERM: bit = 4; break;
 464   default: my_e(100);
 465   }
 466
 467   sigfillset(&set);
 468   sigprocmask(SIG_SETMASK, &set, NULL);
 469
 470   if (caught & bit) my_e(101);
 471   caught |= bit;
 472 }
 473
 474 void test_wait_child()
 475 {
 476   exit(42);
 477 }
 478
 479 void test_wait()
 480 {
 481   pid_t pid;
 482   int status;
 483
 484   subtest = 1;
 485
 486   pid = traced_fork(test_wait_child);
 487
 488   if (waitpid(pid, &status, 0) != pid) my_e(1);
 489   if (!_WIFEXITED(status)) my_e(2);
 490   if (WEXITSTATUS(status) != 42) my_e(3);
 491
 492   traced_wait();
 493 }
 494
 495 void test_exec_child()
 496 {
 497   if (READ() != 0) my_e(100);
 498
 499   execl(executable, "DO CHECK", NULL);
 500
 501   my_e(101);
 502 }
 503
 504 void test_exec()
 505 {
 506   pid_t pid;
 507   int r, status;
 508
 509   /* This test covers the T_OK case. */
 510   if (attach != 0) return;
 511
 512   subtest = 2;
 513
 514   pid = traced_fork(test_exec_child);
 515
 516   WRITE(0);
 517
 518   /* An exec() should result in a trap signal. */
 519   if (waitpid(pid, &status, 0) != pid) my_e(1);
 520   if (!_WIFSTOPPED(status)) my_e(2);
 521   if (WSTOPSIG(status) != SIGTRAP) my_e(3);
 522
 523   if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(4);
 524
 525   if (waitpid(pid, &status, 0) != pid) my_e(5);
 526   if (!_WIFEXITED(status)) my_e(6);
 527   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
 528
 529   traced_wait();
 530 }
 531
 532 void test_step_child()
 533 {
 534   sigset_t set;
 535
 536   signal(SIGUSR1, SIG_IGN);
 537
 538   WRITE(0);
 539
 540   if (READ() != 0) my_e(100);
 541
 542   /* It must not be possible for the child to stop the single-step signal. */
 543   signal(SIGTRAP, SIG_IGN);
 544   sigfillset(&set);
 545   sigprocmask(SIG_SETMASK, &set, NULL);
 546
 547   exit(42);
 548 }
 549
 550 void test_step()
 551 {
 552   pid_t pid;
 553   int r, status, count;
 554
 555   subtest = 3;
 556
 557   pid = traced_fork(test_step_child);
 558
 559   if (READ() != 0) my_e(1);
 560
 561   /* While the child is running, neither waitpid() nor ptrace() should work. */
 562   if (waitpid(pid, &status, WNOHANG) != 0) my_e(2);
 563   if (ptrace(T_RESUME, pid, 0, 0) != -1) my_e(3);
 564   if (errno != EBUSY) my_e(4);
 565
 566   if (kill(pid, SIGUSR1) != 0) my_e(5);
 567
 568   WRITE(0);
 569
 570   /* A kill() signal (other than SIGKILL) should be delivered to the tracer. */
 571   if (waitpid(pid, &status, 0) != pid) my_e(6);
 572   if (!_WIFSTOPPED(status)) my_e(7);
 573   if (WSTOPSIG(status) != SIGUSR1) my_e(8);
 574
 575   /* ptrace(T_STEP) should result in instruction-wise progress. */
 576   for (count = 0; ; count++) {
 577         if (ptrace(T_STEP, pid, 0, 0) != 0) my_e(9);
 578
 579         if (waitpid(pid, &status, 0) != pid) my_e(10);
 580         if (_WIFEXITED(status)) break;
 581         if (!_WIFSTOPPED(status)) my_e(11);
 582         if (WSTOPSIG(status) != SIGTRAP) my_e(12);
 583   }
 584
 585   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
 586
 587   if (count < 10) my_e(13); /* in practice: hundreds */
 588
 589   traced_wait();
 590 }
 591
 592 void test_sig_child()
 593 {
 594   signal(SIGUSR1, exit_handler);
 595
 596   if (READ() != 0) my_e(100);
 597
 598   pause();
 599
 600   my_e(101);
 601 }
 602
 603 void test_sig()
 604 {
 605   pid_t pid;
 606   int r, sig, status;
 607
 608   subtest = 4;
 609
 610   pid = traced_fork(test_sig_child);
 611
 612   WRITE(0);
 613
 614   /* allow the child to enter the pause */
 615   sleep(1);
 616
 617   if (kill(pid, SIGUSR1) != 0) my_e(1);
 618   if (kill(pid, SIGUSR2) != 0) my_e(2);
 619
 620   /* All signals should arrive at the tracer, although in "random" order. */
 621   if (waitpid(pid, &status, 0) != pid) my_e(3);
 622   if (!_WIFSTOPPED(status)) my_e(4);
 623   if (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGUSR2) my_e(5);
 624
 625   /* The tracer should see kills arriving while the tracee is stopped. */
 626   if (kill(pid, WSTOPSIG(status)) != 0) my_e(6);
 627
 628   if (waitpid(pid, &status, WNOHANG) != pid) my_e(7);
 629   if (!_WIFSTOPPED(status)) my_e(8);
 630   if (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGUSR2) my_e(9);
 631   sig = (WSTOPSIG(status) == SIGUSR1) ? SIGUSR2 : SIGUSR1;
 632
 633   if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(10);
 634
 635   if (waitpid(pid, &status, 0) != pid) my_e(11);
 636   if (!_WIFSTOPPED(status)) my_e(12);
 637   if (WSTOPSIG(status) != sig) my_e(13);
 638
 639   if (waitpid(pid, &status, WNOHANG) != 0) my_e(14);
 640
 641   if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(15);
 642
 643   /* Ignored signals passed via ptrace() should be ignored. */
 644   if (kill(pid, SIGUSR1) != 0) my_e(16);
 645
 646   if (waitpid(pid, &status, 0) != pid) my_e(17);
 647   if (!_WIFSTOPPED(status)) my_e(18);
 648   if (WSTOPSIG(status) != SIGUSR1) my_e(19);
 649
 650   if (ptrace(T_RESUME, pid, 0, SIGCHLD) != 0) my_e(20);
 651
 652   /* if the pause has been aborted (shouldn't happen!), let the child exit */
 653   sleep(1);
 654
 655   if (waitpid(pid, &status, WNOHANG) != 0) my_e(21);
 656
 657   /* Caught signals passed via ptrace() should invoke their signal handlers. */
 658   if (kill(pid, SIGUSR1) != 0) my_e(22);
 659
 660   if (waitpid(pid, &status, 0) != pid) my_e(23);
 661   if (!_WIFSTOPPED(status)) my_e(24);
 662   if (WSTOPSIG(status) != SIGUSR1) my_e(25);
 663
 664   if (ptrace(T_RESUME, pid, 0, SIGUSR1) != 0) my_e(26);
 665
 666   if (waitpid(pid, &status, 0) != pid) my_e(27);
 667   if (!_WIFEXITED(status)) my_e(28);
 668   if ((r = WEXITSTATUS(status)) != 42) my_e(29);
 669
 670   traced_wait();
 671 }
 672
 673 void test_exit_child()
 674 {
 675   WRITE(0);
 676
 677   for(;;);
 678 }
 679
 680 void test_exit()
 681 {
 682   pid_t pid;
 683   int r, status;
 684
 685   subtest = 5;
 686
 687   pid = traced_fork(test_exit_child);
 688
 689   if (READ() != 0) my_e(1);
 690
 691   sleep(1);
 692
 693   if (kill(pid, SIGSTOP) != 0) my_e(2);
 694
 695   if (waitpid(pid, &status, 0) != pid) my_e(3);
 696   if (!_WIFSTOPPED(status)) my_e(4);
 697   if (WSTOPSIG(status) != SIGSTOP) my_e(5);
 698
 699   /* There should be no more signals pending for the tracer now. */
 700   if (waitpid(pid, &status, WNOHANG) != 0) my_e(6);
 701
 702   /* ptrace(T_EXIT) should terminate the process with the given exit value. */
 703   if (ptrace(T_EXIT, pid, 0, 42) != 0) my_e(7);
 704
 705   if (waitpid(pid, &status, 0) != pid) my_e(8);
 706   if (!_WIFEXITED(status)) my_e(9);
 707   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
 708
 709   traced_wait();
 710 }
 711
 712 void test_term_child()
 713 {
 714   signal(SIGUSR1, SIG_DFL);
 715   signal(SIGUSR2, dummy_handler);
 716
 717   WRITE(0);
 718
 719   pause();
 720
 721   my_e(100);
 722 }
 723
 724 void test_term()
 725 {
 726   pid_t pid;
 727   int status;
 728
 729   subtest = 6;
 730
 731   pid = traced_fork(test_term_child);
 732
 733   if (READ() != 0) my_e(1);
 734
 735   /* If the first of two signals terminates the traced child, the second signal
 736    * may or may not be delivered to the tracer - this is merely a policy issue.
 737    * However, nothing unexpected should happen.
 738    */
 739   if (kill(pid, SIGUSR1) != 0) my_e(2);
 740   if (kill(pid, SIGUSR2) != 0) my_e(3);
 741
 742   if (waitpid(pid, &status, 0) != pid) my_e(4);
 743   if (!_WIFSTOPPED(status)) my_e(5);
 744
 745   if (ptrace(T_RESUME, pid, 0, SIGUSR1) != 0) my_e(6);
 746
 747   if (waitpid(pid, &status, 0) != pid) my_e(7);
 748
 749   if (_WIFSTOPPED(status)) {
 750         if (ptrace(T_RESUME, pid, 0, SIGUSR1) != 0) my_e(8);
 751
 752         if (waitpid(pid, &status, 0) != pid) my_e(9);
 753   }
 754
 755   if (!_WIFSIGNALED(status)) my_e(10);
 756   if (WTERMSIG(status) != SIGUSR1) my_e(11);
 757
 758   traced_wait();
 759 }
 760
 761 void test_catch_child()
 762 {
 763   struct sigaction sa;
 764   sigset_t set, oset;
 765
 766   sa.sa_handler = catch_handler;
 767   sigemptyset(&sa.sa_mask);
 768   sa.sa_flags = SA_NODEFER;
 769
 770   sigaction(SIGUSR1, &sa, NULL);
 771   sigaction(SIGUSR2, &sa, NULL);
 772   sigaction(SIGTERM, &sa, NULL);
 773
 774   sigfillset(&set);
 775   sigprocmask(SIG_SETMASK, &set, &oset);
 776
 777   caught = 0;
 778
 779   WRITE(0);
 780
 781   while (caught != 7) sigsuspend(&oset);
 782
 783   exit(42);
 784 }
 785
 786 void test_catch()
 787 {
 788   pid_t pid;
 789   int r, sig, status;
 790
 791   subtest = 7;
 792
 793   pid = traced_fork(test_catch_child);
 794
 795   if (READ() != 0) my_e(1);
 796
 797   if (kill(pid, SIGUSR1) != 0) my_e(2);
 798   if (kill(pid, SIGUSR2) != 0) my_e(3);
 799
 800   if (waitpid(pid, &status, 0) != pid) my_e(4);
 801   if (!_WIFSTOPPED(status)) my_e(5);
 802   if (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGUSR2) my_e(6);
 803   sig = (WSTOPSIG(status) == SIGUSR1) ? SIGUSR2 : SIGUSR1;
 804
 805   if (ptrace(T_RESUME, pid, 0, WSTOPSIG(status)) != 0) my_e(7);
 806
 807   if (kill(pid, SIGTERM) != 0) my_e(8);
 808
 809   if (waitpid(pid, &status, 0) != pid) my_e(9);
 810   if (!_WIFSTOPPED(status)) my_e(10);
 811   if (WSTOPSIG(status) != sig && WSTOPSIG(status) != SIGTERM) my_e(11);
 812   if (WSTOPSIG(status) == sig) sig = SIGTERM;
 813
 814   if (ptrace(T_RESUME, pid, 0, WSTOPSIG(status)) != 0) my_e(12);
 815
 816   if (kill(pid, SIGBUS) != 0) my_e(13);
 817
 818   if (waitpid(pid, &status, 0) != pid) my_e(14);
 819   if (!_WIFSTOPPED(status)) my_e(15);
 820   if (WSTOPSIG(status) != sig && WSTOPSIG(status) != SIGBUS) my_e(16);
 821
 822   if (ptrace(T_RESUME, pid, 0, sig) != 0) my_e(17);
 823
 824   if (WSTOPSIG(status) == sig) sig = SIGBUS;
 825
 826   if (waitpid(pid, &status, 0) != pid) my_e(18);
 827   if (!_WIFSTOPPED(status)) my_e(19);
 828   if (WSTOPSIG(status) != sig) my_e(20);
 829
 830   if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(21);
 831
 832   if (waitpid(pid, &status, 0) != pid) my_e(22);
 833   if (!_WIFEXITED(status)) my_e(23);
 834   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
 835
 836   traced_wait();
 837 }
 838
 839 void test_kill_child()
 840 {
 841   sigset_t set;
 842
 843   signal(SIGKILL, SIG_IGN);
 844   sigfillset(&set);
 845   sigprocmask(SIG_SETMASK, &set, NULL);
 846
 847   WRITE(0);
 848
 849   pause();
 850
 851   my_e(100);
 852 }
 853
 854 void test_kill()
 855 {
 856   pid_t pid;
 857   int status;
 858
 859   subtest = 8;
 860
 861   pid = traced_fork(test_kill_child);
 862
 863   if (READ() != 0) my_e(1);
 864
 865   /* SIGKILL must be unstoppable in every way. */
 866   if (kill(pid, SIGKILL) != 0) my_e(2);
 867
 868   if (waitpid(pid, &status, 0) != pid) my_e(3);
 869   if (!_WIFSIGNALED(status)) my_e(4);
 870   if (WTERMSIG(status) != SIGKILL) my_e(5);
 871
 872   /* After termination, the child must no longer be visible to the tracer. */
 873   if (waitpid(pid, &status, WNOHANG) != -1) my_e(6);
 874   if (errno != ECHILD) my_e(7);
 875
 876   traced_wait();
 877 }
 878
 879 void test_attach_child()
 880 {
 881   if (ptrace(T_OK, 0, 0, 0) != -1) my_e(100);
 882   if (errno != EBUSY) my_e(101);
 883
 884   WRITE(0);
 885
 886   if (READ() != 0) my_e(102);
 887
 888   exit(42);
 889 }
 890
 891 void test_attach()
 892 {
 893   pid_t pid;
 894
 895   subtest = 9;
 896
 897   /* Attaching to kernel processes is not allowed. */
 898   if (ptrace(T_ATTACH, -1, 0, 0) != -1) my_e(1);
 899   if (errno != ESRCH) my_e(2);
 900
 901   /* Attaching to self is not allowed. */
 902   if (ptrace(T_ATTACH, getpid(), 0, 0) != -1) my_e(3);
 903   if (errno != EPERM) my_e(4);
 904
 905   /* Attaching to PM is not allowed. */
 906 #if 0
 907   /* FIXME: disabled until we can reliably determine PM's pid */
 908   if (ptrace(T_ATTACH, 0, 0, 0) != -1) my_e(5);
 909   if (errno != EPERM) my_e(6);
 910 #endif
 911
 912   pid = traced_fork(test_attach_child);
 913
 914   /* Attaching more than once is not allowed. */
 915   if (ptrace(T_ATTACH, pid, 0, 0) != -1) my_e(7);
 916   if (errno != EBUSY) my_e(8);
 917
 918   if (READ() != 0) my_e(9);
 919
 920   /* Detaching a running child should not succeed. */
 921   if (ptrace(T_DETACH, pid, 0, 0) == 0) my_e(10);
 922   if (errno != EBUSY) my_e(11);
 923
 924   detach_running(pid);
 925
 926   WRITE(0);
 927
 928   traced_wait();
 929 }
 930
 931 void test_detach_child()
 932 {
 933   struct sigaction sa;
 934   sigset_t set, sset, oset;
 935
 936   sa.sa_handler = catch_handler;
 937   sigemptyset(&sa.sa_mask);
 938   sa.sa_flags = SA_NODEFER;
 939
 940   sigaction(SIGUSR1, &sa, NULL);
 941   sigaction(SIGUSR2, &sa, NULL);
 942   sigaction(SIGTERM, &sa, NULL);
 943
 944   sigfillset(&set);
 945   sigprocmask(SIG_SETMASK, &set, &oset);
 946
 947   sigfillset(&sset);
 948   sigdelset(&sset, SIGUSR1);
 949
 950   caught = 0;
 951
 952   WRITE(0);
 953
 954   if (sigsuspend(&sset) != -1) my_e(102);
 955   if (errno != EINTR) my_e(103);
 956
 957   if (caught != 1) my_e(104);
 958
 959   if (READ() != 0) my_e(105);
 960
 961   while (caught != 7) sigsuspend(&oset);
 962
 963   exit(42);
 964 }
 965
 966 void test_detach()
 967 {
 968   pid_t pid;
 969   int r, status;
 970
 971   /* Can't use traced_fork(), so simplify a bit */
 972   if (attach != 0) return;
 973
 974   subtest = 10;
 975
 976   pid = traced_pfork(test_detach_child);
 977
 978   if (READ() != 0) my_e(1);
 979
 980   /* The tracer should not see signals sent to the process before attaching. */
 981   if (kill(pid, SIGUSR2) != 0) my_e(2);
 982
 983   if (ptrace(T_ATTACH, pid, 0, 0) != 0) my_e(3);
 984
 985   if (waitpid(pid, &status, 0) != pid) my_e(4);
 986   if (!_WIFSTOPPED(status)) my_e(5);
 987   if (WSTOPSIG(status) != SIGSTOP) my_e(6);
 988
 989   if (ptrace(T_RESUME, pid, 0, 0) != 0) my_e(7);
 990
 991   if (kill(pid, SIGUSR1) != 0) my_e(8);
 992
 993   if (waitpid(pid, &status, 0) != pid) my_e(9);
 994   if (!_WIFSTOPPED(status)) my_e(10);
 995   if (WSTOPSIG(status) != SIGUSR1) my_e(11);
 996
 997   /* Signals pending at the tracer should be passed on after detaching. */
 998   if (kill(pid, SIGTERM) != 0) my_e(12);
 999
1000   /* A signal may be passed with the detach request. */
1001   if (ptrace(T_DETACH, pid, 0, SIGUSR1) != 0) my_e(13);
1002
1003   WRITE(0);
1004
1005   if (waitpid(pid, &status, 0) != pid) my_e(14);
1006   if (!_WIFEXITED(status)) my_e(15);
1007   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1008
1009   traced_wait();
1010 }
1011
1012 void test_death_child()
1013 {
1014   pid_t pid;
1015
1016   pid = fork();
1017
1018   if (pid < 0) my_e(100);
1019
1020   if (pid == 0) {
1021         ptrace(T_OK, 0, 0, 0);
1022
1023         WRITE(getpid());
1024
1025         for (;;) pause();
1026   }
1027
1028   if (READ() != 0) my_e(101);
1029
1030   kill(getpid(), SIGKILL);
1031
1032   my_e(102);
1033 }
1034
1035 void test_death()
1036 {
1037   pid_t pid, cpid;
1038   int status;
1039
1040   subtest = 11;
1041
1042   pid = traced_fork(test_death_child);
1043
1044   cpid = READ();
1045
1046   if (kill(cpid, 0) != 0) my_e(1);
1047
1048   WRITE(0);
1049
1050   if (waitpid(pid, &status, 0) != pid) my_e(2);
1051   if (!_WIFSIGNALED(status)) my_e(3);
1052   if (WTERMSIG(status) != SIGKILL) my_e(4);
1053
1054   /* The children of killed tracers should be terminated. */
1055   while (kill(cpid, 0) == 0) sleep(1);
1056   if (errno != ESRCH) my_e(5);
1057
1058   traced_wait();
1059 }
1060
1061 void test_zdeath_child()
1062 {
1063   if (READ() != 0) my_e(100);
1064
1065   exit(42);
1066 }
1067
1068 void test_zdeath()
1069 {
1070   pid_t pid, tpid;
1071   int r, status;
1072
1073   /* Can't use traced_fork(), so simplify a bit */
1074   if (attach != 0) return;
1075
1076   subtest = 12;
1077
1078   pid = traced_pfork(test_zdeath_child);
1079
1080   tpid = fork();
1081
1082   if (tpid < 0) my_e(1);
1083
1084   if (tpid == 0) {
1085         if (ptrace(T_ATTACH, pid, 0, 0) != 0) exit(101);
1086
1087         if (waitpid(pid, &status, 0) != pid) exit(102);
1088         if (!_WIFSTOPPED(status)) exit(103);
1089         if (WSTOPSIG(status) != SIGSTOP) exit(104);
1090
1091         if (ptrace(T_RESUME, pid, 0, 0) != 0) exit(105);
1092
1093         WRITE(0);
1094
1095         /* Unwaited-for traced zombies should be passed to their parent. */
1096         sleep(2);
1097
1098         exit(84);
1099   }
1100
1101   sleep(1);
1102
1103   /* However, that should only happen once the tracer has actually died. */
1104   if (waitpid(pid, &status, WNOHANG) != 0) my_e(2);
1105
1106   if (waitpid(tpid, &status, 0) != tpid) my_e(3);
1107   if (!_WIFEXITED(status)) my_e(4);
1108   if ((r = WEXITSTATUS(status)) != 84) my_e(r);
1109
1110   if (waitpid(pid, &status, 0) != pid) my_e(5);
1111   if (!_WIFEXITED(status)) my_e(6);
1112   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1113
1114   traced_wait();
1115 }
1116
1117 void test_syscall_child()
1118 {
1119   signal(SIGUSR1, count_handler);
1120   signal(SIGUSR2, count_handler);
1121
1122   sigs = 0;
1123
1124   WRITE(0);
1125
1126   if (READ() != 0) my_e(100);
1127
1128   /* Three calls (may fail) */
1129   setuid(0);
1130   close(123);
1131   getpid();
1132
1133   if (sigs != 2) my_e(101);
1134
1135   exit(42);
1136 }
1137
1138 void test_syscall()
1139 {
1140   pid_t pid;
1141   int i, r, sig, status;
1142
1143   subtest = 13;
1144
1145   pid = traced_fork(test_syscall_child);
1146
1147   if (READ() != 0) my_e(1);
1148
1149   if (kill(pid, SIGSTOP) != 0) my_e(2);
1150
1151   if (waitpid(pid, &status, 0) != pid) my_e(3);
1152   if (!_WIFSTOPPED(status)) my_e(4);
1153   if (WSTOPSIG(status) != SIGSTOP) my_e(5);
1154
1155   WRITE(0);
1156
1157   /* Upon resuming a first system call, no syscall leave event must be sent. */
1158   if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(6);
1159
1160   if (waitpid(pid, &status, 0) != pid) my_e(7);
1161
1162   for (i = 0; _WIFSTOPPED(status); i++) {
1163         if (WSTOPSIG(status) != SIGTRAP) my_e(8);
1164
1165         /* Signals passed via T_SYSCALL should arrive, on enter and exit. */
1166         if (i == 3) sig = SIGUSR1;
1167         else if (i == 6) sig = SIGUSR2;
1168         else sig = 0;
1169
1170         if (ptrace(T_SYSCALL, pid, 0, sig) != 0) my_e(9);
1171
1172         if (waitpid(pid, &status, 0) != pid) my_e(10);
1173   }
1174
1175   if (!_WIFEXITED(status)) my_e(11);
1176   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1177
1178   /* The number of events seen is deterministic but libc-dependent. */
1179   if (i < 10 || i > 100) my_e(12);
1180
1181   /* The last system call event must be for entering exit(). */
1182   if (!(i % 2)) my_e(13);
1183
1184   traced_wait();
1185 }
1186
1187 void test_tracefork_child()
1188 {
1189   pid_t pid;
1190
1191   signal(SIGHUP, SIG_IGN);
1192
1193   pid = setsid();
1194
1195   WRITE(pid);
1196
1197   if (READ() != 0) my_e(100);
1198
1199   if ((pid = fork()) < 0) my_e(101);
1200
1201   exit(pid > 0 ? 42 : 84);
1202 }
1203
1204 void test_tracefork()
1205 {
1206   pid_t pgrp, ppid, cpid, wpid;
1207   int r, status, gotstop, ptraps, ctraps;
1208
1209   subtest = 14;
1210
1211   ppid = traced_fork(test_tracefork_child);
1212
1213   if ((pgrp = READ()) <= 0) my_e(1);
1214
1215   if (kill(ppid, SIGSTOP) != 0) my_e(2);
1216
1217   if (waitpid(ppid, &status, 0) != ppid) my_e(3);
1218   if (!_WIFSTOPPED(status)) my_e(4);
1219   if (WSTOPSIG(status) != SIGSTOP) my_e(5);
1220
1221   if (ptrace(T_SETOPT, ppid, 0, TO_TRACEFORK) != 0) my_e(6);
1222
1223   WRITE(0);
1224
1225   if (ptrace(T_SYSCALL, ppid, 0, 0) != 0) my_e(7);
1226
1227   cpid = -1;
1228   gotstop = -1;
1229
1230   /* Count how many traps we get for parent and child, until they both exit. */
1231   for (ptraps = ctraps = 0; ppid || cpid; ) {
1232         wpid = waitpid(-pgrp, &status, 0);
1233
1234         if (wpid <= 0) my_e(8);
1235         if (cpid < 0 && wpid != ppid) {
1236                 cpid = wpid;
1237                 gotstop = 0;
1238         }
1239         if (wpid != ppid && wpid != cpid) my_e(9);
1240
1241         if (_WIFEXITED(status)) {
1242                 if (wpid == ppid) {
1243                         if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1244                         ppid = 0;
1245                 }
1246                 else {
1247                         if ((r = WEXITSTATUS(status)) != 84) my_e(r);
1248                         cpid = 0;
1249                 }
1250         }
1251         else {
1252                 if (!_WIFSTOPPED(status)) my_e(10);
1253
1254                 switch (WSTOPSIG(status)) {
1255                 case SIGCHLD:
1256                 case SIGHUP:
1257                         break;
1258                 case SIGSTOP:
1259                         if (wpid != cpid) my_e(11);
1260                         if (gotstop) my_e(12);
1261                         gotstop = 1;
1262                         break;
1263                 case SIGTRAP:
1264                         if (wpid == ppid) ptraps++;
1265                         else ctraps++;
1266                         break;
1267                 default:
1268                         my_e(13);
1269                 }
1270
1271                 if (ptrace(T_SYSCALL, wpid, 0, 0) != 0) my_e(14);
1272         }
1273   }
1274
1275   /* The parent should get an odd number of traps: the first one is a syscall
1276    * enter trap (typically for the fork()), the last one is the syscall enter
1277    * trap for its exit().
1278    */
1279   if (ptraps < 3) my_e(15);
1280   if (!(ptraps % 2)) my_e(16);
1281
1282   /* The child should get an even number of traps: the first one is a syscall
1283    * leave trap from the fork(), the last one is the syscall enter trap for
1284    * its exit().
1285    */
1286   if (ctraps < 2) my_e(17);
1287   if (ctraps % 2) my_e(18);
1288
1289   traced_wait();
1290 }
1291
1292 void sigexec(setflag, opt, traps, stop)
1293 int setflag;
1294 int opt;
1295 int *traps;
1296 int *stop;
1297 {
1298   pid_t pid;
1299   int r, status;
1300
1301   pid = traced_fork(test_exec_child);
1302
1303   if (kill(pid, SIGSTOP) != 0) my_e(1);
1304
1305   if (waitpid(pid, &status, 0) != pid) my_e(2);
1306   if (!_WIFSTOPPED(status)) my_e(3);
1307   if (WSTOPSIG(status) != SIGSTOP) my_e(4);
1308
1309   if (setflag && ptrace(T_SETOPT, pid, 0, opt) != 0) my_e(5);
1310
1311   WRITE(0);
1312
1313   if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(6);
1314
1315   *traps = 0;
1316   *stop = -1;
1317
1318   for (;;) {
1319         if (waitpid(pid, &status, 0) != pid) my_e(7);
1320
1321         if (_WIFEXITED(status)) break;
1322
1323         if (!_WIFSTOPPED(status)) my_e(8);
1324
1325         switch (WSTOPSIG(status)) {
1326         case SIGTRAP:
1327                 (*traps)++;
1328                 break;
1329         case SIGSTOP:
1330                 if (*stop >= 0) my_e(9);
1331                 *stop = *traps;
1332                 break;
1333         default:
1334                 my_e(10);
1335         }
1336
1337         if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(11);
1338   }
1339
1340   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1341
1342   traced_wait();
1343 }
1344
1345 void test_trapexec()
1346 {
1347   int traps, stop;
1348
1349   subtest = 15;
1350
1351   sigexec(1, 0, &traps, &stop);
1352
1353   /* The exec does not cause a SIGSTOP. This gives us an even number of traps;
1354    * as above, but plus the exec()'s extra SIGTRAP. This trap is
1355    * indistinguishable from a syscall trap, especially when considering failed
1356    * exec() calls and immediately following signal handler invocations.
1357    */
1358   if (traps < 4) my_e(12);
1359   if (traps % 2) my_e(13);
1360   if (stop >= 0) my_e(14);
1361 }
1362
1363 void test_altexec()
1364 {
1365   int traps, stop;
1366
1367   subtest = 16;
1368
1369   sigexec(1, TO_ALTEXEC, &traps, &stop);
1370
1371   /* The exec causes a SIGSTOP. This gives us an odd number of traps: a pair
1372    * for each system call, plus one for the final exit(). The stop must have
1373    * taken place after a syscall enter event, i.e. must be odd as well.
1374    */
1375   if (traps < 3) my_e(12);
1376   if (!(traps % 2)) my_e(13);
1377   if (stop < 0) my_e(14);
1378   if (!(stop % 2)) my_e(15);
1379 }
1380
1381 void test_noexec()
1382 {
1383   int traps, stop;
1384
1385   subtest = 17;
1386
1387   sigexec(1, TO_NOEXEC, &traps, &stop);
1388
1389   /* The exec causes no signal at all. As above, but without the SIGSTOPs. */
1390   if (traps < 3) my_e(12);
1391   if (!(traps % 2)) my_e(13);
1392   if (stop >= 0) my_e(14);
1393 }
1394
1395 void test_defexec()
1396 {
1397   int traps, stop;
1398
1399   /* We want to test the default of T_OK (0) and T_ATTACH (TO_NOEXEC). */
1400   if (attach != 0 && attach != 1) return;
1401
1402   subtest = 18;
1403
1404   /* Do not set any options this time. */
1405   sigexec(0, 0, &traps, &stop);
1406
1407   /* See above. */
1408   if (attach == 0) {
1409         if (traps < 4) my_e(12);
1410         if (traps % 2) my_e(13);
1411         if (stop >= 0) my_e(14);
1412   }
1413   else {
1414         if (traps < 3) my_e(15);
1415         if (!(traps % 2)) my_e(16);
1416         if (stop >= 0) my_e(17);
1417   }
1418 }
1419
1420 void test_reattach_child()
1421 {
1422   struct timeval tv;
1423
1424   if (READ() != 0) my_e(100);
1425
1426   tv.tv_sec = 2;
1427   tv.tv_usec = 0;
1428   if (select(0, NULL, NULL, NULL, &tv) != 0) my_e(101);
1429
1430   exit(42);
1431 }
1432
1433 void test_reattach()
1434 {
1435   pid_t pid;
1436   int r, status, count;
1437
1438   subtest = 19;
1439
1440   pid = traced_fork(test_reattach_child);
1441
1442   if (kill(pid, SIGSTOP) != 0) my_e(1);
1443
1444   if (waitpid(pid, &status, 0) != pid) my_e(2);
1445   if (!_WIFSTOPPED(status)) my_e(3);
1446   if (WSTOPSIG(status) != SIGSTOP) my_e(4);
1447
1448   WRITE(0);
1449
1450   signal(SIGALRM, dummy_handler);
1451   alarm(1);
1452
1453   /* Start tracing system calls. We don't know how many there will be until
1454    * we reach the child's select(), so we have to interrupt ourselves.
1455    * The hard assumption here is that the child is able to enter the select()
1456    * within a second, despite being traced. If this is not the case, the test
1457    * may hang or fail, and the child may die from a SIGTRAP.
1458    */
1459   if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(5);
1460
1461   for (count = 0; (r = waitpid(pid, &status, 0)) == pid; count++) {
1462         if (!_WIFSTOPPED(status)) my_e(6);
1463         if (WSTOPSIG(status) != SIGTRAP) my_e(7);
1464
1465         if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(8);
1466   }
1467
1468   if (r != -1 || errno != EINTR) my_e(9);
1469
1470   /* We always start with syscall enter event; the last event we should have
1471    * seen before the alarm was entering the select() call.
1472    */
1473   if (!(count % 2)) my_e(10);
1474
1475   /* Detach, and immediately attach again. */
1476   detach_running(pid);
1477
1478   if (ptrace(T_ATTACH, pid, 0, 0) != 0) my_e(11);
1479
1480   if (waitpid(pid, &status, 0) != pid) my_e(12);
1481   if (!_WIFSTOPPED(status)) my_e(13);
1482   if (WSTOPSIG(status) != SIGSTOP) my_e(14);
1483
1484   if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(15);
1485
1486   if (waitpid(pid, &status, 0) != pid) my_e(16);
1487
1488   for (count = 0; _WIFSTOPPED(status); count++) {
1489         if (WSTOPSIG(status) != SIGTRAP) my_e(17);
1490
1491         if (ptrace(T_SYSCALL, pid, 0, 0) != 0) my_e(18);
1492
1493         if (waitpid(pid, &status, 0) != pid) my_e(19);
1494   }
1495
1496   if (!_WIFEXITED(status)) my_e(20);
1497   if ((r = WEXITSTATUS(status)) != 42) my_e(r);
1498
1499   /* We must not have seen the select()'s syscall leave event, and the last
1500    * event will be the syscall enter for the exit().
1501    */
1502   if (!(count % 2)) my_e(21);
1503
1504   traced_wait();
1505 }
1506