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