t_ptrace_wait.c revision 1.116
1/* $NetBSD: t_ptrace_wait.c,v 1.116 2019/05/01 18:20:23 kamil Exp $ */ 2 3/*- 4 * Copyright (c) 2016, 2017, 2018, 2019 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29#include <sys/cdefs.h> 30__RCSID("$NetBSD: t_ptrace_wait.c,v 1.116 2019/05/01 18:20:23 kamil Exp $"); 31 32#include <sys/param.h> 33#include <sys/types.h> 34#include <sys/mman.h> 35#include <sys/ptrace.h> 36#include <sys/resource.h> 37#include <sys/stat.h> 38#include <sys/syscall.h> 39#include <sys/sysctl.h> 40#include <sys/wait.h> 41#include <machine/reg.h> 42#include <elf.h> 43#include <err.h> 44#include <errno.h> 45#include <lwp.h> 46#include <pthread.h> 47#include <sched.h> 48#include <signal.h> 49#include <stdint.h> 50#include <stdio.h> 51#include <stdlib.h> 52#include <strings.h> 53#include <time.h> 54#include <unistd.h> 55 56#include <fenv.h> 57#if (__arm__ && !__SOFTFP__) || __aarch64__ 58#include <ieeefp.h> /* only need for ARM Cortex/Neon hack */ 59#endif 60 61#include <atf-c.h> 62 63#include "h_macros.h" 64 65#include "t_ptrace_wait.h" 66#include "msg.h" 67 68#define PARENT_TO_CHILD(info, fds, msg) \ 69 SYSCALL_REQUIRE(msg_write_child(info " to child " # fds, &fds, &msg, \ 70 sizeof(msg)) == 0) 71 72#define CHILD_FROM_PARENT(info, fds, msg) \ 73 FORKEE_ASSERT(msg_read_parent(info " from parent " # fds, &fds, &msg, \ 74 sizeof(msg)) == 0) 75 76#define CHILD_TO_PARENT(info, fds, msg) \ 77 FORKEE_ASSERT(msg_write_parent(info " to parent " # fds, &fds, &msg, \ 78 sizeof(msg)) == 0) 79 80#define PARENT_FROM_CHILD(info, fds, msg) \ 81 SYSCALL_REQUIRE(msg_read_child(info " from parent " # fds, &fds, &msg, \ 82 sizeof(msg)) == 0) 83 84#define SYSCALL_REQUIRE(expr) ATF_REQUIRE_MSG(expr, "%s: %s", # expr, \ 85 strerror(errno)) 86#define SYSCALL_REQUIRE_ERRNO(res, exp) ATF_REQUIRE_MSG(res == exp, \ 87 "%d(%s) != %d", res, strerror(res), exp) 88 89static int debug = 0; 90 91#define DPRINTF(a, ...) do \ 92 if (debug) printf(a, ##__VA_ARGS__); \ 93 while (/*CONSTCOND*/0) 94 95#ifndef TEST_VFORK_ENABLED 96#define TEST_VFORK_ENABLED 0 97#endif 98 99/// ---------------------------------------------------------------------------- 100 101static void 102traceme_raise(int sigval) 103{ 104 const int exitval = 5; 105 pid_t child, wpid; 106#if defined(TWAIT_HAVE_STATUS) 107 int status; 108#endif 109 110 struct ptrace_siginfo info; 111 memset(&info, 0, sizeof(info)); 112 113 DPRINTF("Before forking process PID=%d\n", getpid()); 114 SYSCALL_REQUIRE((child = fork()) != -1); 115 if (child == 0) { 116 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 117 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 118 119 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 120 FORKEE_ASSERT(raise(sigval) == 0); 121 122 switch (sigval) { 123 case SIGKILL: 124 /* NOTREACHED */ 125 FORKEE_ASSERTX(0 && "This shall not be reached"); 126 __unreachable(); 127 default: 128 DPRINTF("Before exiting of the child process\n"); 129 _exit(exitval); 130 } 131 } 132 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 133 134 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 135 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 136 137 switch (sigval) { 138 case SIGKILL: 139 validate_status_signaled(status, sigval, 0); 140 break; 141 default: 142 validate_status_stopped(status, sigval); 143 144 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 145 "child\n"); 146 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 147 sizeof(info)) != -1); 148 149 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 150 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 151 "si_errno=%#x\n", 152 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 153 info.psi_siginfo.si_errno); 154 155 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 156 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 157 158 DPRINTF("Before resuming the child process where it left off " 159 "and without signal to be sent\n"); 160 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 161 162 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 163 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 164 child); 165 break; 166 } 167 168 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 169 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 170} 171 172#define TRACEME_RAISE(test, sig) \ 173ATF_TC(test); \ 174ATF_TC_HEAD(test, tc) \ 175{ \ 176 atf_tc_set_md_var(tc, "descr", \ 177 "Verify " #sig " followed by _exit(2) in a child"); \ 178} \ 179 \ 180ATF_TC_BODY(test, tc) \ 181{ \ 182 \ 183 traceme_raise(sig); \ 184} 185 186TRACEME_RAISE(traceme_raise1, SIGKILL) /* non-maskable */ 187TRACEME_RAISE(traceme_raise2, SIGSTOP) /* non-maskable */ 188TRACEME_RAISE(traceme_raise3, SIGABRT) /* regular abort trap */ 189TRACEME_RAISE(traceme_raise4, SIGHUP) /* hangup */ 190TRACEME_RAISE(traceme_raise5, SIGCONT) /* continued? */ 191TRACEME_RAISE(traceme_raise6, SIGTRAP) /* crash signal */ 192TRACEME_RAISE(traceme_raise7, SIGBUS) /* crash signal */ 193TRACEME_RAISE(traceme_raise8, SIGILL) /* crash signal */ 194TRACEME_RAISE(traceme_raise9, SIGFPE) /* crash signal */ 195TRACEME_RAISE(traceme_raise10, SIGSEGV) /* crash signal */ 196 197/// ---------------------------------------------------------------------------- 198 199static void 200traceme_raisesignal_ignored(int sigignored) 201{ 202 const int exitval = 5; 203 const int sigval = SIGSTOP; 204 pid_t child, wpid; 205 struct sigaction sa; 206#if defined(TWAIT_HAVE_STATUS) 207 int status; 208#endif 209 struct ptrace_siginfo info; 210 211 memset(&info, 0, sizeof(info)); 212 213 DPRINTF("Before forking process PID=%d\n", getpid()); 214 SYSCALL_REQUIRE((child = fork()) != -1); 215 if (child == 0) { 216 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 217 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 218 219 memset(&sa, 0, sizeof(sa)); 220 sa.sa_handler = SIG_IGN; 221 sigemptyset(&sa.sa_mask); 222 FORKEE_ASSERT(sigaction(sigignored, &sa, NULL) != -1); 223 224 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 225 FORKEE_ASSERT(raise(sigval) == 0); 226 227 DPRINTF("Before raising %s from child\n", 228 strsignal(sigignored)); 229 FORKEE_ASSERT(raise(sigignored) == 0); 230 231 DPRINTF("Before exiting of the child process\n"); 232 _exit(exitval); 233 } 234 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 235 236 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 237 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 238 239 validate_status_stopped(status, sigval); 240 241 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 242 SYSCALL_REQUIRE( 243 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 244 245 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 246 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 247 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 248 info.psi_siginfo.si_errno); 249 250 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 251 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 252 253 DPRINTF("Before resuming the child process where it left off and " 254 "without signal to be sent\n"); 255 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 256 257 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 258 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 259 260 validate_status_stopped(status, sigignored); 261 262 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 263 SYSCALL_REQUIRE( 264 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 265 266 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 267 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 268 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 269 info.psi_siginfo.si_errno); 270 271 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigignored); 272 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 273 274 DPRINTF("Before resuming the child process where it left off and " 275 "without signal to be sent\n"); 276 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 277 278 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 279 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 280 281 validate_status_exited(status, exitval); 282 283 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 284 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 285} 286 287#define TRACEME_RAISESIGNAL_IGNORED(test, sig) \ 288ATF_TC(test); \ 289ATF_TC_HEAD(test, tc) \ 290{ \ 291 atf_tc_set_md_var(tc, "descr", \ 292 "Verify that ignoring (with SIG_IGN) " #sig " in tracee " \ 293 "does not stop tracer from catching this raised signal"); \ 294} \ 295 \ 296ATF_TC_BODY(test, tc) \ 297{ \ 298 \ 299 traceme_raisesignal_ignored(sig); \ 300} 301 302// A signal handler for SIGKILL and SIGSTOP cannot be ignored. 303TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored1, SIGABRT) /* abort */ 304TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored2, SIGHUP) /* hangup */ 305TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored3, SIGCONT) /* cont. */ 306TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored4, SIGTRAP) /* crash */ 307TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored5, SIGBUS) /* crash */ 308TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored6, SIGILL) /* crash */ 309TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored7, SIGFPE) /* crash */ 310TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored8, SIGSEGV) /* crash */ 311 312/// ---------------------------------------------------------------------------- 313 314static void 315traceme_raisesignal_masked(int sigmasked) 316{ 317 const int exitval = 5; 318 const int sigval = SIGSTOP; 319 pid_t child, wpid; 320#if defined(TWAIT_HAVE_STATUS) 321 int status; 322#endif 323 sigset_t intmask; 324 struct ptrace_siginfo info; 325 326 memset(&info, 0, sizeof(info)); 327 328 DPRINTF("Before forking process PID=%d\n", getpid()); 329 SYSCALL_REQUIRE((child = fork()) != -1); 330 if (child == 0) { 331 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 332 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 333 334 sigemptyset(&intmask); 335 sigaddset(&intmask, sigmasked); 336 sigprocmask(SIG_BLOCK, &intmask, NULL); 337 338 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 339 FORKEE_ASSERT(raise(sigval) == 0); 340 341 DPRINTF("Before raising %s breakpoint from child\n", 342 strsignal(sigmasked)); 343 FORKEE_ASSERT(raise(sigmasked) == 0); 344 345 DPRINTF("Before exiting of the child process\n"); 346 _exit(exitval); 347 } 348 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 349 350 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 351 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 352 353 validate_status_stopped(status, sigval); 354 355 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 356 SYSCALL_REQUIRE( 357 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 358 359 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 360 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 361 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 362 info.psi_siginfo.si_errno); 363 364 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 365 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 366 367 DPRINTF("Before resuming the child process where it left off and " 368 "without signal to be sent\n"); 369 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 370 371 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 372 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 373 374 validate_status_exited(status, exitval); 375 376 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 377 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 378} 379 380#define TRACEME_RAISESIGNAL_MASKED(test, sig) \ 381ATF_TC(test); \ 382ATF_TC_HEAD(test, tc) \ 383{ \ 384 atf_tc_set_md_var(tc, "descr", \ 385 "Verify that masking (with SIG_BLOCK) " #sig " in tracee " \ 386 "stops tracer from catching this raised signal"); \ 387} \ 388 \ 389ATF_TC_BODY(test, tc) \ 390{ \ 391 \ 392 traceme_raisesignal_masked(sig); \ 393} 394 395// A signal handler for SIGKILL and SIGSTOP cannot be masked. 396TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked1, SIGABRT) /* abort trap */ 397TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked2, SIGHUP) /* hangup */ 398TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked3, SIGCONT) /* continued? */ 399TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked4, SIGTRAP) /* crash sig. */ 400TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked5, SIGBUS) /* crash sig. */ 401TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked6, SIGILL) /* crash sig. */ 402TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked7, SIGFPE) /* crash sig. */ 403TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked8, SIGSEGV) /* crash sig. */ 404 405/// ---------------------------------------------------------------------------- 406 407static void 408traceme_crash(int sig) 409{ 410 pid_t child, wpid; 411#if defined(TWAIT_HAVE_STATUS) 412 int status; 413#endif 414 struct ptrace_siginfo info; 415 416#ifndef PTRACE_ILLEGAL_ASM 417 if (sig == SIGILL) 418 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 419#endif 420 421 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 422 atf_tc_skip("FP exceptions are not supported"); 423 424 memset(&info, 0, sizeof(info)); 425 426 DPRINTF("Before forking process PID=%d\n", getpid()); 427 SYSCALL_REQUIRE((child = fork()) != -1); 428 if (child == 0) { 429 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 430 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 431 432 DPRINTF("Before executing a trap\n"); 433 switch (sig) { 434 case SIGTRAP: 435 trigger_trap(); 436 break; 437 case SIGSEGV: 438 trigger_segv(); 439 break; 440 case SIGILL: 441 trigger_ill(); 442 break; 443 case SIGFPE: 444 trigger_fpe(); 445 break; 446 case SIGBUS: 447 trigger_bus(); 448 break; 449 default: 450 /* NOTREACHED */ 451 FORKEE_ASSERTX(0 && "This shall not be reached"); 452 } 453 454 /* NOTREACHED */ 455 FORKEE_ASSERTX(0 && "This shall not be reached"); 456 } 457 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 458 459 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 460 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 461 462 validate_status_stopped(status, sig); 463 464 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 465 SYSCALL_REQUIRE( 466 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 467 468 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 469 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 470 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 471 info.psi_siginfo.si_errno); 472 473 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 474 switch (sig) { 475 case SIGTRAP: 476 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 477 break; 478 case SIGSEGV: 479 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 480 break; 481 case SIGILL: 482 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 483 info.psi_siginfo.si_code <= ILL_BADSTK); 484 break; 485 case SIGFPE: 486 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 487 break; 488 case SIGBUS: 489 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 490 break; 491 } 492 493 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 494 495 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 496 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 497 498 validate_status_signaled(status, SIGKILL, 0); 499 500 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 501 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 502} 503 504#define TRACEME_CRASH(test, sig) \ 505ATF_TC(test); \ 506ATF_TC_HEAD(test, tc) \ 507{ \ 508 atf_tc_set_md_var(tc, "descr", \ 509 "Verify crash signal " #sig " in a child after PT_TRACE_ME"); \ 510} \ 511 \ 512ATF_TC_BODY(test, tc) \ 513{ \ 514 \ 515 traceme_crash(sig); \ 516} 517 518TRACEME_CRASH(traceme_crash_trap, SIGTRAP) 519TRACEME_CRASH(traceme_crash_segv, SIGSEGV) 520TRACEME_CRASH(traceme_crash_ill, SIGILL) 521TRACEME_CRASH(traceme_crash_fpe, SIGFPE) 522TRACEME_CRASH(traceme_crash_bus, SIGBUS) 523 524/// ---------------------------------------------------------------------------- 525 526static void 527traceme_signalmasked_crash(int sig) 528{ 529 const int sigval = SIGSTOP; 530 pid_t child, wpid; 531#if defined(TWAIT_HAVE_STATUS) 532 int status; 533#endif 534 struct ptrace_siginfo info; 535 sigset_t intmask; 536 struct kinfo_proc2 kp; 537 size_t len = sizeof(kp); 538 539 int name[6]; 540 const size_t namelen = __arraycount(name); 541 ki_sigset_t kp_sigmask; 542 543#ifndef PTRACE_ILLEGAL_ASM 544 if (sig == SIGILL) 545 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 546#endif 547 548 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 549 atf_tc_skip("FP exceptions are not supported"); 550 551 memset(&info, 0, sizeof(info)); 552 553 DPRINTF("Before forking process PID=%d\n", getpid()); 554 SYSCALL_REQUIRE((child = fork()) != -1); 555 if (child == 0) { 556 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 557 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 558 559 sigemptyset(&intmask); 560 sigaddset(&intmask, sig); 561 sigprocmask(SIG_BLOCK, &intmask, NULL); 562 563 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 564 FORKEE_ASSERT(raise(sigval) == 0); 565 566 DPRINTF("Before executing a trap\n"); 567 switch (sig) { 568 case SIGTRAP: 569 trigger_trap(); 570 break; 571 case SIGSEGV: 572 trigger_segv(); 573 break; 574 case SIGILL: 575 trigger_ill(); 576 break; 577 case SIGFPE: 578 trigger_fpe(); 579 break; 580 case SIGBUS: 581 trigger_bus(); 582 break; 583 default: 584 /* NOTREACHED */ 585 FORKEE_ASSERTX(0 && "This shall not be reached"); 586 } 587 588 /* NOTREACHED */ 589 FORKEE_ASSERTX(0 && "This shall not be reached"); 590 } 591 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 592 593 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 594 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 595 596 validate_status_stopped(status, sigval); 597 598 name[0] = CTL_KERN, 599 name[1] = KERN_PROC2, 600 name[2] = KERN_PROC_PID; 601 name[3] = child; 602 name[4] = sizeof(kp); 603 name[5] = 1; 604 605 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 606 607 kp_sigmask = kp.p_sigmask; 608 609 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 610 SYSCALL_REQUIRE( 611 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 612 613 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 614 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 615 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 616 info.psi_siginfo.si_errno); 617 618 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 619 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 620 621 DPRINTF("Before resuming the child process where it left off and " 622 "without signal to be sent\n"); 623 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 624 625 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 626 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 627 628 validate_status_stopped(status, sig); 629 630 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 631 SYSCALL_REQUIRE( 632 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 633 634 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 635 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 636 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 637 info.psi_siginfo.si_errno); 638 639 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 640 641 DPRINTF("kp_sigmask=" 642 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 643 kp_sigmask.__bits[0], kp_sigmask.__bits[1], kp_sigmask.__bits[2], 644 kp_sigmask.__bits[3]); 645 646 DPRINTF("kp.p_sigmask=" 647 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 648 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 649 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 650 651 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, sizeof(kp_sigmask))); 652 653 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 654 switch (sig) { 655 case SIGTRAP: 656 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 657 break; 658 case SIGSEGV: 659 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 660 break; 661 case SIGILL: 662 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 663 info.psi_siginfo.si_code <= ILL_BADSTK); 664 break; 665 case SIGFPE: 666 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 667 break; 668 case SIGBUS: 669 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 670 break; 671 } 672 673 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 674 675 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 676 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 677 678 validate_status_signaled(status, SIGKILL, 0); 679 680 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 681 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 682} 683 684#define TRACEME_SIGNALMASKED_CRASH(test, sig) \ 685ATF_TC(test); \ 686ATF_TC_HEAD(test, tc) \ 687{ \ 688 atf_tc_set_md_var(tc, "descr", \ 689 "Verify masked crash signal " #sig " in a child after " \ 690 "PT_TRACE_ME is delivered to its tracer"); \ 691} \ 692 \ 693ATF_TC_BODY(test, tc) \ 694{ \ 695 \ 696 traceme_signalmasked_crash(sig); \ 697} 698 699TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_trap, SIGTRAP) 700TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_segv, SIGSEGV) 701TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_ill, SIGILL) 702TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_fpe, SIGFPE) 703TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_bus, SIGBUS) 704 705/// ---------------------------------------------------------------------------- 706 707static void 708traceme_signalignored_crash(int sig) 709{ 710 const int sigval = SIGSTOP; 711 pid_t child, wpid; 712#if defined(TWAIT_HAVE_STATUS) 713 int status; 714#endif 715 struct sigaction sa; 716 struct ptrace_siginfo info; 717 struct kinfo_proc2 kp; 718 size_t len = sizeof(kp); 719 720 int name[6]; 721 const size_t namelen = __arraycount(name); 722 ki_sigset_t kp_sigignore; 723 724#ifndef PTRACE_ILLEGAL_ASM 725 if (sig == SIGILL) 726 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 727#endif 728 729 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 730 atf_tc_skip("FP exceptions are not supported"); 731 732 memset(&info, 0, sizeof(info)); 733 734 DPRINTF("Before forking process PID=%d\n", getpid()); 735 SYSCALL_REQUIRE((child = fork()) != -1); 736 if (child == 0) { 737 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 738 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 739 740 memset(&sa, 0, sizeof(sa)); 741 sa.sa_handler = SIG_IGN; 742 sigemptyset(&sa.sa_mask); 743 744 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 745 746 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 747 FORKEE_ASSERT(raise(sigval) == 0); 748 749 DPRINTF("Before executing a trap\n"); 750 switch (sig) { 751 case SIGTRAP: 752 trigger_trap(); 753 break; 754 case SIGSEGV: 755 trigger_segv(); 756 break; 757 case SIGILL: 758 trigger_ill(); 759 break; 760 case SIGFPE: 761 trigger_fpe(); 762 break; 763 case SIGBUS: 764 trigger_bus(); 765 break; 766 default: 767 /* NOTREACHED */ 768 FORKEE_ASSERTX(0 && "This shall not be reached"); 769 } 770 771 /* NOTREACHED */ 772 FORKEE_ASSERTX(0 && "This shall not be reached"); 773 } 774 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 775 776 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 777 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 778 779 validate_status_stopped(status, sigval); 780 781 name[0] = CTL_KERN, 782 name[1] = KERN_PROC2, 783 name[2] = KERN_PROC_PID; 784 name[3] = child; 785 name[4] = sizeof(kp); 786 name[5] = 1; 787 788 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 789 790 kp_sigignore = kp.p_sigignore; 791 792 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 793 SYSCALL_REQUIRE( 794 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 795 796 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 797 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 798 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 799 info.psi_siginfo.si_errno); 800 801 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 802 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 803 804 DPRINTF("Before resuming the child process where it left off and " 805 "without signal to be sent\n"); 806 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 807 808 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 809 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 810 811 validate_status_stopped(status, sig); 812 813 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 814 SYSCALL_REQUIRE( 815 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 816 817 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 818 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 819 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 820 info.psi_siginfo.si_errno); 821 822 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 823 824 DPRINTF("kp_sigignore=" 825 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 826 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 827 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 828 829 DPRINTF("kp.p_sigignore=" 830 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 831 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 832 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 833 834 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, sizeof(kp_sigignore))); 835 836 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 837 switch (sig) { 838 case SIGTRAP: 839 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 840 break; 841 case SIGSEGV: 842 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 843 break; 844 case SIGILL: 845 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 846 info.psi_siginfo.si_code <= ILL_BADSTK); 847 break; 848 case SIGFPE: 849 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 850 break; 851 case SIGBUS: 852 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 853 break; 854 } 855 856 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 857 858 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 859 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 860 861 validate_status_signaled(status, SIGKILL, 0); 862 863 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 864 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 865} 866 867#define TRACEME_SIGNALIGNORED_CRASH(test, sig) \ 868ATF_TC(test); \ 869ATF_TC_HEAD(test, tc) \ 870{ \ 871 atf_tc_set_md_var(tc, "descr", \ 872 "Verify ignored crash signal " #sig " in a child after " \ 873 "PT_TRACE_ME is delivered to its tracer"); \ 874} \ 875 \ 876ATF_TC_BODY(test, tc) \ 877{ \ 878 \ 879 traceme_signalignored_crash(sig); \ 880} 881 882TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_trap, SIGTRAP) 883TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_segv, SIGSEGV) 884TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_ill, SIGILL) 885TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_fpe, SIGFPE) 886TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_bus, SIGBUS) 887 888/// ---------------------------------------------------------------------------- 889 890static void 891traceme_sendsignal_handle(int sigsent, void (*sah)(int a), int *traceme_caught) 892{ 893 const int exitval = 5; 894 const int sigval = SIGSTOP; 895 pid_t child, wpid; 896 struct sigaction sa; 897#if defined(TWAIT_HAVE_STATUS) 898 int status; 899#endif 900 struct ptrace_siginfo info; 901 902 memset(&info, 0, sizeof(info)); 903 904 DPRINTF("Before forking process PID=%d\n", getpid()); 905 SYSCALL_REQUIRE((child = fork()) != -1); 906 if (child == 0) { 907 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 908 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 909 910 sa.sa_handler = sah; 911 sa.sa_flags = SA_SIGINFO; 912 sigemptyset(&sa.sa_mask); 913 914 FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1); 915 916 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 917 FORKEE_ASSERT(raise(sigval) == 0); 918 919 FORKEE_ASSERT_EQ(*traceme_caught, 1); 920 921 DPRINTF("Before exiting of the child process\n"); 922 _exit(exitval); 923 } 924 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 925 926 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 927 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 928 929 validate_status_stopped(status, sigval); 930 931 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 932 SYSCALL_REQUIRE( 933 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 934 935 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 936 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 937 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 938 info.psi_siginfo.si_errno); 939 940 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 941 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 942 943 DPRINTF("Before resuming the child process where it left off and with " 944 "signal %s to be sent\n", strsignal(sigsent)); 945 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 946 947 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 948 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 949 950 validate_status_exited(status, exitval); 951 952 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 953 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 954} 955 956#define TRACEME_SENDSIGNAL_HANDLE(test, sig) \ 957ATF_TC(test); \ 958ATF_TC_HEAD(test, tc) \ 959{ \ 960 atf_tc_set_md_var(tc, "descr", \ 961 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 962 "handled correctly and caught by a signal handler"); \ 963} \ 964 \ 965static int test##_caught = 0; \ 966 \ 967static void \ 968test##_sighandler(int arg) \ 969{ \ 970 FORKEE_ASSERT_EQ(arg, sig); \ 971 \ 972 ++ test##_caught; \ 973} \ 974 \ 975ATF_TC_BODY(test, tc) \ 976{ \ 977 \ 978 traceme_sendsignal_handle(sig, test##_sighandler, & test##_caught); \ 979} 980 981// A signal handler for SIGKILL and SIGSTOP cannot be registered. 982TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle1, SIGABRT) /* abort trap */ 983TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle2, SIGHUP) /* hangup */ 984TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle3, SIGCONT) /* continued? */ 985TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle4, SIGTRAP) /* crash sig. */ 986TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle5, SIGBUS) /* crash sig. */ 987TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle6, SIGILL) /* crash sig. */ 988TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle7, SIGFPE) /* crash sig. */ 989TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle8, SIGSEGV) /* crash sig. */ 990 991/// ---------------------------------------------------------------------------- 992 993static void 994traceme_sendsignal_masked(int sigsent) 995{ 996 const int exitval = 5; 997 const int sigval = SIGSTOP; 998 pid_t child, wpid; 999 sigset_t set; 1000#if defined(TWAIT_HAVE_STATUS) 1001 int status; 1002#endif 1003 struct ptrace_siginfo info; 1004 1005 memset(&info, 0, sizeof(info)); 1006 1007 DPRINTF("Before forking process PID=%d\n", getpid()); 1008 SYSCALL_REQUIRE((child = fork()) != -1); 1009 if (child == 0) { 1010 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1011 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1012 1013 sigemptyset(&set); 1014 sigaddset(&set, sigsent); 1015 FORKEE_ASSERT(sigprocmask(SIG_BLOCK, &set, NULL) != -1); 1016 1017 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1018 FORKEE_ASSERT(raise(sigval) == 0); 1019 1020 _exit(exitval); 1021 } 1022 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1023 1024 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1025 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1026 1027 validate_status_stopped(status, sigval); 1028 1029 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1030 SYSCALL_REQUIRE( 1031 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1032 1033 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1034 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1035 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1036 info.psi_siginfo.si_errno); 1037 1038 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1039 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1040 1041 DPRINTF("Before resuming the child process where it left off and with " 1042 "signal %s to be sent\n", strsignal(sigsent)); 1043 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1044 1045 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1046 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1047 1048 validate_status_exited(status, exitval); 1049 1050 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1051 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1052} 1053 1054#define TRACEME_SENDSIGNAL_MASKED(test, sig) \ 1055ATF_TC(test); \ 1056ATF_TC_HEAD(test, tc) \ 1057{ \ 1058 atf_tc_set_md_var(tc, "descr", \ 1059 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1060 "handled correctly and the signal is masked by SIG_BLOCK"); \ 1061} \ 1062 \ 1063ATF_TC_BODY(test, tc) \ 1064{ \ 1065 \ 1066 traceme_sendsignal_masked(sig); \ 1067} 1068 1069// A signal handler for SIGKILL and SIGSTOP cannot be masked. 1070TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked1, SIGABRT) /* abort trap */ 1071TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked2, SIGHUP) /* hangup */ 1072TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked3, SIGCONT) /* continued? */ 1073TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked4, SIGTRAP) /* crash sig. */ 1074TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked5, SIGBUS) /* crash sig. */ 1075TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked6, SIGILL) /* crash sig. */ 1076TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked7, SIGFPE) /* crash sig. */ 1077TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked8, SIGSEGV) /* crash sig. */ 1078 1079/// ---------------------------------------------------------------------------- 1080 1081static void 1082traceme_sendsignal_ignored(int sigsent) 1083{ 1084 const int exitval = 5; 1085 const int sigval = SIGSTOP; 1086 pid_t child, wpid; 1087 struct sigaction sa; 1088#if defined(TWAIT_HAVE_STATUS) 1089 int status; 1090#endif 1091 struct ptrace_siginfo info; 1092 1093 memset(&info, 0, sizeof(info)); 1094 1095 DPRINTF("Before forking process PID=%d\n", getpid()); 1096 SYSCALL_REQUIRE((child = fork()) != -1); 1097 if (child == 0) { 1098 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1099 1100 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1101 1102 memset(&sa, 0, sizeof(sa)); 1103 sa.sa_handler = SIG_IGN; 1104 sigemptyset(&sa.sa_mask); 1105 FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1); 1106 1107 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1108 FORKEE_ASSERT(raise(sigval) == 0); 1109 1110 _exit(exitval); 1111 } 1112 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1113 1114 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1115 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1116 1117 validate_status_stopped(status, sigval); 1118 1119 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1120 SYSCALL_REQUIRE( 1121 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1122 1123 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1124 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1125 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1126 info.psi_siginfo.si_errno); 1127 1128 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1129 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1130 1131 DPRINTF("Before resuming the child process where it left off and with " 1132 "signal %s to be sent\n", strsignal(sigsent)); 1133 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1134 1135 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1136 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1137 1138 validate_status_exited(status, exitval); 1139 1140 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1141 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1142} 1143 1144#define TRACEME_SENDSIGNAL_IGNORED(test, sig) \ 1145ATF_TC(test); \ 1146ATF_TC_HEAD(test, tc) \ 1147{ \ 1148 atf_tc_set_md_var(tc, "descr", \ 1149 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1150 "handled correctly and the signal is masked by SIG_IGN"); \ 1151} \ 1152 \ 1153ATF_TC_BODY(test, tc) \ 1154{ \ 1155 \ 1156 traceme_sendsignal_ignored(sig); \ 1157} 1158 1159// A signal handler for SIGKILL and SIGSTOP cannot be ignored. 1160TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored1, SIGABRT) /* abort */ 1161TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored2, SIGHUP) /* hangup */ 1162TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored3, SIGCONT) /* continued */ 1163TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored4, SIGTRAP) /* crash s. */ 1164TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored5, SIGBUS) /* crash s. */ 1165TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored6, SIGILL) /* crash s. */ 1166TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored7, SIGFPE) /* crash s. */ 1167TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored8, SIGSEGV) /* crash s. */ 1168 1169/// ---------------------------------------------------------------------------- 1170 1171static void 1172traceme_sendsignal_simple(int sigsent) 1173{ 1174 const int sigval = SIGSTOP; 1175 int exitval = 0; 1176 pid_t child, wpid; 1177#if defined(TWAIT_HAVE_STATUS) 1178 int status; 1179 int expect_core; 1180 1181 switch (sigsent) { 1182 case SIGABRT: 1183 case SIGTRAP: 1184 case SIGBUS: 1185 case SIGILL: 1186 case SIGFPE: 1187 case SIGSEGV: 1188 expect_core = 1; 1189 break; 1190 default: 1191 expect_core = 0; 1192 break; 1193 } 1194#endif 1195 struct ptrace_siginfo info; 1196 1197 memset(&info, 0, sizeof(info)); 1198 1199 DPRINTF("Before forking process PID=%d\n", getpid()); 1200 SYSCALL_REQUIRE((child = fork()) != -1); 1201 if (child == 0) { 1202 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1203 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1204 1205 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1206 FORKEE_ASSERT(raise(sigval) == 0); 1207 1208 switch (sigsent) { 1209 case SIGCONT: 1210 case SIGSTOP: 1211 _exit(exitval); 1212 default: 1213 /* NOTREACHED */ 1214 FORKEE_ASSERTX(0 && "This shall not be reached"); 1215 } 1216 } 1217 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1218 1219 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1220 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1221 1222 validate_status_stopped(status, sigval); 1223 1224 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1225 SYSCALL_REQUIRE( 1226 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1227 1228 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1229 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1230 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1231 info.psi_siginfo.si_errno); 1232 1233 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1234 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1235 1236 DPRINTF("Before resuming the child process where it left off and with " 1237 "signal %s to be sent\n", strsignal(sigsent)); 1238 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1239 1240 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1241 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1242 1243 switch (sigsent) { 1244 case SIGSTOP: 1245 validate_status_stopped(status, sigsent); 1246 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 1247 "child\n"); 1248 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 1249 sizeof(info)) != -1); 1250 1251 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1252 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 1253 "si_errno=%#x\n", 1254 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1255 info.psi_siginfo.si_errno); 1256 1257 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1258 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1259 1260 DPRINTF("Before resuming the child process where it left off " 1261 "and with signal %s to be sent\n", strsignal(sigsent)); 1262 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 1263 1264 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1265 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 1266 child); 1267 /* FALLTHROUGH */ 1268 case SIGCONT: 1269 validate_status_exited(status, exitval); 1270 break; 1271 default: 1272 validate_status_signaled(status, sigsent, expect_core); 1273 break; 1274 } 1275 1276 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1277 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1278} 1279 1280#define TRACEME_SENDSIGNAL_SIMPLE(test, sig) \ 1281ATF_TC(test); \ 1282ATF_TC_HEAD(test, tc) \ 1283{ \ 1284 atf_tc_set_md_var(tc, "descr", \ 1285 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1286 "handled correctly in a child without a signal handler"); \ 1287} \ 1288 \ 1289ATF_TC_BODY(test, tc) \ 1290{ \ 1291 \ 1292 traceme_sendsignal_simple(sig); \ 1293} 1294 1295TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple1, SIGKILL) /* non-maskable*/ 1296TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple2, SIGSTOP) /* non-maskable*/ 1297TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple3, SIGABRT) /* abort trap */ 1298TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple4, SIGHUP) /* hangup */ 1299TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple5, SIGCONT) /* continued? */ 1300TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple6, SIGTRAP) /* crash sig. */ 1301TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple7, SIGBUS) /* crash sig. */ 1302TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple8, SIGILL) /* crash sig. */ 1303TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple9, SIGFPE) /* crash sig. */ 1304TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple10, SIGSEGV) /* crash sig. */ 1305 1306/// ---------------------------------------------------------------------------- 1307 1308ATF_TC(traceme_pid1_parent); 1309ATF_TC_HEAD(traceme_pid1_parent, tc) 1310{ 1311 atf_tc_set_md_var(tc, "descr", 1312 "Verify that PT_TRACE_ME is not allowed when our parent is PID1"); 1313} 1314 1315ATF_TC_BODY(traceme_pid1_parent, tc) 1316{ 1317 struct msg_fds parent_child; 1318 int exitval_child1 = 1, exitval_child2 = 2; 1319 pid_t child1, child2, wpid; 1320 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 1321#if defined(TWAIT_HAVE_STATUS) 1322 int status; 1323#endif 1324 1325 SYSCALL_REQUIRE(msg_open(&parent_child) == 0); 1326 1327 DPRINTF("Before forking process PID=%d\n", getpid()); 1328 SYSCALL_REQUIRE((child1 = fork()) != -1); 1329 if (child1 == 0) { 1330 DPRINTF("Before forking process PID=%d\n", getpid()); 1331 SYSCALL_REQUIRE((child2 = fork()) != -1); 1332 if (child2 != 0) { 1333 DPRINTF("Parent process PID=%d, child2's PID=%d\n", 1334 getpid(), child2); 1335 _exit(exitval_child1); 1336 } 1337 CHILD_FROM_PARENT("exit child1", parent_child, msg); 1338 1339 DPRINTF("Assert that our parent is PID1 (initproc)\n"); 1340 FORKEE_ASSERT_EQ(getppid(), 1); 1341 1342 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1343 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) == -1); 1344 SYSCALL_REQUIRE_ERRNO(errno, EPERM); 1345 1346 CHILD_TO_PARENT("child2 exiting", parent_child, msg); 1347 1348 _exit(exitval_child2); 1349 } 1350 DPRINTF("Parent process PID=%d, child1's PID=%d\n", getpid(), child1); 1351 1352 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1353 TWAIT_REQUIRE_SUCCESS( 1354 wpid = TWAIT_GENERIC(child1, &status, WEXITED), child1); 1355 1356 validate_status_exited(status, exitval_child1); 1357 1358 DPRINTF("Notify that child1 is dead\n"); 1359 PARENT_TO_CHILD("exit child1", parent_child, msg); 1360 1361 DPRINTF("Wait for exiting of child2\n"); 1362 PARENT_FROM_CHILD("child2 exiting", parent_child, msg); 1363} 1364 1365/// ---------------------------------------------------------------------------- 1366 1367static void 1368traceme_vfork_raise(int sigval) 1369{ 1370 const int exitval = 5, exitval_watcher = 10; 1371 pid_t child, parent, watcher, wpid; 1372 int rv; 1373#if defined(TWAIT_HAVE_STATUS) 1374 int status; 1375 1376 /* volatile workarounds GCC -Werror=clobbered */ 1377 volatile int expect_core; 1378 1379 switch (sigval) { 1380 case SIGABRT: 1381 case SIGTRAP: 1382 case SIGBUS: 1383 case SIGILL: 1384 case SIGFPE: 1385 case SIGSEGV: 1386 expect_core = 1; 1387 break; 1388 default: 1389 expect_core = 0; 1390 break; 1391 } 1392#endif 1393 1394 /* 1395 * Spawn a dedicated thread to watch for a stopped child and emit 1396 * the SIGKILL signal to it. 1397 * 1398 * vfork(2) might clobber watcher, this means that it's safer and 1399 * simpler to reparent this process to initproc and forget about it. 1400 */ 1401 if (sigval == SIGSTOP) { 1402 parent = getpid(); 1403 1404 watcher = fork(); 1405 ATF_REQUIRE(watcher != 1); 1406 if (watcher == 0) { 1407 /* Double fork(2) trick to reparent to initproc */ 1408 watcher = fork(); 1409 FORKEE_ASSERT_NEQ(watcher, -1); 1410 if (watcher != 0) 1411 _exit(exitval_watcher); 1412 1413 child = await_stopped_child(parent); 1414 1415 errno = 0; 1416 rv = kill(child, SIGKILL); 1417 FORKEE_ASSERT_EQ(rv, 0); 1418 FORKEE_ASSERT_EQ(errno, 0); 1419 1420 /* This exit value will be collected by initproc */ 1421 _exit(0); 1422 } 1423 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1424 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(watcher, &status, 0), 1425 watcher); 1426 1427 validate_status_exited(status, exitval_watcher); 1428 1429 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1430 TWAIT_REQUIRE_FAILURE(ECHILD, 1431 wpid = TWAIT_GENERIC(watcher, &status, 0)); 1432 } 1433 1434 DPRINTF("Before forking process PID=%d\n", getpid()); 1435 SYSCALL_REQUIRE((child = vfork()) != -1); 1436 if (child == 0) { 1437 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1438 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1439 1440 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1441 FORKEE_ASSERT(raise(sigval) == 0); 1442 1443 switch (sigval) { 1444 case SIGSTOP: 1445 case SIGKILL: 1446 case SIGABRT: 1447 case SIGHUP: 1448 case SIGTRAP: 1449 case SIGBUS: 1450 case SIGILL: 1451 case SIGFPE: 1452 case SIGSEGV: 1453 /* NOTREACHED */ 1454 FORKEE_ASSERTX(0 && "This shall not be reached"); 1455 __unreachable(); 1456 default: 1457 DPRINTF("Before exiting of the child process\n"); 1458 _exit(exitval); 1459 } 1460 } 1461 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1462 1463 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1464 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1465 1466 switch (sigval) { 1467 case SIGKILL: 1468 case SIGABRT: 1469 case SIGHUP: 1470 case SIGTRAP: 1471 case SIGBUS: 1472 case SIGILL: 1473 case SIGFPE: 1474 case SIGSEGV: 1475 validate_status_signaled(status, sigval, expect_core); 1476 break; 1477 case SIGSTOP: 1478 validate_status_signaled(status, SIGKILL, 0); 1479 break; 1480 case SIGCONT: 1481 case SIGTSTP: 1482 case SIGTTIN: 1483 case SIGTTOU: 1484 validate_status_exited(status, exitval); 1485 break; 1486 default: 1487 /* NOTREACHED */ 1488 ATF_REQUIRE(0 && "NOT IMPLEMENTED"); 1489 break; 1490 } 1491 1492 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1493 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1494} 1495 1496#define TRACEME_VFORK_RAISE(test, sig) \ 1497ATF_TC(test); \ 1498ATF_TC_HEAD(test, tc) \ 1499{ \ 1500 atf_tc_set_md_var(tc, "descr", \ 1501 "Verify PT_TRACE_ME followed by raise of " #sig " in a " \ 1502 "vfork(2)ed child"); \ 1503} \ 1504 \ 1505ATF_TC_BODY(test, tc) \ 1506{ \ 1507 \ 1508 traceme_vfork_raise(sig); \ 1509} 1510 1511TRACEME_VFORK_RAISE(traceme_vfork_raise1, SIGKILL) /* non-maskable */ 1512TRACEME_VFORK_RAISE(traceme_vfork_raise2, SIGSTOP) /* non-maskable */ 1513TRACEME_VFORK_RAISE(traceme_vfork_raise3, SIGTSTP) /* ignored in vfork(2) */ 1514TRACEME_VFORK_RAISE(traceme_vfork_raise4, SIGTTIN) /* ignored in vfork(2) */ 1515TRACEME_VFORK_RAISE(traceme_vfork_raise5, SIGTTOU) /* ignored in vfork(2) */ 1516TRACEME_VFORK_RAISE(traceme_vfork_raise6, SIGABRT) /* regular abort trap */ 1517TRACEME_VFORK_RAISE(traceme_vfork_raise7, SIGHUP) /* hangup */ 1518TRACEME_VFORK_RAISE(traceme_vfork_raise8, SIGCONT) /* continued? */ 1519TRACEME_VFORK_RAISE(traceme_vfork_raise9, SIGTRAP) /* crash signal */ 1520TRACEME_VFORK_RAISE(traceme_vfork_raise10, SIGBUS) /* crash signal */ 1521TRACEME_VFORK_RAISE(traceme_vfork_raise11, SIGILL) /* crash signal */ 1522TRACEME_VFORK_RAISE(traceme_vfork_raise12, SIGFPE) /* crash signal */ 1523TRACEME_VFORK_RAISE(traceme_vfork_raise13, SIGSEGV) /* crash signal */ 1524 1525/// ---------------------------------------------------------------------------- 1526 1527static void 1528traceme_vfork_crash(int sig) 1529{ 1530 pid_t child, wpid; 1531#if defined(TWAIT_HAVE_STATUS) 1532 int status; 1533#endif 1534 1535#ifndef PTRACE_ILLEGAL_ASM 1536 if (sig == SIGILL) 1537 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1538#endif 1539 1540 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1541 atf_tc_skip("FP exceptions are not supported"); 1542 1543 DPRINTF("Before forking process PID=%d\n", getpid()); 1544 SYSCALL_REQUIRE((child = vfork()) != -1); 1545 if (child == 0) { 1546 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1547 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1548 1549 DPRINTF("Before executing a trap\n"); 1550 switch (sig) { 1551 case SIGTRAP: 1552 trigger_trap(); 1553 break; 1554 case SIGSEGV: 1555 trigger_segv(); 1556 break; 1557 case SIGILL: 1558 trigger_ill(); 1559 break; 1560 case SIGFPE: 1561 trigger_fpe(); 1562 break; 1563 case SIGBUS: 1564 trigger_bus(); 1565 break; 1566 default: 1567 /* NOTREACHED */ 1568 FORKEE_ASSERTX(0 && "This shall not be reached"); 1569 } 1570 1571 /* NOTREACHED */ 1572 FORKEE_ASSERTX(0 && "This shall not be reached"); 1573 } 1574 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1575 1576 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1577 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1578 1579 validate_status_signaled(status, sig, 1); 1580 1581 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1582 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1583} 1584 1585#define TRACEME_VFORK_CRASH(test, sig) \ 1586ATF_TC(test); \ 1587ATF_TC_HEAD(test, tc) \ 1588{ \ 1589 atf_tc_set_md_var(tc, "descr", \ 1590 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1591 "vfork(2)ed child"); \ 1592} \ 1593 \ 1594ATF_TC_BODY(test, tc) \ 1595{ \ 1596 \ 1597 traceme_vfork_crash(sig); \ 1598} 1599 1600TRACEME_VFORK_CRASH(traceme_vfork_crash_trap, SIGTRAP) 1601TRACEME_VFORK_CRASH(traceme_vfork_crash_segv, SIGSEGV) 1602TRACEME_VFORK_CRASH(traceme_vfork_crash_ill, SIGILL) 1603TRACEME_VFORK_CRASH(traceme_vfork_crash_fpe, SIGFPE) 1604TRACEME_VFORK_CRASH(traceme_vfork_crash_bus, SIGBUS) 1605 1606/// ---------------------------------------------------------------------------- 1607 1608static void 1609traceme_vfork_signalmasked_crash(int sig) 1610{ 1611 pid_t child, wpid; 1612#if defined(TWAIT_HAVE_STATUS) 1613 int status; 1614#endif 1615 sigset_t intmask; 1616 1617#ifndef PTRACE_ILLEGAL_ASM 1618 if (sig == SIGILL) 1619 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1620#endif 1621 1622 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1623 atf_tc_skip("FP exceptions are not supported"); 1624 1625 DPRINTF("Before forking process PID=%d\n", getpid()); 1626 SYSCALL_REQUIRE((child = vfork()) != -1); 1627 if (child == 0) { 1628 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1629 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1630 1631 sigemptyset(&intmask); 1632 sigaddset(&intmask, sig); 1633 sigprocmask(SIG_BLOCK, &intmask, NULL); 1634 1635 DPRINTF("Before executing a trap\n"); 1636 switch (sig) { 1637 case SIGTRAP: 1638 trigger_trap(); 1639 break; 1640 case SIGSEGV: 1641 trigger_segv(); 1642 break; 1643 case SIGILL: 1644 trigger_ill(); 1645 break; 1646 case SIGFPE: 1647 trigger_fpe(); 1648 break; 1649 case SIGBUS: 1650 trigger_bus(); 1651 break; 1652 default: 1653 /* NOTREACHED */ 1654 FORKEE_ASSERTX(0 && "This shall not be reached"); 1655 } 1656 1657 /* NOTREACHED */ 1658 FORKEE_ASSERTX(0 && "This shall not be reached"); 1659 } 1660 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1661 1662 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1663 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1664 1665 validate_status_signaled(status, sig, 1); 1666 1667 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1668 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1669} 1670 1671#define TRACEME_VFORK_SIGNALMASKED_CRASH(test, sig) \ 1672ATF_TC(test); \ 1673ATF_TC_HEAD(test, tc) \ 1674{ \ 1675 atf_tc_set_md_var(tc, "descr", \ 1676 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1677 "vfork(2)ed child with a masked signal"); \ 1678} \ 1679 \ 1680ATF_TC_BODY(test, tc) \ 1681{ \ 1682 \ 1683 traceme_vfork_signalmasked_crash(sig); \ 1684} 1685 1686TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_trap, SIGTRAP) 1687TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_segv, SIGSEGV) 1688TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_ill, SIGILL) 1689TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_fpe, SIGFPE) 1690TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_bus, SIGBUS) 1691 1692/// ---------------------------------------------------------------------------- 1693 1694static void 1695traceme_vfork_signalignored_crash(int sig) 1696{ 1697 pid_t child, wpid; 1698#if defined(TWAIT_HAVE_STATUS) 1699 int status; 1700#endif 1701 struct sigaction sa; 1702 1703#ifndef PTRACE_ILLEGAL_ASM 1704 if (sig == SIGILL) 1705 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1706#endif 1707 1708 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1709 atf_tc_skip("FP exceptions are not supported"); 1710 1711 DPRINTF("Before forking process PID=%d\n", getpid()); 1712 SYSCALL_REQUIRE((child = vfork()) != -1); 1713 if (child == 0) { 1714 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1715 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1716 1717 memset(&sa, 0, sizeof(sa)); 1718 sa.sa_handler = SIG_IGN; 1719 sigemptyset(&sa.sa_mask); 1720 1721 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 1722 1723 DPRINTF("Before executing a trap\n"); 1724 switch (sig) { 1725 case SIGTRAP: 1726 trigger_trap(); 1727 break; 1728 case SIGSEGV: 1729 trigger_segv(); 1730 break; 1731 case SIGILL: 1732 trigger_ill(); 1733 break; 1734 case SIGFPE: 1735 trigger_fpe(); 1736 break; 1737 case SIGBUS: 1738 trigger_bus(); 1739 break; 1740 default: 1741 /* NOTREACHED */ 1742 FORKEE_ASSERTX(0 && "This shall not be reached"); 1743 } 1744 1745 /* NOTREACHED */ 1746 FORKEE_ASSERTX(0 && "This shall not be reached"); 1747 } 1748 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1749 1750 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1751 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1752 1753 validate_status_signaled(status, sig, 1); 1754 1755 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1756 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1757} 1758 1759#define TRACEME_VFORK_SIGNALIGNORED_CRASH(test, sig) \ 1760ATF_TC(test); \ 1761ATF_TC_HEAD(test, tc) \ 1762{ \ 1763 atf_tc_set_md_var(tc, "descr", \ 1764 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1765 "vfork(2)ed child with ignored signal"); \ 1766} \ 1767 \ 1768ATF_TC_BODY(test, tc) \ 1769{ \ 1770 \ 1771 traceme_vfork_signalignored_crash(sig); \ 1772} 1773 1774TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_trap, 1775 SIGTRAP) 1776TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_segv, 1777 SIGSEGV) 1778TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_ill, 1779 SIGILL) 1780TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_fpe, 1781 SIGFPE) 1782TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_bus, 1783 SIGBUS) 1784 1785/// ---------------------------------------------------------------------------- 1786 1787static void 1788traceme_vfork_exec(bool masked, bool ignored) 1789{ 1790 const int sigval = SIGTRAP; 1791 pid_t child, wpid; 1792#if defined(TWAIT_HAVE_STATUS) 1793 int status; 1794#endif 1795 struct sigaction sa; 1796 struct ptrace_siginfo info; 1797 sigset_t intmask; 1798 struct kinfo_proc2 kp; 1799 size_t len = sizeof(kp); 1800 1801 int name[6]; 1802 const size_t namelen = __arraycount(name); 1803 ki_sigset_t kp_sigmask; 1804 ki_sigset_t kp_sigignore; 1805 1806 memset(&info, 0, sizeof(info)); 1807 1808 DPRINTF("Before forking process PID=%d\n", getpid()); 1809 SYSCALL_REQUIRE((child = vfork()) != -1); 1810 if (child == 0) { 1811 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1812 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1813 1814 if (masked) { 1815 sigemptyset(&intmask); 1816 sigaddset(&intmask, sigval); 1817 sigprocmask(SIG_BLOCK, &intmask, NULL); 1818 } 1819 1820 if (ignored) { 1821 memset(&sa, 0, sizeof(sa)); 1822 sa.sa_handler = SIG_IGN; 1823 sigemptyset(&sa.sa_mask); 1824 FORKEE_ASSERT(sigaction(sigval, &sa, NULL) != -1); 1825 } 1826 1827 DPRINTF("Before calling execve(2) from child\n"); 1828 execlp("/bin/echo", "/bin/echo", NULL); 1829 1830 /* NOTREACHED */ 1831 FORKEE_ASSERTX(0 && "Not reached"); 1832 } 1833 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1834 1835 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1836 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1837 1838 validate_status_stopped(status, sigval); 1839 1840 name[0] = CTL_KERN, 1841 name[1] = KERN_PROC2, 1842 name[2] = KERN_PROC_PID; 1843 name[3] = getpid(); 1844 name[4] = sizeof(kp); 1845 name[5] = 1; 1846 1847 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 1848 1849 if (masked) 1850 kp_sigmask = kp.p_sigmask; 1851 1852 if (ignored) 1853 kp_sigignore = kp.p_sigignore; 1854 1855 name[3] = getpid(); 1856 1857 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 1858 1859 if (masked) { 1860 DPRINTF("kp_sigmask=" 1861 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1862 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 1863 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 1864 1865 DPRINTF("kp.p_sigmask=" 1866 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1867 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 1868 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 1869 1870 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 1871 sizeof(kp_sigmask))); 1872 } 1873 1874 if (ignored) { 1875 DPRINTF("kp_sigignore=" 1876 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1877 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 1878 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 1879 1880 DPRINTF("kp.p_sigignore=" 1881 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1882 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 1883 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 1884 1885 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 1886 sizeof(kp_sigignore))); 1887 } 1888 1889 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1890 SYSCALL_REQUIRE( 1891 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1892 1893 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1894 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1895 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1896 info.psi_siginfo.si_errno); 1897 1898 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1899 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_EXEC); 1900 1901 DPRINTF("Before resuming the child process where it left off and " 1902 "without signal to be sent\n"); 1903 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 1904 1905 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1906 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1907 1908 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1909 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1910} 1911 1912#define TRACEME_VFORK_EXEC(test, masked, ignored) \ 1913ATF_TC(test); \ 1914ATF_TC_HEAD(test, tc) \ 1915{ \ 1916 atf_tc_set_md_var(tc, "descr", \ 1917 "Verify PT_TRACE_ME followed by exec(3) in a vfork(2)ed " \ 1918 "child%s%s", masked ? " with masked signal" : "", \ 1919 masked ? " with ignored signal" : ""); \ 1920} \ 1921 \ 1922ATF_TC_BODY(test, tc) \ 1923{ \ 1924 \ 1925 traceme_vfork_exec(masked, ignored); \ 1926} 1927 1928TRACEME_VFORK_EXEC(traceme_vfork_exec, false, false) 1929TRACEME_VFORK_EXEC(traceme_vfork_signalmasked_exec, true, false) 1930TRACEME_VFORK_EXEC(traceme_vfork_signalignored_exec, false, true) 1931 1932/// ---------------------------------------------------------------------------- 1933 1934#if defined(TWAIT_HAVE_PID) 1935static void 1936unrelated_tracer_sees_crash(int sig, bool masked, bool ignored) 1937{ 1938 const int sigval = SIGSTOP; 1939 struct msg_fds parent_tracee, parent_tracer; 1940 const int exitval = 10; 1941 pid_t tracee, tracer, wpid; 1942 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 1943#if defined(TWAIT_HAVE_STATUS) 1944 int status; 1945#endif 1946 struct sigaction sa; 1947 struct ptrace_siginfo info; 1948 sigset_t intmask; 1949 struct kinfo_proc2 kp; 1950 size_t len = sizeof(kp); 1951 1952 int name[6]; 1953 const size_t namelen = __arraycount(name); 1954 ki_sigset_t kp_sigmask; 1955 ki_sigset_t kp_sigignore; 1956 1957#ifndef PTRACE_ILLEGAL_ASM 1958 if (sig == SIGILL) 1959 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1960#endif 1961 1962 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1963 atf_tc_skip("FP exceptions are not supported"); 1964 1965 memset(&info, 0, sizeof(info)); 1966 1967 DPRINTF("Spawn tracee\n"); 1968 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 1969 tracee = atf_utils_fork(); 1970 if (tracee == 0) { 1971 // Wait for parent to let us crash 1972 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 1973 1974 if (masked) { 1975 sigemptyset(&intmask); 1976 sigaddset(&intmask, sig); 1977 sigprocmask(SIG_BLOCK, &intmask, NULL); 1978 } 1979 1980 if (ignored) { 1981 memset(&sa, 0, sizeof(sa)); 1982 sa.sa_handler = SIG_IGN; 1983 sigemptyset(&sa.sa_mask); 1984 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 1985 } 1986 1987 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1988 FORKEE_ASSERT(raise(sigval) == 0); 1989 1990 DPRINTF("Before executing a trap\n"); 1991 switch (sig) { 1992 case SIGTRAP: 1993 trigger_trap(); 1994 break; 1995 case SIGSEGV: 1996 trigger_segv(); 1997 break; 1998 case SIGILL: 1999 trigger_ill(); 2000 break; 2001 case SIGFPE: 2002 trigger_fpe(); 2003 break; 2004 case SIGBUS: 2005 trigger_bus(); 2006 break; 2007 default: 2008 /* NOTREACHED */ 2009 FORKEE_ASSERTX(0 && "This shall not be reached"); 2010 } 2011 2012 /* NOTREACHED */ 2013 FORKEE_ASSERTX(0 && "This shall not be reached"); 2014 } 2015 2016 DPRINTF("Spawn debugger\n"); 2017 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2018 tracer = atf_utils_fork(); 2019 if (tracer == 0) { 2020 /* Fork again and drop parent to reattach to PID 1 */ 2021 tracer = atf_utils_fork(); 2022 if (tracer != 0) 2023 _exit(exitval); 2024 2025 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2026 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2027 2028 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2029 FORKEE_REQUIRE_SUCCESS( 2030 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2031 2032 forkee_status_stopped(status, SIGSTOP); 2033 2034 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2035 "traced process\n"); 2036 SYSCALL_REQUIRE( 2037 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2038 2039 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2040 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2041 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2042 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2043 2044 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, SIGSTOP); 2045 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_USER); 2046 2047 /* Resume tracee with PT_CONTINUE */ 2048 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2049 2050 /* Inform parent that tracer has attached to tracee */ 2051 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2052 2053 /* Wait for parent to tell use that tracee should have exited */ 2054 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2055 2056 /* Wait for tracee and assert that it exited */ 2057 FORKEE_REQUIRE_SUCCESS( 2058 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2059 2060 forkee_status_stopped(status, sigval); 2061 2062 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2063 "traced process\n"); 2064 SYSCALL_REQUIRE( 2065 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2066 2067 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2068 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2069 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2070 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2071 2072 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sigval); 2073 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_LWP); 2074 2075 name[0] = CTL_KERN, 2076 name[1] = KERN_PROC2, 2077 name[2] = KERN_PROC_PID; 2078 name[3] = tracee; 2079 name[4] = sizeof(kp); 2080 name[5] = 1; 2081 2082 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2083 2084 if (masked) 2085 kp_sigmask = kp.p_sigmask; 2086 2087 if (ignored) 2088 kp_sigignore = kp.p_sigignore; 2089 2090 /* Resume tracee with PT_CONTINUE */ 2091 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2092 2093 /* Wait for tracee and assert that it exited */ 2094 FORKEE_REQUIRE_SUCCESS( 2095 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2096 2097 forkee_status_stopped(status, sig); 2098 2099 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2100 "traced process\n"); 2101 SYSCALL_REQUIRE( 2102 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2103 2104 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2105 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2106 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2107 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2108 2109 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sig); 2110 2111 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2112 2113 if (masked) { 2114 DPRINTF("kp_sigmask=" 2115 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2116 PRIx32 "\n", 2117 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 2118 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 2119 2120 DPRINTF("kp.p_sigmask=" 2121 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2122 PRIx32 "\n", 2123 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 2124 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 2125 2126 FORKEE_ASSERTX(!memcmp(&kp_sigmask, &kp.p_sigmask, 2127 sizeof(kp_sigmask))); 2128 } 2129 2130 if (ignored) { 2131 DPRINTF("kp_sigignore=" 2132 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2133 PRIx32 "\n", 2134 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 2135 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 2136 2137 DPRINTF("kp.p_sigignore=" 2138 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2139 PRIx32 "\n", 2140 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 2141 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 2142 2143 FORKEE_ASSERTX(!memcmp(&kp_sigignore, &kp.p_sigignore, 2144 sizeof(kp_sigignore))); 2145 } 2146 2147 switch (sig) { 2148 case SIGTRAP: 2149 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 2150 break; 2151 case SIGSEGV: 2152 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 2153 break; 2154 case SIGILL: 2155 FORKEE_ASSERT(info.psi_siginfo.si_code >= ILL_ILLOPC && 2156 info.psi_siginfo.si_code <= ILL_BADSTK); 2157 break; 2158 case SIGFPE: 2159 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 2160 break; 2161 case SIGBUS: 2162 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 2163 break; 2164 } 2165 2166 FORKEE_ASSERT(ptrace(PT_KILL, tracee, NULL, 0) != -1); 2167 DPRINTF("Before calling %s() for the tracee\n", TWAIT_FNAME); 2168 FORKEE_REQUIRE_SUCCESS( 2169 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2170 2171 forkee_status_signaled(status, SIGKILL, 0); 2172 2173 /* Inform parent that tracer is exiting normally */ 2174 CHILD_TO_PARENT("tracer done", parent_tracer, msg); 2175 2176 DPRINTF("Before exiting of the tracer process\n"); 2177 _exit(0 /* collect by initproc */); 2178 } 2179 2180 DPRINTF("Wait for the tracer process (direct child) to exit " 2181 "calling %s()\n", TWAIT_FNAME); 2182 TWAIT_REQUIRE_SUCCESS( 2183 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2184 2185 validate_status_exited(status, exitval); 2186 2187 DPRINTF("Wait for the non-exited tracee process with %s()\n", 2188 TWAIT_FNAME); 2189 TWAIT_REQUIRE_SUCCESS( 2190 wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0); 2191 2192 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2193 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2194 2195 DPRINTF("Resume the tracee and let it crash\n"); 2196 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2197 2198 DPRINTF("Resume the tracer and let it detect crashed tracee\n"); 2199 PARENT_TO_CHILD("Message 2", parent_tracer, msg); 2200 2201 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2202 TWAIT_FNAME); 2203 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2204 2205 validate_status_signaled(status, SIGKILL, 0); 2206 2207 DPRINTF("Await normal exit of tracer\n"); 2208 PARENT_FROM_CHILD("tracer done", parent_tracer, msg); 2209 2210 msg_close(&parent_tracer); 2211 msg_close(&parent_tracee); 2212} 2213 2214#define UNRELATED_TRACER_SEES_CRASH(test, sig) \ 2215ATF_TC(test); \ 2216ATF_TC_HEAD(test, tc) \ 2217{ \ 2218 atf_tc_set_md_var(tc, "descr", \ 2219 "Assert that an unrelated tracer sees crash signal from " \ 2220 "the debuggee"); \ 2221} \ 2222 \ 2223ATF_TC_BODY(test, tc) \ 2224{ \ 2225 \ 2226 unrelated_tracer_sees_crash(sig, false, false); \ 2227} 2228 2229UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_trap, SIGTRAP) 2230UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_segv, SIGSEGV) 2231UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_ill, SIGILL) 2232UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_fpe, SIGFPE) 2233UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_bus, SIGBUS) 2234 2235#define UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(test, sig) \ 2236ATF_TC(test); \ 2237ATF_TC_HEAD(test, tc) \ 2238{ \ 2239 atf_tc_set_md_var(tc, "descr", \ 2240 "Assert that an unrelated tracer sees crash signal from " \ 2241 "the debuggee with masked signal"); \ 2242} \ 2243 \ 2244ATF_TC_BODY(test, tc) \ 2245{ \ 2246 \ 2247 unrelated_tracer_sees_crash(sig, true, false); \ 2248} 2249 2250UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2251 unrelated_tracer_sees_signalmasked_crash_trap, SIGTRAP) 2252UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2253 unrelated_tracer_sees_signalmasked_crash_segv, SIGSEGV) 2254UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2255 unrelated_tracer_sees_signalmasked_crash_ill, SIGILL) 2256UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2257 unrelated_tracer_sees_signalmasked_crash_fpe, SIGFPE) 2258UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2259 unrelated_tracer_sees_signalmasked_crash_bus, SIGBUS) 2260 2261#define UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(test, sig) \ 2262ATF_TC(test); \ 2263ATF_TC_HEAD(test, tc) \ 2264{ \ 2265 atf_tc_set_md_var(tc, "descr", \ 2266 "Assert that an unrelated tracer sees crash signal from " \ 2267 "the debuggee with signal ignored"); \ 2268} \ 2269 \ 2270ATF_TC_BODY(test, tc) \ 2271{ \ 2272 \ 2273 unrelated_tracer_sees_crash(sig, false, true); \ 2274} 2275 2276UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2277 unrelated_tracer_sees_signalignored_crash_trap, SIGTRAP) 2278UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2279 unrelated_tracer_sees_signalignored_crash_segv, SIGSEGV) 2280UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2281 unrelated_tracer_sees_signalignored_crash_ill, SIGILL) 2282UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2283 unrelated_tracer_sees_signalignored_crash_fpe, SIGFPE) 2284UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2285 unrelated_tracer_sees_signalignored_crash_bus, SIGBUS) 2286#endif 2287 2288/// ---------------------------------------------------------------------------- 2289 2290#if defined(TWAIT_HAVE_PID) 2291static void 2292tracer_sees_terminaton_before_the_parent_raw(bool notimeout, bool unrelated, 2293 bool stopped) 2294{ 2295 /* 2296 * notimeout - disable timeout in await zombie function 2297 * unrelated - attach from unrelated tracer reparented to initproc 2298 * stopped - attach to a stopped process 2299 */ 2300 2301 struct msg_fds parent_tracee, parent_tracer; 2302 const int exitval_tracee = 5; 2303 const int exitval_tracer = 10; 2304 pid_t tracee, tracer, wpid; 2305 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2306#if defined(TWAIT_HAVE_STATUS) 2307 int status; 2308#endif 2309 2310 /* 2311 * Only a subset of options are supported. 2312 */ 2313 ATF_REQUIRE((!notimeout && !unrelated && !stopped) || 2314 (!notimeout && unrelated && !stopped) || 2315 (notimeout && !unrelated && !stopped) || 2316 (!notimeout && unrelated && stopped)); 2317 2318 DPRINTF("Spawn tracee\n"); 2319 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2320 tracee = atf_utils_fork(); 2321 if (tracee == 0) { 2322 if (stopped) { 2323 DPRINTF("Stop self PID %d\n", getpid()); 2324 raise(SIGSTOP); 2325 } 2326 2327 // Wait for parent to let us exit 2328 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 2329 _exit(exitval_tracee); 2330 } 2331 2332 DPRINTF("Spawn debugger\n"); 2333 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2334 tracer = atf_utils_fork(); 2335 if (tracer == 0) { 2336 if(unrelated) { 2337 /* Fork again and drop parent to reattach to PID 1 */ 2338 tracer = atf_utils_fork(); 2339 if (tracer != 0) 2340 _exit(exitval_tracer); 2341 } 2342 2343 if (stopped) { 2344 DPRINTF("Await for a stopped parent PID %d\n", tracee); 2345 await_stopped(tracee); 2346 } 2347 2348 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2349 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2350 2351 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2352 FORKEE_REQUIRE_SUCCESS( 2353 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2354 2355 forkee_status_stopped(status, SIGSTOP); 2356 2357 /* Resume tracee with PT_CONTINUE */ 2358 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2359 2360 /* Inform parent that tracer has attached to tracee */ 2361 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2362 2363 /* Wait for parent to tell use that tracee should have exited */ 2364 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2365 2366 /* Wait for tracee and assert that it exited */ 2367 FORKEE_REQUIRE_SUCCESS( 2368 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2369 2370 forkee_status_exited(status, exitval_tracee); 2371 DPRINTF("Tracee %d exited with %d\n", tracee, exitval_tracee); 2372 2373 DPRINTF("Before exiting of the tracer process\n"); 2374 _exit(unrelated ? 0 /* collect by initproc */ : exitval_tracer); 2375 } 2376 2377 if (unrelated) { 2378 DPRINTF("Wait for the tracer process (direct child) to exit " 2379 "calling %s()\n", TWAIT_FNAME); 2380 TWAIT_REQUIRE_SUCCESS( 2381 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2382 2383 validate_status_exited(status, exitval_tracer); 2384 2385 DPRINTF("Wait for the non-exited tracee process with %s()\n", 2386 TWAIT_FNAME); 2387 TWAIT_REQUIRE_SUCCESS( 2388 wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0); 2389 } 2390 2391 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2392 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2393 2394 DPRINTF("Resume the tracee and let it exit\n"); 2395 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2396 2397 DPRINTF("Detect that tracee is zombie\n"); 2398 if (notimeout) 2399 await_zombie_raw(tracee, 0); 2400 else 2401 await_zombie(tracee); 2402 2403 DPRINTF("Assert that there is no status about tracee %d - " 2404 "Tracer must detect zombie first - calling %s()\n", tracee, 2405 TWAIT_FNAME); 2406 TWAIT_REQUIRE_SUCCESS( 2407 wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0); 2408 2409 if (unrelated) { 2410 DPRINTF("Resume the tracer and let it detect exited tracee\n"); 2411 PARENT_TO_CHILD("Message 2", parent_tracer, msg); 2412 } else { 2413 DPRINTF("Tell the tracer child should have exited\n"); 2414 PARENT_TO_CHILD("wait for tracee exit", parent_tracer, msg); 2415 DPRINTF("Wait for tracer to finish its job and exit - calling " 2416 "%s()\n", TWAIT_FNAME); 2417 2418 DPRINTF("Wait from tracer child to complete waiting for " 2419 "tracee\n"); 2420 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 2421 tracer); 2422 2423 validate_status_exited(status, exitval_tracer); 2424 } 2425 2426 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2427 TWAIT_FNAME); 2428 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2429 2430 validate_status_exited(status, exitval_tracee); 2431 2432 msg_close(&parent_tracer); 2433 msg_close(&parent_tracee); 2434} 2435 2436ATF_TC(tracer_sees_terminaton_before_the_parent); 2437ATF_TC_HEAD(tracer_sees_terminaton_before_the_parent, tc) 2438{ 2439 atf_tc_set_md_var(tc, "descr", 2440 "Assert that tracer sees process termination before the parent"); 2441} 2442 2443ATF_TC_BODY(tracer_sees_terminaton_before_the_parent, tc) 2444{ 2445 2446 tracer_sees_terminaton_before_the_parent_raw(false, false, false); 2447} 2448 2449ATF_TC(tracer_sysctl_lookup_without_duplicates); 2450ATF_TC_HEAD(tracer_sysctl_lookup_without_duplicates, tc) 2451{ 2452 atf_tc_set_md_var(tc, "descr", 2453 "Assert that await_zombie() in attach1 always finds a single " 2454 "process and no other error is reported"); 2455} 2456 2457ATF_TC_BODY(tracer_sysctl_lookup_without_duplicates, tc) 2458{ 2459 time_t start, end; 2460 double diff; 2461 unsigned long N = 0; 2462 2463 /* 2464 * Reuse this test with tracer_sees_terminaton_before_the_parent_raw(). 2465 * This test body isn't specific to this race, however it's just good 2466 * enough for this purposes, no need to invent a dedicated code flow. 2467 */ 2468 2469 start = time(NULL); 2470 while (true) { 2471 DPRINTF("Step: %lu\n", N); 2472 tracer_sees_terminaton_before_the_parent_raw(true, false, 2473 false); 2474 end = time(NULL); 2475 diff = difftime(end, start); 2476 if (diff >= 5.0) 2477 break; 2478 ++N; 2479 } 2480 DPRINTF("Iterations: %lu\n", N); 2481} 2482 2483ATF_TC(unrelated_tracer_sees_terminaton_before_the_parent); 2484ATF_TC_HEAD(unrelated_tracer_sees_terminaton_before_the_parent, tc) 2485{ 2486 atf_tc_set_md_var(tc, "descr", 2487 "Assert that tracer sees process termination before the parent"); 2488} 2489 2490ATF_TC_BODY(unrelated_tracer_sees_terminaton_before_the_parent, tc) 2491{ 2492 2493 tracer_sees_terminaton_before_the_parent_raw(false, true, false); 2494} 2495 2496ATF_TC(tracer_attach_to_unrelated_stopped_process); 2497ATF_TC_HEAD(tracer_attach_to_unrelated_stopped_process, tc) 2498{ 2499 atf_tc_set_md_var(tc, "descr", 2500 "Assert that tracer can attach to an unrelated stopped process"); 2501} 2502 2503ATF_TC_BODY(tracer_attach_to_unrelated_stopped_process, tc) 2504{ 2505 2506 tracer_sees_terminaton_before_the_parent_raw(false, true, true); 2507} 2508#endif 2509 2510/// ---------------------------------------------------------------------------- 2511 2512static void 2513parent_attach_to_its_child(bool stopped) 2514{ 2515 struct msg_fds parent_tracee; 2516 const int exitval_tracee = 5; 2517 pid_t tracee, wpid; 2518 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2519#if defined(TWAIT_HAVE_STATUS) 2520 int status; 2521#endif 2522 2523 DPRINTF("Spawn tracee\n"); 2524 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2525 tracee = atf_utils_fork(); 2526 if (tracee == 0) { 2527 CHILD_FROM_PARENT("Message 1", parent_tracee, msg); 2528 DPRINTF("Parent should now attach to tracee\n"); 2529 2530 if (stopped) { 2531 DPRINTF("Stop self PID %d\n", getpid()); 2532 SYSCALL_REQUIRE(raise(SIGSTOP) != -1); 2533 } 2534 2535 CHILD_FROM_PARENT("Message 2", parent_tracee, msg); 2536 /* Wait for message from the parent */ 2537 _exit(exitval_tracee); 2538 } 2539 PARENT_TO_CHILD("Message 1", parent_tracee, msg); 2540 2541 if (stopped) { 2542 DPRINTF("Await for a stopped tracee PID %d\n", tracee); 2543 await_stopped(tracee); 2544 } 2545 2546 DPRINTF("Before calling PT_ATTACH for tracee %d\n", tracee); 2547 SYSCALL_REQUIRE(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2548 2549 DPRINTF("Wait for the stopped tracee process with %s()\n", 2550 TWAIT_FNAME); 2551 TWAIT_REQUIRE_SUCCESS( 2552 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2553 2554 validate_status_stopped(status, SIGSTOP); 2555 2556 DPRINTF("Resume tracee with PT_CONTINUE\n"); 2557 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2558 2559 DPRINTF("Let the tracee exit now\n"); 2560 PARENT_TO_CHILD("Message 2", parent_tracee, msg); 2561 2562 DPRINTF("Wait for tracee to exit with %s()\n", TWAIT_FNAME); 2563 TWAIT_REQUIRE_SUCCESS( 2564 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2565 2566 validate_status_exited(status, exitval_tracee); 2567 2568 DPRINTF("Before calling %s() for tracee\n", TWAIT_FNAME); 2569 TWAIT_REQUIRE_FAILURE(ECHILD, 2570 wpid = TWAIT_GENERIC(tracee, &status, 0)); 2571 2572 msg_close(&parent_tracee); 2573} 2574 2575ATF_TC(parent_attach_to_its_child); 2576ATF_TC_HEAD(parent_attach_to_its_child, tc) 2577{ 2578 atf_tc_set_md_var(tc, "descr", 2579 "Assert that tracer parent can PT_ATTACH to its child"); 2580} 2581 2582ATF_TC_BODY(parent_attach_to_its_child, tc) 2583{ 2584 2585 parent_attach_to_its_child(false); 2586} 2587 2588ATF_TC(parent_attach_to_its_stopped_child); 2589ATF_TC_HEAD(parent_attach_to_its_stopped_child, tc) 2590{ 2591 atf_tc_set_md_var(tc, "descr", 2592 "Assert that tracer parent can PT_ATTACH to its stopped child"); 2593} 2594 2595ATF_TC_BODY(parent_attach_to_its_stopped_child, tc) 2596{ 2597 2598 parent_attach_to_its_child(true); 2599} 2600 2601/// ---------------------------------------------------------------------------- 2602 2603static void 2604child_attach_to_its_parent(bool stopped) 2605{ 2606 struct msg_fds parent_tracee; 2607 const int exitval_tracer = 5; 2608 pid_t tracer, wpid; 2609 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2610#if defined(TWAIT_HAVE_STATUS) 2611 int status; 2612#endif 2613 2614 DPRINTF("Spawn tracer\n"); 2615 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2616 tracer = atf_utils_fork(); 2617 if (tracer == 0) { 2618 /* Wait for message from the parent */ 2619 CHILD_FROM_PARENT("Message 1", parent_tracee, msg); 2620 2621 if (stopped) { 2622 DPRINTF("Await for a stopped parent PID %d\n", 2623 getppid()); 2624 await_stopped(getppid()); 2625 } 2626 2627 DPRINTF("Attach to parent PID %d with PT_ATTACH from child\n", 2628 getppid()); 2629 FORKEE_ASSERT(ptrace(PT_ATTACH, getppid(), NULL, 0) != -1); 2630 2631 DPRINTF("Wait for the stopped parent process with %s()\n", 2632 TWAIT_FNAME); 2633 FORKEE_REQUIRE_SUCCESS( 2634 wpid = TWAIT_GENERIC(getppid(), &status, 0), getppid()); 2635 2636 forkee_status_stopped(status, SIGSTOP); 2637 2638 DPRINTF("Resume parent with PT_DETACH\n"); 2639 FORKEE_ASSERT(ptrace(PT_DETACH, getppid(), (void *)1, 0) 2640 != -1); 2641 2642 /* Tell parent we are ready */ 2643 CHILD_TO_PARENT("Message 1", parent_tracee, msg); 2644 2645 _exit(exitval_tracer); 2646 } 2647 2648 DPRINTF("Wait for the tracer to become ready\n"); 2649 PARENT_TO_CHILD("Message 1", parent_tracee, msg); 2650 2651 if (stopped) { 2652 DPRINTF("Stop self PID %d\n", getpid()); 2653 SYSCALL_REQUIRE(raise(SIGSTOP) != -1); 2654 } 2655 2656 DPRINTF("Allow the tracer to exit now\n"); 2657 PARENT_FROM_CHILD("Message 1", parent_tracee, msg); 2658 2659 DPRINTF("Wait for tracer to exit with %s()\n", TWAIT_FNAME); 2660 TWAIT_REQUIRE_SUCCESS( 2661 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2662 2663 validate_status_exited(status, exitval_tracer); 2664 2665 DPRINTF("Before calling %s() for tracer\n", TWAIT_FNAME); 2666 TWAIT_REQUIRE_FAILURE(ECHILD, 2667 wpid = TWAIT_GENERIC(tracer, &status, 0)); 2668 2669 msg_close(&parent_tracee); 2670} 2671 2672ATF_TC(child_attach_to_its_parent); 2673ATF_TC_HEAD(child_attach_to_its_parent, tc) 2674{ 2675 atf_tc_set_md_var(tc, "descr", 2676 "Assert that tracer child can PT_ATTACH to its parent"); 2677} 2678 2679ATF_TC_BODY(child_attach_to_its_parent, tc) 2680{ 2681 2682 child_attach_to_its_parent(false); 2683} 2684 2685ATF_TC(child_attach_to_its_stopped_parent); 2686ATF_TC_HEAD(child_attach_to_its_stopped_parent, tc) 2687{ 2688 atf_tc_set_md_var(tc, "descr", 2689 "Assert that tracer child can PT_ATTACH to its stopped parent"); 2690} 2691 2692ATF_TC_BODY(child_attach_to_its_stopped_parent, tc) 2693{ 2694 /* 2695 * The ATF framework (atf-run) does not tolerate raise(SIGSTOP), as 2696 * this causes a pipe (established from atf-run) to be broken. 2697 * atf-run uses this mechanism to monitor whether a test is alive. 2698 * 2699 * As a workaround spawn this test as a subprocess. 2700 */ 2701 2702 const int exitval = 15; 2703 pid_t child, wpid; 2704#if defined(TWAIT_HAVE_STATUS) 2705 int status; 2706#endif 2707 2708 SYSCALL_REQUIRE((child = fork()) != -1); 2709 if (child == 0) { 2710 child_attach_to_its_parent(true); 2711 _exit(exitval); 2712 } else { 2713 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2714 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2715 2716 validate_status_exited(status, exitval); 2717 2718 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 2719 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 2720 } 2721} 2722 2723/// ---------------------------------------------------------------------------- 2724 2725#if defined(TWAIT_HAVE_PID) 2726 2727enum tracee_sees_its_original_parent_type { 2728 TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID, 2729 TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2, 2730 TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS 2731}; 2732 2733static void 2734tracee_sees_its_original_parent(enum tracee_sees_its_original_parent_type type) 2735{ 2736 struct msg_fds parent_tracer, parent_tracee; 2737 const int exitval_tracee = 5; 2738 const int exitval_tracer = 10; 2739 pid_t parent, tracee, tracer, wpid; 2740 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2741#if defined(TWAIT_HAVE_STATUS) 2742 int status; 2743#endif 2744 /* sysctl(3) - kinfo_proc2 */ 2745 int name[CTL_MAXNAME]; 2746 struct kinfo_proc2 kp; 2747 size_t len = sizeof(kp); 2748 unsigned int namelen; 2749 2750 /* procfs - status */ 2751 FILE *fp; 2752 struct stat st; 2753 const char *fname = "/proc/curproc/status"; 2754 char s_executable[MAXPATHLEN]; 2755 int s_pid, s_ppid; 2756 int rv; 2757 2758 if (type == TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS) { 2759 SYSCALL_REQUIRE( 2760 (rv = stat(fname, &st)) == 0 || (errno == ENOENT)); 2761 if (rv != 0) 2762 atf_tc_skip("/proc/curproc/status not found"); 2763 } 2764 2765 DPRINTF("Spawn tracee\n"); 2766 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2767 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2768 tracee = atf_utils_fork(); 2769 if (tracee == 0) { 2770 parent = getppid(); 2771 2772 /* Emit message to the parent */ 2773 CHILD_TO_PARENT("tracee ready", parent_tracee, msg); 2774 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 2775 2776 switch (type) { 2777 case TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID: 2778 FORKEE_ASSERT_EQ(parent, getppid()); 2779 break; 2780 case TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2: 2781 namelen = 0; 2782 name[namelen++] = CTL_KERN; 2783 name[namelen++] = KERN_PROC2; 2784 name[namelen++] = KERN_PROC_PID; 2785 name[namelen++] = getpid(); 2786 name[namelen++] = len; 2787 name[namelen++] = 1; 2788 2789 FORKEE_ASSERT_EQ( 2790 sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2791 FORKEE_ASSERT_EQ(parent, kp.p_ppid); 2792 break; 2793 case TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS: 2794 /* 2795 * Format: 2796 * EXECUTABLE PID PPID ... 2797 */ 2798 FORKEE_ASSERT((fp = fopen(fname, "r")) != NULL); 2799 fscanf(fp, "%s %d %d", s_executable, &s_pid, &s_ppid); 2800 FORKEE_ASSERT_EQ(fclose(fp), 0); 2801 FORKEE_ASSERT_EQ(parent, s_ppid); 2802 break; 2803 } 2804 2805 _exit(exitval_tracee); 2806 } 2807 DPRINTF("Wait for child to record its parent identifier (pid)\n"); 2808 PARENT_FROM_CHILD("tracee ready", parent_tracee, msg); 2809 2810 DPRINTF("Spawn debugger\n"); 2811 tracer = atf_utils_fork(); 2812 if (tracer == 0) { 2813 /* No IPC to communicate with the child */ 2814 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2815 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2816 2817 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2818 FORKEE_REQUIRE_SUCCESS( 2819 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2820 2821 forkee_status_stopped(status, SIGSTOP); 2822 2823 /* Resume tracee with PT_CONTINUE */ 2824 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2825 2826 /* Inform parent that tracer has attached to tracee */ 2827 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2828 2829 /* Wait for parent to tell use that tracee should have exited */ 2830 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2831 2832 /* Wait for tracee and assert that it exited */ 2833 FORKEE_REQUIRE_SUCCESS( 2834 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2835 2836 forkee_status_exited(status, exitval_tracee); 2837 2838 DPRINTF("Before exiting of the tracer process\n"); 2839 _exit(exitval_tracer); 2840 } 2841 2842 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2843 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2844 2845 DPRINTF("Resume the tracee and let it exit\n"); 2846 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2847 2848 DPRINTF("Detect that tracee is zombie\n"); 2849 await_zombie(tracee); 2850 2851 DPRINTF("Assert that there is no status about tracee - " 2852 "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME); 2853 TWAIT_REQUIRE_SUCCESS( 2854 wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0); 2855 2856 DPRINTF("Tell the tracer child should have exited\n"); 2857 PARENT_TO_CHILD("wait for tracee exit", parent_tracer, msg); 2858 2859 DPRINTF("Wait from tracer child to complete waiting for tracee\n"); 2860 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 2861 tracer); 2862 2863 validate_status_exited(status, exitval_tracer); 2864 2865 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2866 TWAIT_FNAME); 2867 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 2868 tracee); 2869 2870 validate_status_exited(status, exitval_tracee); 2871 2872 msg_close(&parent_tracer); 2873 msg_close(&parent_tracee); 2874} 2875 2876#define TRACEE_SEES_ITS_ORIGINAL_PARENT(test, type, descr) \ 2877ATF_TC(test); \ 2878ATF_TC_HEAD(test, tc) \ 2879{ \ 2880 atf_tc_set_md_var(tc, "descr", \ 2881 "Assert that tracee sees its original parent when being traced " \ 2882 "(check " descr ")"); \ 2883} \ 2884 \ 2885ATF_TC_BODY(test, tc) \ 2886{ \ 2887 \ 2888 tracee_sees_its_original_parent(type); \ 2889} 2890 2891TRACEE_SEES_ITS_ORIGINAL_PARENT( 2892 tracee_sees_its_original_parent_getppid, 2893 TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID, 2894 "getppid(2)"); 2895TRACEE_SEES_ITS_ORIGINAL_PARENT( 2896 tracee_sees_its_original_parent_sysctl_kinfo_proc2, 2897 TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2, 2898 "sysctl(3) and kinfo_proc2"); 2899TRACEE_SEES_ITS_ORIGINAL_PARENT( 2900 tracee_sees_its_original_parent_procfs_status, 2901 TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS, 2902 "the status file in procfs"); 2903#endif 2904 2905/// ---------------------------------------------------------------------------- 2906 2907static void 2908eventmask_preserved(int event) 2909{ 2910 const int exitval = 5; 2911 const int sigval = SIGSTOP; 2912 pid_t child, wpid; 2913#if defined(TWAIT_HAVE_STATUS) 2914 int status; 2915#endif 2916 ptrace_event_t set_event, get_event; 2917 const int len = sizeof(ptrace_event_t); 2918 2919 DPRINTF("Before forking process PID=%d\n", getpid()); 2920 SYSCALL_REQUIRE((child = fork()) != -1); 2921 if (child == 0) { 2922 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 2923 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 2924 2925 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 2926 FORKEE_ASSERT(raise(sigval) == 0); 2927 2928 DPRINTF("Before exiting of the child process\n"); 2929 _exit(exitval); 2930 } 2931 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 2932 2933 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2934 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2935 2936 validate_status_stopped(status, sigval); 2937 2938 set_event.pe_set_event = event; 2939 SYSCALL_REQUIRE( 2940 ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1); 2941 SYSCALL_REQUIRE( 2942 ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1); 2943 ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0); 2944 2945 DPRINTF("Before resuming the child process where it left off and " 2946 "without signal to be sent\n"); 2947 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 2948 2949 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2950 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2951 2952 validate_status_exited(status, exitval); 2953 2954 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2955 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 2956} 2957 2958#define EVENTMASK_PRESERVED(test, event) \ 2959ATF_TC(test); \ 2960ATF_TC_HEAD(test, tc) \ 2961{ \ 2962 atf_tc_set_md_var(tc, "descr", \ 2963 "Verify that eventmask " #event " is preserved"); \ 2964} \ 2965 \ 2966ATF_TC_BODY(test, tc) \ 2967{ \ 2968 \ 2969 eventmask_preserved(event); \ 2970} 2971 2972EVENTMASK_PRESERVED(eventmask_preserved_empty, 0) 2973EVENTMASK_PRESERVED(eventmask_preserved_fork, PTRACE_FORK) 2974EVENTMASK_PRESERVED(eventmask_preserved_vfork, PTRACE_VFORK) 2975EVENTMASK_PRESERVED(eventmask_preserved_vfork_done, PTRACE_VFORK_DONE) 2976EVENTMASK_PRESERVED(eventmask_preserved_lwp_create, PTRACE_LWP_CREATE) 2977EVENTMASK_PRESERVED(eventmask_preserved_lwp_exit, PTRACE_LWP_EXIT) 2978 2979/// ---------------------------------------------------------------------------- 2980 2981static void 2982fork_body(pid_t (*fn)(void), bool trackfork, bool trackvfork, 2983 bool trackvforkdone) 2984{ 2985 const int exitval = 5; 2986 const int exitval2 = 15; 2987 const int sigval = SIGSTOP; 2988 pid_t child, child2 = 0, wpid; 2989#if defined(TWAIT_HAVE_STATUS) 2990 int status; 2991#endif 2992 ptrace_state_t state; 2993 const int slen = sizeof(state); 2994 ptrace_event_t event; 2995 const int elen = sizeof(event); 2996 2997 DPRINTF("Before forking process PID=%d\n", getpid()); 2998 SYSCALL_REQUIRE((child = fork()) != -1); 2999 if (child == 0) { 3000 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3001 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3002 3003 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3004 FORKEE_ASSERT(raise(sigval) == 0); 3005 3006 FORKEE_ASSERT((child2 = (fn)()) != -1); 3007 3008 if (child2 == 0) 3009 _exit(exitval2); 3010 3011 FORKEE_REQUIRE_SUCCESS 3012 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3013 3014 forkee_status_exited(status, exitval2); 3015 3016 DPRINTF("Before exiting of the child process\n"); 3017 _exit(exitval); 3018 } 3019 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3020 3021 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3022 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3023 3024 validate_status_stopped(status, sigval); 3025 3026 DPRINTF("Set 0%s%s%s in EVENT_MASK for the child %d\n", 3027 trackfork ? "|PTRACE_FORK" : "", 3028 trackvfork ? "|PTRACE_VFORK" : "", 3029 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 3030 event.pe_set_event = 0; 3031 if (trackfork) 3032 event.pe_set_event |= PTRACE_FORK; 3033 if (trackvfork) 3034 event.pe_set_event |= PTRACE_VFORK; 3035 if (trackvforkdone) 3036 event.pe_set_event |= PTRACE_VFORK_DONE; 3037 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 3038 3039 DPRINTF("Before resuming the child process where it left off and " 3040 "without signal to be sent\n"); 3041 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3042 3043#if defined(TWAIT_HAVE_PID) 3044 if ((trackfork && fn == fork) || (trackvfork && fn == vfork)) { 3045 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3046 child); 3047 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 3048 child); 3049 3050 validate_status_stopped(status, SIGTRAP); 3051 3052 SYSCALL_REQUIRE( 3053 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3054 if (trackfork && fn == fork) { 3055 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 3056 PTRACE_FORK); 3057 } 3058 if (trackvfork && fn == vfork) { 3059 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 3060 PTRACE_VFORK); 3061 } 3062 3063 child2 = state.pe_other_pid; 3064 DPRINTF("Reported ptrace event with forkee %d\n", child2); 3065 3066 DPRINTF("Before calling %s() for the forkee %d of the child " 3067 "%d\n", TWAIT_FNAME, child2, child); 3068 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 3069 child2); 3070 3071 validate_status_stopped(status, SIGTRAP); 3072 3073 SYSCALL_REQUIRE( 3074 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 3075 if (trackfork && fn == fork) { 3076 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 3077 PTRACE_FORK); 3078 } 3079 if (trackvfork && fn == vfork) { 3080 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 3081 PTRACE_VFORK); 3082 } 3083 3084 ATF_REQUIRE_EQ(state.pe_other_pid, child); 3085 3086 DPRINTF("Before resuming the forkee process where it left off " 3087 "and without signal to be sent\n"); 3088 SYSCALL_REQUIRE( 3089 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 3090 3091 DPRINTF("Before resuming the child process where it left off " 3092 "and without signal to be sent\n"); 3093 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3094 } 3095#endif 3096 3097 if (trackvforkdone && fn == vfork) { 3098 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3099 child); 3100 TWAIT_REQUIRE_SUCCESS( 3101 wpid = TWAIT_GENERIC(child, &status, 0), child); 3102 3103 validate_status_stopped(status, SIGTRAP); 3104 3105 SYSCALL_REQUIRE( 3106 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3107 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 3108 3109 child2 = state.pe_other_pid; 3110 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 3111 child2); 3112 3113 DPRINTF("Before resuming the child process where it left off " 3114 "and without signal to be sent\n"); 3115 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3116 } 3117 3118#if defined(TWAIT_HAVE_PID) 3119 if ((trackfork && fn == fork) || (trackvfork && fn == vfork)) { 3120 DPRINTF("Before calling %s() for the forkee - expected exited" 3121 "\n", TWAIT_FNAME); 3122 TWAIT_REQUIRE_SUCCESS( 3123 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3124 3125 validate_status_exited(status, exitval2); 3126 3127 DPRINTF("Before calling %s() for the forkee - expected no " 3128 "process\n", TWAIT_FNAME); 3129 TWAIT_REQUIRE_FAILURE(ECHILD, 3130 wpid = TWAIT_GENERIC(child2, &status, 0)); 3131 } 3132#endif 3133 3134 DPRINTF("Before calling %s() for the child - expected stopped " 3135 "SIGCHLD\n", TWAIT_FNAME); 3136 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3137 3138 validate_status_stopped(status, SIGCHLD); 3139 3140 DPRINTF("Before resuming the child process where it left off and " 3141 "without signal to be sent\n"); 3142 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3143 3144 DPRINTF("Before calling %s() for the child - expected exited\n", 3145 TWAIT_FNAME); 3146 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3147 3148 validate_status_exited(status, exitval); 3149 3150 DPRINTF("Before calling %s() for the child - expected no process\n", 3151 TWAIT_FNAME); 3152 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3153} 3154 3155#define FORK_TEST(name,fun,tfork,tvfork,tvforkdone) \ 3156ATF_TC(name); \ 3157ATF_TC_HEAD(name, tc) \ 3158{ \ 3159 atf_tc_set_md_var(tc, "descr", "Verify " #fun "(2) " \ 3160 "called with 0%s%s%s in EVENT_MASK", \ 3161 tfork ? "|PTRACE_FORK" : "", \ 3162 tvfork ? "|PTRACE_VFORK" : "", \ 3163 tvforkdone ? "|PTRACE_VFORK_DONE" : ""); \ 3164} \ 3165 \ 3166ATF_TC_BODY(name, tc) \ 3167{ \ 3168 \ 3169 fork_body(fun, tfork, tvfork, tvforkdone); \ 3170} 3171 3172FORK_TEST(fork1, fork, false, false, false) 3173#if defined(TWAIT_HAVE_PID) 3174FORK_TEST(fork2, fork, true, false, false) 3175FORK_TEST(fork3, fork, false, true, false) 3176FORK_TEST(fork4, fork, true, true, false) 3177#endif 3178FORK_TEST(fork5, fork, false, false, true) 3179#if defined(TWAIT_HAVE_PID) 3180FORK_TEST(fork6, fork, true, false, true) 3181FORK_TEST(fork7, fork, false, true, true) 3182FORK_TEST(fork8, fork, true, true, true) 3183#endif 3184 3185#if TEST_VFORK_ENABLED 3186FORK_TEST(vfork1, vfork, false, false, false) 3187#if defined(TWAIT_HAVE_PID) 3188FORK_TEST(vfork2, vfork, true, false, false) 3189FORK_TEST(vfork3, vfork, false, true, false) 3190FORK_TEST(vfork4, vfork, true, true, false) 3191#endif 3192FORK_TEST(vfork5, vfork, false, false, true) 3193#if defined(TWAIT_HAVE_PID) 3194FORK_TEST(vfork6, vfork, true, false, true) 3195FORK_TEST(vfork7, vfork, false, true, true) 3196FORK_TEST(vfork8, vfork, true, true, true) 3197#endif 3198#endif 3199 3200/// ---------------------------------------------------------------------------- 3201 3202#if defined(TWAIT_HAVE_PID) 3203static void 3204fork_detach_forker_body(bool detachfork, bool detachvfork, 3205 bool detachvforkdone, bool kill_process) 3206{ 3207 const int exitval = 5; 3208 const int exitval2 = 15; 3209 const int sigval = SIGSTOP; 3210 pid_t child, child2 = 0, wpid; 3211#if defined(TWAIT_HAVE_STATUS) 3212 int status; 3213#endif 3214 ptrace_state_t state; 3215 const int slen = sizeof(state); 3216 ptrace_event_t event; 3217 const int elen = sizeof(event); 3218 3219 pid_t (*fn)(void); 3220 int op; 3221 3222 ATF_REQUIRE((detachfork && !detachvfork && !detachvforkdone) || 3223 (!detachfork && detachvfork && !detachvforkdone) || 3224 (!detachfork && !detachvfork && detachvforkdone)); 3225 3226 if (detachfork) 3227 fn = fork; 3228 else 3229 fn = vfork; 3230 3231 DPRINTF("Before forking process PID=%d\n", getpid()); 3232 SYSCALL_REQUIRE((child = fork()) != -1); 3233 if (child == 0) { 3234 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3235 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3236 3237 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3238 FORKEE_ASSERT(raise(sigval) == 0); 3239 3240 FORKEE_ASSERT((child2 = (fn)()) != -1); 3241 3242 if (child2 == 0) 3243 _exit(exitval2); 3244 3245 FORKEE_REQUIRE_SUCCESS 3246 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3247 3248 forkee_status_exited(status, exitval2); 3249 3250 DPRINTF("Before exiting of the child process\n"); 3251 _exit(exitval); 3252 } 3253 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3254 3255 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3256 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3257 3258 validate_status_stopped(status, sigval); 3259 3260 DPRINTF("Set EVENT_MASK for the child %d\n", child); 3261 event.pe_set_event = PTRACE_FORK | PTRACE_VFORK | PTRACE_VFORK_DONE; 3262 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 3263 3264 DPRINTF("Before resuming the child process where it left off and " 3265 "without signal to be sent\n"); 3266 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3267 3268 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, child); 3269 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3270 3271 validate_status_stopped(status, SIGTRAP); 3272 3273 SYSCALL_REQUIRE( 3274 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3275 op = (fn == fork) ? PTRACE_FORK : PTRACE_VFORK; 3276 ATF_REQUIRE_EQ(state.pe_report_event & op, op); 3277 3278 child2 = state.pe_other_pid; 3279 DPRINTF("Reported ptrace event with forkee %d\n", child2); 3280 3281 if (detachfork || detachvfork) 3282 op = kill_process ? PT_KILL : PT_DETACH; 3283 else 3284 op = PT_CONTINUE; 3285 SYSCALL_REQUIRE(ptrace(op, child, (void *)1, 0) != -1); 3286 3287 DPRINTF("Before calling %s() for the forkee %d of the child %d\n", 3288 TWAIT_FNAME, child2, child); 3289 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3290 3291 validate_status_stopped(status, SIGTRAP); 3292 3293 SYSCALL_REQUIRE( 3294 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 3295 op = (fn == fork) ? PTRACE_FORK : PTRACE_VFORK; 3296 ATF_REQUIRE_EQ(state.pe_report_event & op, op); 3297 ATF_REQUIRE_EQ(state.pe_other_pid, child); 3298 3299 DPRINTF("Before resuming the forkee process where it left off " 3300 "and without signal to be sent\n"); 3301 SYSCALL_REQUIRE( 3302 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 3303 3304 if (detachvforkdone && fn == vfork) { 3305 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3306 child); 3307 TWAIT_REQUIRE_SUCCESS( 3308 wpid = TWAIT_GENERIC(child, &status, 0), child); 3309 3310 validate_status_stopped(status, SIGTRAP); 3311 3312 SYSCALL_REQUIRE( 3313 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3314 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 3315 3316 child2 = state.pe_other_pid; 3317 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 3318 child2); 3319 3320 op = kill_process ? PT_KILL : PT_DETACH; 3321 DPRINTF("Before resuming the child process where it left off " 3322 "and without signal to be sent\n"); 3323 SYSCALL_REQUIRE(ptrace(op, child, (void *)1, 0) != -1); 3324 } 3325 3326 DPRINTF("Before calling %s() for the forkee - expected exited\n", 3327 TWAIT_FNAME); 3328 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3329 3330 validate_status_exited(status, exitval2); 3331 3332 DPRINTF("Before calling %s() for the forkee - expected no process\n", 3333 TWAIT_FNAME); 3334 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child2, &status, 0)); 3335 3336 DPRINTF("Before calling %s() for the forkee - expected exited\n", 3337 TWAIT_FNAME); 3338 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3339 3340 if (kill_process) { 3341 validate_status_signaled(status, SIGKILL, 0); 3342 } else { 3343 validate_status_exited(status, exitval); 3344 } 3345 3346 DPRINTF("Before calling %s() for the child - expected no process\n", 3347 TWAIT_FNAME); 3348 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3349} 3350 3351#define FORK_DETACH_FORKER(name,detfork,detvfork,detvforkdone,kprocess) \ 3352ATF_TC(name); \ 3353ATF_TC_HEAD(name, tc) \ 3354{ \ 3355 atf_tc_set_md_var(tc, "descr", "Verify %s %s%s%s", \ 3356 kprocess ? "killed" : "detached", \ 3357 detfork ? "forker" : "", \ 3358 detvfork ? "vforker" : "", \ 3359 detvforkdone ? "vforker done" : ""); \ 3360} \ 3361 \ 3362ATF_TC_BODY(name, tc) \ 3363{ \ 3364 \ 3365 fork_detach_forker_body(detfork, detvfork, detvforkdone, \ 3366 kprocess); \ 3367} 3368 3369FORK_DETACH_FORKER(fork_detach_forker, true, false, false, false) 3370#if TEST_VFORK_ENABLED 3371FORK_DETACH_FORKER(vfork_detach_vforker, false, true, false, false) 3372FORK_DETACH_FORKER(vfork_detach_vforkerdone, false, false, true, false) 3373#endif 3374FORK_DETACH_FORKER(fork_kill_forker, true, false, false, true) 3375#if TEST_VFORK_ENABLED 3376FORK_DETACH_FORKER(vfork_kill_vforker, false, true, false, true) 3377FORK_DETACH_FORKER(vfork_kill_vforkerdone, false, false, true, true) 3378#endif 3379#endif 3380 3381/// ---------------------------------------------------------------------------- 3382 3383#if TEST_VFORK_ENABLED 3384static void 3385traceme_vfork_fork_body(pid_t (*fn)(void)) 3386{ 3387 const int exitval = 5; 3388 const int exitval2 = 15; 3389 pid_t child, child2 = 0, wpid; 3390#if defined(TWAIT_HAVE_STATUS) 3391 int status; 3392#endif 3393 3394 DPRINTF("Before forking process PID=%d\n", getpid()); 3395 SYSCALL_REQUIRE((child = vfork()) != -1); 3396 if (child == 0) { 3397 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3398 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3399 3400 FORKEE_ASSERT((child2 = (fn)()) != -1); 3401 3402 if (child2 == 0) 3403 _exit(exitval2); 3404 3405 FORKEE_REQUIRE_SUCCESS 3406 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3407 3408 forkee_status_exited(status, exitval2); 3409 3410 DPRINTF("Before exiting of the child process\n"); 3411 _exit(exitval); 3412 } 3413 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3414 3415 DPRINTF("Before calling %s() for the child - expected exited\n", 3416 TWAIT_FNAME); 3417 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3418 3419 validate_status_exited(status, exitval); 3420 3421 DPRINTF("Before calling %s() for the child - expected no process\n", 3422 TWAIT_FNAME); 3423 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3424} 3425 3426#define TRACEME_VFORK_FORK_TEST(name,fun) \ 3427ATF_TC(name); \ 3428ATF_TC_HEAD(name, tc) \ 3429{ \ 3430 atf_tc_set_md_var(tc, "descr", "Verify " #fun "(2) " \ 3431 "called from vfork(2)ed child"); \ 3432} \ 3433 \ 3434ATF_TC_BODY(name, tc) \ 3435{ \ 3436 \ 3437 traceme_vfork_fork_body(fun); \ 3438} 3439 3440TRACEME_VFORK_FORK_TEST(traceme_vfork_fork, fork) 3441TRACEME_VFORK_FORK_TEST(traceme_vfork_vfork, vfork) 3442#endif 3443 3444/// ---------------------------------------------------------------------------- 3445 3446enum bytes_transfer_type { 3447 BYTES_TRANSFER_DATA, 3448 BYTES_TRANSFER_DATAIO, 3449 BYTES_TRANSFER_TEXT, 3450 BYTES_TRANSFER_TEXTIO, 3451 BYTES_TRANSFER_AUXV 3452}; 3453 3454static int __used 3455bytes_transfer_dummy(int a, int b, int c, int d) 3456{ 3457 int e, f, g, h; 3458 3459 a *= 4; 3460 b += 3; 3461 c -= 2; 3462 d /= 1; 3463 3464 e = strtol("10", NULL, 10); 3465 f = strtol("20", NULL, 10); 3466 g = strtol("30", NULL, 10); 3467 h = strtol("40", NULL, 10); 3468 3469 return (a + b * c - d) + (e * f - g / h); 3470} 3471 3472static void 3473bytes_transfer(int operation, size_t size, enum bytes_transfer_type type) 3474{ 3475 const int exitval = 5; 3476 const int sigval = SIGSTOP; 3477 pid_t child, wpid; 3478 bool skip = false; 3479 3480 int lookup_me = 0; 3481 uint8_t lookup_me8 = 0; 3482 uint16_t lookup_me16 = 0; 3483 uint32_t lookup_me32 = 0; 3484 uint64_t lookup_me64 = 0; 3485 3486 int magic = 0x13579246; 3487 uint8_t magic8 = 0xab; 3488 uint16_t magic16 = 0x1234; 3489 uint32_t magic32 = 0x98765432; 3490 uint64_t magic64 = 0xabcdef0123456789; 3491 3492 struct ptrace_io_desc io; 3493#if defined(TWAIT_HAVE_STATUS) 3494 int status; 3495#endif 3496 /* 513 is just enough, for the purposes of ATF it's good enough */ 3497 AuxInfo ai[513], *aip; 3498 3499 ATF_REQUIRE(size < sizeof(ai)); 3500 3501 /* Prepare variables for .TEXT transfers */ 3502 switch (type) { 3503 case BYTES_TRANSFER_TEXT: 3504 memcpy(&magic, bytes_transfer_dummy, sizeof(magic)); 3505 break; 3506 case BYTES_TRANSFER_TEXTIO: 3507 switch (size) { 3508 case 8: 3509 memcpy(&magic8, bytes_transfer_dummy, sizeof(magic8)); 3510 break; 3511 case 16: 3512 memcpy(&magic16, bytes_transfer_dummy, sizeof(magic16)); 3513 break; 3514 case 32: 3515 memcpy(&magic32, bytes_transfer_dummy, sizeof(magic32)); 3516 break; 3517 case 64: 3518 memcpy(&magic64, bytes_transfer_dummy, sizeof(magic64)); 3519 break; 3520 } 3521 break; 3522 default: 3523 break; 3524 } 3525 3526 /* Prepare variables for PIOD and AUXV transfers */ 3527 switch (type) { 3528 case BYTES_TRANSFER_TEXTIO: 3529 case BYTES_TRANSFER_DATAIO: 3530 io.piod_op = operation; 3531 switch (size) { 3532 case 8: 3533 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3534 (void *)bytes_transfer_dummy : 3535 &lookup_me8; 3536 io.piod_addr = &lookup_me8; 3537 io.piod_len = sizeof(lookup_me8); 3538 break; 3539 case 16: 3540 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3541 (void *)bytes_transfer_dummy : 3542 &lookup_me16; 3543 io.piod_addr = &lookup_me16; 3544 io.piod_len = sizeof(lookup_me16); 3545 break; 3546 case 32: 3547 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3548 (void *)bytes_transfer_dummy : 3549 &lookup_me32; 3550 io.piod_addr = &lookup_me32; 3551 io.piod_len = sizeof(lookup_me32); 3552 break; 3553 case 64: 3554 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3555 (void *)bytes_transfer_dummy : 3556 &lookup_me64; 3557 io.piod_addr = &lookup_me64; 3558 io.piod_len = sizeof(lookup_me64); 3559 break; 3560 default: 3561 break; 3562 } 3563 break; 3564 case BYTES_TRANSFER_AUXV: 3565 io.piod_op = operation; 3566 io.piod_offs = 0; 3567 io.piod_addr = ai; 3568 io.piod_len = size; 3569 break; 3570 default: 3571 break; 3572 } 3573 3574 DPRINTF("Before forking process PID=%d\n", getpid()); 3575 SYSCALL_REQUIRE((child = fork()) != -1); 3576 if (child == 0) { 3577 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3578 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3579 3580 switch (type) { 3581 case BYTES_TRANSFER_DATA: 3582 switch (operation) { 3583 case PT_READ_D: 3584 case PT_READ_I: 3585 lookup_me = magic; 3586 break; 3587 default: 3588 break; 3589 } 3590 break; 3591 case BYTES_TRANSFER_DATAIO: 3592 switch (operation) { 3593 case PIOD_READ_D: 3594 case PIOD_READ_I: 3595 switch (size) { 3596 case 8: 3597 lookup_me8 = magic8; 3598 break; 3599 case 16: 3600 lookup_me16 = magic16; 3601 break; 3602 case 32: 3603 lookup_me32 = magic32; 3604 break; 3605 case 64: 3606 lookup_me64 = magic64; 3607 break; 3608 default: 3609 break; 3610 } 3611 break; 3612 default: 3613 break; 3614 } 3615 default: 3616 break; 3617 } 3618 3619 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3620 FORKEE_ASSERT(raise(sigval) == 0); 3621 3622 /* Handle PIOD and PT separately as operation values overlap */ 3623 switch (type) { 3624 case BYTES_TRANSFER_DATA: 3625 switch (operation) { 3626 case PT_WRITE_D: 3627 case PT_WRITE_I: 3628 FORKEE_ASSERT_EQ(lookup_me, magic); 3629 break; 3630 default: 3631 break; 3632 } 3633 break; 3634 case BYTES_TRANSFER_DATAIO: 3635 switch (operation) { 3636 case PIOD_WRITE_D: 3637 case PIOD_WRITE_I: 3638 switch (size) { 3639 case 8: 3640 FORKEE_ASSERT_EQ(lookup_me8, magic8); 3641 break; 3642 case 16: 3643 FORKEE_ASSERT_EQ(lookup_me16, magic16); 3644 break; 3645 case 32: 3646 FORKEE_ASSERT_EQ(lookup_me32, magic32); 3647 break; 3648 case 64: 3649 FORKEE_ASSERT_EQ(lookup_me64, magic64); 3650 break; 3651 default: 3652 break; 3653 } 3654 break; 3655 default: 3656 break; 3657 } 3658 break; 3659 case BYTES_TRANSFER_TEXT: 3660 FORKEE_ASSERT(memcmp(&magic, bytes_transfer_dummy, 3661 sizeof(magic)) == 0); 3662 break; 3663 case BYTES_TRANSFER_TEXTIO: 3664 switch (size) { 3665 case 8: 3666 FORKEE_ASSERT(memcmp(&magic8, 3667 bytes_transfer_dummy, 3668 sizeof(magic8)) == 0); 3669 break; 3670 case 16: 3671 FORKEE_ASSERT(memcmp(&magic16, 3672 bytes_transfer_dummy, 3673 sizeof(magic16)) == 0); 3674 break; 3675 case 32: 3676 FORKEE_ASSERT(memcmp(&magic32, 3677 bytes_transfer_dummy, 3678 sizeof(magic32)) == 0); 3679 break; 3680 case 64: 3681 FORKEE_ASSERT(memcmp(&magic64, 3682 bytes_transfer_dummy, 3683 sizeof(magic64)) == 0); 3684 break; 3685 } 3686 break; 3687 default: 3688 break; 3689 } 3690 3691 DPRINTF("Before exiting of the child process\n"); 3692 _exit(exitval); 3693 } 3694 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3695 3696 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3697 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3698 3699 validate_status_stopped(status, sigval); 3700 3701 /* Check PaX MPROTECT */ 3702 if (!can_we_write_to_text(child)) { 3703 switch (type) { 3704 case BYTES_TRANSFER_TEXTIO: 3705 switch (operation) { 3706 case PIOD_WRITE_D: 3707 case PIOD_WRITE_I: 3708 skip = true; 3709 break; 3710 default: 3711 break; 3712 } 3713 break; 3714 case BYTES_TRANSFER_TEXT: 3715 switch (operation) { 3716 case PT_WRITE_D: 3717 case PT_WRITE_I: 3718 skip = true; 3719 break; 3720 default: 3721 break; 3722 } 3723 break; 3724 default: 3725 break; 3726 } 3727 } 3728 3729 /* Bailout cleanly killing the child process */ 3730 if (skip) { 3731 SYSCALL_REQUIRE(ptrace(PT_KILL, child, (void *)1, 0) != -1); 3732 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3733 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 3734 child); 3735 3736 validate_status_signaled(status, SIGKILL, 0); 3737 3738 atf_tc_skip("PaX MPROTECT setup prevents writes to .text"); 3739 } 3740 3741 DPRINTF("Calling operation to transfer bytes between child=%d and " 3742 "parent=%d\n", child, getpid()); 3743 3744 switch (type) { 3745 case BYTES_TRANSFER_TEXTIO: 3746 case BYTES_TRANSFER_DATAIO: 3747 case BYTES_TRANSFER_AUXV: 3748 switch (operation) { 3749 case PIOD_WRITE_D: 3750 case PIOD_WRITE_I: 3751 switch (size) { 3752 case 8: 3753 lookup_me8 = magic8; 3754 break; 3755 case 16: 3756 lookup_me16 = magic16; 3757 break; 3758 case 32: 3759 lookup_me32 = magic32; 3760 break; 3761 case 64: 3762 lookup_me64 = magic64; 3763 break; 3764 default: 3765 break; 3766 } 3767 break; 3768 default: 3769 break; 3770 } 3771 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1); 3772 switch (operation) { 3773 case PIOD_READ_D: 3774 case PIOD_READ_I: 3775 switch (size) { 3776 case 8: 3777 ATF_REQUIRE_EQ(lookup_me8, magic8); 3778 break; 3779 case 16: 3780 ATF_REQUIRE_EQ(lookup_me16, magic16); 3781 break; 3782 case 32: 3783 ATF_REQUIRE_EQ(lookup_me32, magic32); 3784 break; 3785 case 64: 3786 ATF_REQUIRE_EQ(lookup_me64, magic64); 3787 break; 3788 default: 3789 break; 3790 } 3791 break; 3792 case PIOD_READ_AUXV: 3793 DPRINTF("Asserting that AUXV length (%zu) is > 0\n", 3794 io.piod_len); 3795 ATF_REQUIRE(io.piod_len > 0); 3796 for (aip = ai; aip->a_type != AT_NULL; aip++) 3797 DPRINTF("a_type=%#llx a_v=%#llx\n", 3798 (long long int)aip->a_type, 3799 (long long int)aip->a_v); 3800 break; 3801 default: 3802 break; 3803 } 3804 break; 3805 case BYTES_TRANSFER_TEXT: 3806 switch (operation) { 3807 case PT_READ_D: 3808 case PT_READ_I: 3809 errno = 0; 3810 lookup_me = ptrace(operation, child, 3811 bytes_transfer_dummy, 0); 3812 ATF_REQUIRE_EQ(lookup_me, magic); 3813 SYSCALL_REQUIRE_ERRNO(errno, 0); 3814 break; 3815 case PT_WRITE_D: 3816 case PT_WRITE_I: 3817 SYSCALL_REQUIRE(ptrace(operation, child, 3818 bytes_transfer_dummy, magic) 3819 != -1); 3820 break; 3821 default: 3822 break; 3823 } 3824 break; 3825 case BYTES_TRANSFER_DATA: 3826 switch (operation) { 3827 case PT_READ_D: 3828 case PT_READ_I: 3829 errno = 0; 3830 lookup_me = ptrace(operation, child, &lookup_me, 0); 3831 ATF_REQUIRE_EQ(lookup_me, magic); 3832 SYSCALL_REQUIRE_ERRNO(errno, 0); 3833 break; 3834 case PT_WRITE_D: 3835 case PT_WRITE_I: 3836 lookup_me = magic; 3837 SYSCALL_REQUIRE(ptrace(operation, child, &lookup_me, 3838 magic) != -1); 3839 break; 3840 default: 3841 break; 3842 } 3843 break; 3844 default: 3845 break; 3846 } 3847 3848 DPRINTF("Before resuming the child process where it left off and " 3849 "without signal to be sent\n"); 3850 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3851 3852 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3853 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3854 3855 validate_status_exited(status, exitval); 3856 3857 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3858 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3859} 3860 3861#define BYTES_TRANSFER(test, operation, size, type) \ 3862ATF_TC(test); \ 3863ATF_TC_HEAD(test, tc) \ 3864{ \ 3865 atf_tc_set_md_var(tc, "descr", \ 3866 "Verify bytes transfer operation" #operation " and size " #size \ 3867 " of type " #type); \ 3868} \ 3869 \ 3870ATF_TC_BODY(test, tc) \ 3871{ \ 3872 \ 3873 bytes_transfer(operation, size, BYTES_TRANSFER_##type); \ 3874} 3875 3876// DATA 3877 3878BYTES_TRANSFER(bytes_transfer_piod_read_d_8, PIOD_READ_D, 8, DATAIO) 3879BYTES_TRANSFER(bytes_transfer_piod_read_d_16, PIOD_READ_D, 16, DATAIO) 3880BYTES_TRANSFER(bytes_transfer_piod_read_d_32, PIOD_READ_D, 32, DATAIO) 3881BYTES_TRANSFER(bytes_transfer_piod_read_d_64, PIOD_READ_D, 64, DATAIO) 3882 3883BYTES_TRANSFER(bytes_transfer_piod_read_i_8, PIOD_READ_I, 8, DATAIO) 3884BYTES_TRANSFER(bytes_transfer_piod_read_i_16, PIOD_READ_I, 16, DATAIO) 3885BYTES_TRANSFER(bytes_transfer_piod_read_i_32, PIOD_READ_I, 32, DATAIO) 3886BYTES_TRANSFER(bytes_transfer_piod_read_i_64, PIOD_READ_I, 64, DATAIO) 3887 3888BYTES_TRANSFER(bytes_transfer_piod_write_d_8, PIOD_WRITE_D, 8, DATAIO) 3889BYTES_TRANSFER(bytes_transfer_piod_write_d_16, PIOD_WRITE_D, 16, DATAIO) 3890BYTES_TRANSFER(bytes_transfer_piod_write_d_32, PIOD_WRITE_D, 32, DATAIO) 3891BYTES_TRANSFER(bytes_transfer_piod_write_d_64, PIOD_WRITE_D, 64, DATAIO) 3892 3893BYTES_TRANSFER(bytes_transfer_piod_write_i_8, PIOD_WRITE_I, 8, DATAIO) 3894BYTES_TRANSFER(bytes_transfer_piod_write_i_16, PIOD_WRITE_I, 16, DATAIO) 3895BYTES_TRANSFER(bytes_transfer_piod_write_i_32, PIOD_WRITE_I, 32, DATAIO) 3896BYTES_TRANSFER(bytes_transfer_piod_write_i_64, PIOD_WRITE_I, 64, DATAIO) 3897 3898BYTES_TRANSFER(bytes_transfer_read_d, PT_READ_D, 32, DATA) 3899BYTES_TRANSFER(bytes_transfer_read_i, PT_READ_I, 32, DATA) 3900BYTES_TRANSFER(bytes_transfer_write_d, PT_WRITE_D, 32, DATA) 3901BYTES_TRANSFER(bytes_transfer_write_i, PT_WRITE_I, 32, DATA) 3902 3903// TEXT 3904 3905BYTES_TRANSFER(bytes_transfer_piod_read_d_8_text, PIOD_READ_D, 8, TEXTIO) 3906BYTES_TRANSFER(bytes_transfer_piod_read_d_16_text, PIOD_READ_D, 16, TEXTIO) 3907BYTES_TRANSFER(bytes_transfer_piod_read_d_32_text, PIOD_READ_D, 32, TEXTIO) 3908BYTES_TRANSFER(bytes_transfer_piod_read_d_64_text, PIOD_READ_D, 64, TEXTIO) 3909 3910BYTES_TRANSFER(bytes_transfer_piod_read_i_8_text, PIOD_READ_I, 8, TEXTIO) 3911BYTES_TRANSFER(bytes_transfer_piod_read_i_16_text, PIOD_READ_I, 16, TEXTIO) 3912BYTES_TRANSFER(bytes_transfer_piod_read_i_32_text, PIOD_READ_I, 32, TEXTIO) 3913BYTES_TRANSFER(bytes_transfer_piod_read_i_64_text, PIOD_READ_I, 64, TEXTIO) 3914 3915BYTES_TRANSFER(bytes_transfer_piod_write_d_8_text, PIOD_WRITE_D, 8, TEXTIO) 3916BYTES_TRANSFER(bytes_transfer_piod_write_d_16_text, PIOD_WRITE_D, 16, TEXTIO) 3917BYTES_TRANSFER(bytes_transfer_piod_write_d_32_text, PIOD_WRITE_D, 32, TEXTIO) 3918BYTES_TRANSFER(bytes_transfer_piod_write_d_64_text, PIOD_WRITE_D, 64, TEXTIO) 3919 3920BYTES_TRANSFER(bytes_transfer_piod_write_i_8_text, PIOD_WRITE_I, 8, TEXTIO) 3921BYTES_TRANSFER(bytes_transfer_piod_write_i_16_text, PIOD_WRITE_I, 16, TEXTIO) 3922BYTES_TRANSFER(bytes_transfer_piod_write_i_32_text, PIOD_WRITE_I, 32, TEXTIO) 3923BYTES_TRANSFER(bytes_transfer_piod_write_i_64_text, PIOD_WRITE_I, 64, TEXTIO) 3924 3925BYTES_TRANSFER(bytes_transfer_read_d_text, PT_READ_D, 32, TEXT) 3926BYTES_TRANSFER(bytes_transfer_read_i_text, PT_READ_I, 32, TEXT) 3927BYTES_TRANSFER(bytes_transfer_write_d_text, PT_WRITE_D, 32, TEXT) 3928BYTES_TRANSFER(bytes_transfer_write_i_text, PT_WRITE_I, 32, TEXT) 3929 3930// AUXV 3931 3932BYTES_TRANSFER(bytes_transfer_piod_read_auxv, PIOD_READ_AUXV, 4096, AUXV) 3933 3934/// ---------------------------------------------------------------------------- 3935 3936static void 3937bytes_transfer_alignment(const char *operation) 3938{ 3939 const int exitval = 5; 3940 const int sigval = SIGSTOP; 3941 pid_t child, wpid; 3942#if defined(TWAIT_HAVE_STATUS) 3943 int status; 3944#endif 3945 char *buffer; 3946 int vector; 3947 size_t len; 3948 size_t i; 3949 int op; 3950 3951 struct ptrace_io_desc io; 3952 struct ptrace_siginfo info; 3953 3954 memset(&io, 0, sizeof(io)); 3955 memset(&info, 0, sizeof(info)); 3956 3957 /* Testing misaligned byte transfer crossing page boundaries */ 3958 len = sysconf(_SC_PAGESIZE) * 2; 3959 buffer = malloc(len); 3960 ATF_REQUIRE(buffer != NULL); 3961 3962 /* Initialize the buffer with random data */ 3963 for (i = 0; i < len; i++) 3964 buffer[i] = i & 0xff; 3965 3966 DPRINTF("Before forking process PID=%d\n", getpid()); 3967 SYSCALL_REQUIRE((child = fork()) != -1); 3968 if (child == 0) { 3969 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3970 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3971 3972 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3973 FORKEE_ASSERT(raise(sigval) == 0); 3974 3975 DPRINTF("Before exiting of the child process\n"); 3976 _exit(exitval); 3977 } 3978 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3979 3980 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3981 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3982 3983 validate_status_stopped(status, sigval); 3984 3985 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 3986 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) 3987 != -1); 3988 3989 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 3990 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 3991 "si_errno=%#x\n", 3992 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 3993 info.psi_siginfo.si_errno); 3994 3995 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 3996 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 3997 3998 if (strcmp(operation, "PT_READ_I") == 0 || 3999 strcmp(operation, "PT_READ_D") == 0) { 4000 if (strcmp(operation, "PT_READ_I")) 4001 op = PT_READ_I; 4002 else 4003 op = PT_READ_D; 4004 4005 for (i = 0; i <= (len - sizeof(int)); i++) { 4006 errno = 0; 4007 vector = ptrace(op, child, buffer + i, 0); 4008 ATF_REQUIRE_EQ(errno, 0); 4009 ATF_REQUIRE(!memcmp(&vector, buffer + i, sizeof(int))); 4010 } 4011 } else if (strcmp(operation, "PT_WRITE_I") == 0 || 4012 strcmp(operation, "PT_WRITE_D") == 0) { 4013 if (strcmp(operation, "PT_WRITE_I")) 4014 op = PT_WRITE_I; 4015 else 4016 op = PT_WRITE_D; 4017 4018 for (i = 0; i <= (len - sizeof(int)); i++) { 4019 memcpy(&vector, buffer + i, sizeof(int)); 4020 SYSCALL_REQUIRE(ptrace(op, child, buffer + 1, vector) 4021 != -1); 4022 } 4023 } else if (strcmp(operation, "PIOD_READ_I") == 0 || 4024 strcmp(operation, "PIOD_READ_D") == 0) { 4025 if (strcmp(operation, "PIOD_READ_I")) 4026 op = PIOD_READ_I; 4027 else 4028 op = PIOD_READ_D; 4029 4030 io.piod_op = op; 4031 io.piod_addr = &vector; 4032 io.piod_len = sizeof(int); 4033 4034 for (i = 0; i <= (len - sizeof(int)); i++) { 4035 io.piod_offs = buffer + i; 4036 4037 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4038 != -1); 4039 ATF_REQUIRE(!memcmp(&vector, buffer + i, sizeof(int))); 4040 } 4041 } else if (strcmp(operation, "PIOD_WRITE_I") == 0 || 4042 strcmp(operation, "PIOD_WRITE_D") == 0) { 4043 if (strcmp(operation, "PIOD_WRITE_I")) 4044 op = PIOD_WRITE_I; 4045 else 4046 op = PIOD_WRITE_D; 4047 4048 io.piod_op = op; 4049 io.piod_addr = &vector; 4050 io.piod_len = sizeof(int); 4051 4052 for (i = 0; i <= (len - sizeof(int)); i++) { 4053 io.piod_offs = buffer + i; 4054 4055 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4056 != -1); 4057 } 4058 } else if (strcmp(operation, "PIOD_READ_AUXV") == 0) { 4059 io.piod_op = PIOD_READ_AUXV; 4060 io.piod_addr = &vector; 4061 io.piod_len = sizeof(int); 4062 4063 errno = 0; 4064 i = 0; 4065 /* Read the whole AUXV vector, it has no clear length */ 4066 while (errno != EIO) { 4067 io.piod_offs = (void *)(intptr_t)i; 4068 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4069 != -1 || (errno == EIO && i > 0)); 4070 ++i; 4071 } 4072 } 4073 4074 DPRINTF("Before resuming the child process where it left off " 4075 "and without signal to be sent\n"); 4076 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4077 4078 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4079 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4080 child); 4081 4082 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4083 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4084} 4085 4086#define BYTES_TRANSFER_ALIGNMENT(test, operation) \ 4087ATF_TC(test); \ 4088ATF_TC_HEAD(test, tc) \ 4089{ \ 4090 atf_tc_set_md_var(tc, "descr", \ 4091 "Verify bytes transfer for potentially misaligned " \ 4092 "operation " operation); \ 4093} \ 4094 \ 4095ATF_TC_BODY(test, tc) \ 4096{ \ 4097 \ 4098 bytes_transfer_alignment(operation); \ 4099} 4100 4101BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_read_i, "PT_READ_I") 4102BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_read_d, "PT_READ_D") 4103BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_write_i, "PT_WRITE_I") 4104BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_write_d, "PT_WRITE_D") 4105 4106BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_i, "PIOD_READ_I") 4107BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_d, "PIOD_READ_D") 4108BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_write_i, "PIOD_WRITE_I") 4109BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_write_d, "PIOD_WRITE_D") 4110 4111BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_auxv, "PIOD_READ_AUXV") 4112 4113/// ---------------------------------------------------------------------------- 4114 4115static void 4116bytes_transfer_eof(const char *operation) 4117{ 4118 const int exitval = 5; 4119 const int sigval = SIGSTOP; 4120 pid_t child, wpid; 4121#if defined(TWAIT_HAVE_STATUS) 4122 int status; 4123#endif 4124 FILE *fp; 4125 char *p; 4126 int vector; 4127 int op; 4128 4129 struct ptrace_io_desc io; 4130 struct ptrace_siginfo info; 4131 4132 memset(&io, 0, sizeof(io)); 4133 memset(&info, 0, sizeof(info)); 4134 4135 vector = 0; 4136 4137 fp = tmpfile(); 4138 ATF_REQUIRE(fp != NULL); 4139 4140 p = mmap(0, 1, PROT_READ|PROT_WRITE, MAP_PRIVATE, fileno(fp), 0); 4141 ATF_REQUIRE(p != MAP_FAILED); 4142 4143 DPRINTF("Before forking process PID=%d\n", getpid()); 4144 SYSCALL_REQUIRE((child = fork()) != -1); 4145 if (child == 0) { 4146 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4147 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4148 4149 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4150 FORKEE_ASSERT(raise(sigval) == 0); 4151 4152 DPRINTF("Before exiting of the child process\n"); 4153 _exit(exitval); 4154 } 4155 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4156 4157 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4158 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4159 4160 validate_status_stopped(status, sigval); 4161 4162 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4163 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) 4164 != -1); 4165 4166 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4167 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 4168 "si_errno=%#x\n", 4169 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4170 info.psi_siginfo.si_errno); 4171 4172 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4173 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4174 4175 if (strcmp(operation, "PT_READ_I") == 0 || 4176 strcmp(operation, "PT_READ_D") == 0) { 4177 if (strcmp(operation, "PT_READ_I")) 4178 op = PT_READ_I; 4179 else 4180 op = PT_READ_D; 4181 4182 errno = 0; 4183 SYSCALL_REQUIRE(ptrace(op, child, p, 0) == -1); 4184 ATF_REQUIRE_EQ(errno, EINVAL); 4185 } else if (strcmp(operation, "PT_WRITE_I") == 0 || 4186 strcmp(operation, "PT_WRITE_D") == 0) { 4187 if (strcmp(operation, "PT_WRITE_I")) 4188 op = PT_WRITE_I; 4189 else 4190 op = PT_WRITE_D; 4191 4192 errno = 0; 4193 SYSCALL_REQUIRE(ptrace(op, child, p, vector) == -1); 4194 ATF_REQUIRE_EQ(errno, EINVAL); 4195 } else if (strcmp(operation, "PIOD_READ_I") == 0 || 4196 strcmp(operation, "PIOD_READ_D") == 0) { 4197 if (strcmp(operation, "PIOD_READ_I")) 4198 op = PIOD_READ_I; 4199 else 4200 op = PIOD_READ_D; 4201 4202 io.piod_op = op; 4203 io.piod_addr = &vector; 4204 io.piod_len = sizeof(int); 4205 io.piod_offs = p; 4206 4207 errno = 0; 4208 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) == -1); 4209 ATF_REQUIRE_EQ(errno, EINVAL); 4210 } else if (strcmp(operation, "PIOD_WRITE_I") == 0 || 4211 strcmp(operation, "PIOD_WRITE_D") == 0) { 4212 if (strcmp(operation, "PIOD_WRITE_I")) 4213 op = PIOD_WRITE_I; 4214 else 4215 op = PIOD_WRITE_D; 4216 4217 io.piod_op = op; 4218 io.piod_addr = &vector; 4219 io.piod_len = sizeof(int); 4220 io.piod_offs = p; 4221 4222 errno = 0; 4223 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) == -1); 4224 ATF_REQUIRE_EQ(errno, EINVAL); 4225 } 4226 4227 DPRINTF("Before resuming the child process where it left off " 4228 "and without signal to be sent\n"); 4229 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4230 4231 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4232 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4233 child); 4234 4235 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4236 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4237} 4238 4239#define BYTES_TRANSFER_EOF(test, operation) \ 4240ATF_TC(test); \ 4241ATF_TC_HEAD(test, tc) \ 4242{ \ 4243 atf_tc_set_md_var(tc, "descr", \ 4244 "Verify bytes EOF byte transfer for the " operation \ 4245 " operation"); \ 4246} \ 4247 \ 4248ATF_TC_BODY(test, tc) \ 4249{ \ 4250 \ 4251 bytes_transfer_eof(operation); \ 4252} 4253 4254BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_read_i, "PT_READ_I") 4255BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_read_d, "PT_READ_D") 4256BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_write_i, "PT_WRITE_I") 4257BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_write_d, "PT_WRITE_D") 4258 4259BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_read_i, "PIOD_READ_I") 4260BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_read_d, "PIOD_READ_D") 4261BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_write_i, "PIOD_WRITE_I") 4262BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_write_d, "PIOD_WRITE_D") 4263 4264/// ---------------------------------------------------------------------------- 4265 4266#if defined(HAVE_GPREGS) || defined(HAVE_FPREGS) 4267static void 4268access_regs(const char *regset, const char *aux) 4269{ 4270 const int exitval = 5; 4271 const int sigval = SIGSTOP; 4272 pid_t child, wpid; 4273#if defined(TWAIT_HAVE_STATUS) 4274 int status; 4275#endif 4276#if defined(HAVE_GPREGS) 4277 struct reg gpr; 4278 register_t rgstr; 4279#endif 4280#if defined(HAVE_FPREGS) 4281 struct fpreg fpr; 4282#endif 4283 4284#if !defined(HAVE_GPREGS) 4285 if (strcmp(regset, "regs") == 0) 4286 atf_tc_fail("Impossible test scenario!"); 4287#endif 4288 4289#if !defined(HAVE_FPREGS) 4290 if (strcmp(regset, "fpregs") == 0) 4291 atf_tc_fail("Impossible test scenario!"); 4292#endif 4293 4294 DPRINTF("Before forking process PID=%d\n", getpid()); 4295 SYSCALL_REQUIRE((child = fork()) != -1); 4296 if (child == 0) { 4297 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4298 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4299 4300 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4301 FORKEE_ASSERT(raise(sigval) == 0); 4302 4303 DPRINTF("Before exiting of the child process\n"); 4304 _exit(exitval); 4305 } 4306 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4307 4308 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4309 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4310 4311 validate_status_stopped(status, sigval); 4312 4313#if defined(HAVE_GPREGS) 4314 if (strcmp(regset, "regs") == 0) { 4315 DPRINTF("Call GETREGS for the child process\n"); 4316 SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1); 4317 4318 if (strcmp(aux, "none") == 0) { 4319 DPRINTF("Retrieved registers\n"); 4320 } else if (strcmp(aux, "pc") == 0) { 4321 rgstr = PTRACE_REG_PC(&gpr); 4322 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4323 } else if (strcmp(aux, "set_pc") == 0) { 4324 rgstr = PTRACE_REG_PC(&gpr); 4325 PTRACE_REG_SET_PC(&gpr, rgstr); 4326 } else if (strcmp(aux, "sp") == 0) { 4327 rgstr = PTRACE_REG_SP(&gpr); 4328 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4329 } else if (strcmp(aux, "intrv") == 0) { 4330 rgstr = PTRACE_REG_INTRV(&gpr); 4331 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4332 } else if (strcmp(aux, "setregs") == 0) { 4333 DPRINTF("Call SETREGS for the child process\n"); 4334 SYSCALL_REQUIRE( 4335 ptrace(PT_GETREGS, child, &gpr, 0) != -1); 4336 } 4337 } 4338#endif 4339 4340#if defined(HAVE_FPREGS) 4341 if (strcmp(regset, "fpregs") == 0) { 4342 DPRINTF("Call GETFPREGS for the child process\n"); 4343 SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1); 4344 4345 if (strcmp(aux, "getfpregs") == 0) { 4346 DPRINTF("Retrieved FP registers\n"); 4347 } else if (strcmp(aux, "setfpregs") == 0) { 4348 DPRINTF("Call SETFPREGS for the child\n"); 4349 SYSCALL_REQUIRE( 4350 ptrace(PT_SETFPREGS, child, &fpr, 0) != -1); 4351 } 4352 } 4353#endif 4354 4355 DPRINTF("Before resuming the child process where it left off and " 4356 "without signal to be sent\n"); 4357 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4358 4359 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4360 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4361 4362 validate_status_exited(status, exitval); 4363 4364 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4365 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4366} 4367 4368#define ACCESS_REGS(test, regset, aux) \ 4369ATF_TC(test); \ 4370ATF_TC_HEAD(test, tc) \ 4371{ \ 4372 atf_tc_set_md_var(tc, "descr", \ 4373 "Verify " regset " with auxiliary operation: " aux); \ 4374} \ 4375 \ 4376ATF_TC_BODY(test, tc) \ 4377{ \ 4378 \ 4379 access_regs(regset, aux); \ 4380} 4381#endif 4382 4383#if defined(HAVE_GPREGS) 4384ACCESS_REGS(access_regs1, "regs", "none") 4385ACCESS_REGS(access_regs2, "regs", "pc") 4386ACCESS_REGS(access_regs3, "regs", "set_pc") 4387ACCESS_REGS(access_regs4, "regs", "sp") 4388ACCESS_REGS(access_regs5, "regs", "intrv") 4389ACCESS_REGS(access_regs6, "regs", "setregs") 4390#endif 4391#if defined(HAVE_FPREGS) 4392ACCESS_REGS(access_fpregs1, "fpregs", "getfpregs") 4393ACCESS_REGS(access_fpregs2, "fpregs", "setfpregs") 4394#endif 4395 4396/// ---------------------------------------------------------------------------- 4397 4398#if defined(PT_STEP) 4399static void 4400ptrace_step(int N, int setstep, bool masked, bool ignored) 4401{ 4402 const int exitval = 5; 4403 const int sigval = SIGSTOP; 4404 pid_t child, wpid; 4405#if defined(TWAIT_HAVE_STATUS) 4406 int status; 4407#endif 4408 int happy; 4409 struct sigaction sa; 4410 struct ptrace_siginfo info; 4411 sigset_t intmask; 4412 struct kinfo_proc2 kp; 4413 size_t len = sizeof(kp); 4414 4415 int name[6]; 4416 const size_t namelen = __arraycount(name); 4417 ki_sigset_t kp_sigmask; 4418 ki_sigset_t kp_sigignore; 4419 4420#if defined(__arm__) 4421 /* PT_STEP not supported on arm 32-bit */ 4422 atf_tc_expect_fail("PR kern/52119"); 4423#endif 4424 4425 DPRINTF("Before forking process PID=%d\n", getpid()); 4426 SYSCALL_REQUIRE((child = fork()) != -1); 4427 if (child == 0) { 4428 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4429 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4430 4431 if (masked) { 4432 sigemptyset(&intmask); 4433 sigaddset(&intmask, SIGTRAP); 4434 sigprocmask(SIG_BLOCK, &intmask, NULL); 4435 } 4436 4437 if (ignored) { 4438 memset(&sa, 0, sizeof(sa)); 4439 sa.sa_handler = SIG_IGN; 4440 sigemptyset(&sa.sa_mask); 4441 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 4442 } 4443 4444 happy = check_happy(999); 4445 4446 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4447 FORKEE_ASSERT(raise(sigval) == 0); 4448 4449 FORKEE_ASSERT_EQ(happy, check_happy(999)); 4450 4451 DPRINTF("Before exiting of the child process\n"); 4452 _exit(exitval); 4453 } 4454 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4455 4456 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4457 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4458 4459 validate_status_stopped(status, sigval); 4460 4461 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4462 SYSCALL_REQUIRE( 4463 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4464 4465 DPRINTF("Before checking siginfo_t\n"); 4466 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4467 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4468 4469 name[0] = CTL_KERN, 4470 name[1] = KERN_PROC2, 4471 name[2] = KERN_PROC_PID; 4472 name[3] = child; 4473 name[4] = sizeof(kp); 4474 name[5] = 1; 4475 4476 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 4477 4478 if (masked) 4479 kp_sigmask = kp.p_sigmask; 4480 4481 if (ignored) 4482 kp_sigignore = kp.p_sigignore; 4483 4484 while (N --> 0) { 4485 if (setstep) { 4486 DPRINTF("Before resuming the child process where it " 4487 "left off and without signal to be sent (use " 4488 "PT_SETSTEP and PT_CONTINUE)\n"); 4489 SYSCALL_REQUIRE(ptrace(PT_SETSTEP, child, 0, 0) != -1); 4490 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) 4491 != -1); 4492 } else { 4493 DPRINTF("Before resuming the child process where it " 4494 "left off and without signal to be sent (use " 4495 "PT_STEP)\n"); 4496 SYSCALL_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) 4497 != -1); 4498 } 4499 4500 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4501 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4502 child); 4503 4504 validate_status_stopped(status, SIGTRAP); 4505 4506 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4507 SYSCALL_REQUIRE( 4508 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4509 4510 DPRINTF("Before checking siginfo_t\n"); 4511 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 4512 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_TRACE); 4513 4514 if (setstep) { 4515 SYSCALL_REQUIRE(ptrace(PT_CLEARSTEP, child, 0, 0) != -1); 4516 } 4517 4518 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 4519 4520 if (masked) { 4521 DPRINTF("kp_sigmask=" 4522 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4523 PRIx32 "\n", 4524 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 4525 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 4526 4527 DPRINTF("kp.p_sigmask=" 4528 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4529 PRIx32 "\n", 4530 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 4531 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 4532 4533 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 4534 sizeof(kp_sigmask))); 4535 } 4536 4537 if (ignored) { 4538 DPRINTF("kp_sigignore=" 4539 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4540 PRIx32 "\n", 4541 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 4542 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 4543 4544 DPRINTF("kp.p_sigignore=" 4545 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4546 PRIx32 "\n", 4547 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 4548 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 4549 4550 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 4551 sizeof(kp_sigignore))); 4552 } 4553 } 4554 4555 DPRINTF("Before resuming the child process where it left off and " 4556 "without signal to be sent\n"); 4557 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4558 4559 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4560 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4561 4562 validate_status_exited(status, exitval); 4563 4564 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4565 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4566} 4567 4568#define PTRACE_STEP(test, N, setstep) \ 4569ATF_TC(test); \ 4570ATF_TC_HEAD(test, tc) \ 4571{ \ 4572 atf_tc_set_md_var(tc, "descr", \ 4573 "Verify " #N " (PT_SETSTEP set to: " #setstep ")"); \ 4574} \ 4575 \ 4576ATF_TC_BODY(test, tc) \ 4577{ \ 4578 \ 4579 ptrace_step(N, setstep, false, false); \ 4580} 4581 4582PTRACE_STEP(step1, 1, 0) 4583PTRACE_STEP(step2, 2, 0) 4584PTRACE_STEP(step3, 3, 0) 4585PTRACE_STEP(step4, 4, 0) 4586PTRACE_STEP(setstep1, 1, 1) 4587PTRACE_STEP(setstep2, 2, 1) 4588PTRACE_STEP(setstep3, 3, 1) 4589PTRACE_STEP(setstep4, 4, 1) 4590 4591ATF_TC(step_signalmasked); 4592ATF_TC_HEAD(step_signalmasked, tc) 4593{ 4594 atf_tc_set_md_var(tc, "descr", "Verify PT_STEP with masked SIGTRAP"); 4595} 4596 4597ATF_TC_BODY(step_signalmasked, tc) 4598{ 4599 4600 ptrace_step(1, 0, true, false); 4601} 4602 4603ATF_TC(step_signalignored); 4604ATF_TC_HEAD(step_signalignored, tc) 4605{ 4606 atf_tc_set_md_var(tc, "descr", "Verify PT_STEP with ignored SIGTRAP"); 4607} 4608 4609ATF_TC_BODY(step_signalignored, tc) 4610{ 4611 4612 ptrace_step(1, 0, false, true); 4613} 4614#endif 4615 4616/// ---------------------------------------------------------------------------- 4617 4618static void 4619ptrace_kill(const char *type) 4620{ 4621 const int sigval = SIGSTOP; 4622 pid_t child, wpid; 4623#if defined(TWAIT_HAVE_STATUS) 4624 int status; 4625#endif 4626 4627 DPRINTF("Before forking process PID=%d\n", getpid()); 4628 SYSCALL_REQUIRE((child = fork()) != -1); 4629 if (child == 0) { 4630 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4631 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4632 4633 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4634 FORKEE_ASSERT(raise(sigval) == 0); 4635 4636 /* NOTREACHED */ 4637 FORKEE_ASSERTX(0 && 4638 "Child should be terminated by a signal from its parent"); 4639 } 4640 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4641 4642 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4643 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4644 4645 validate_status_stopped(status, sigval); 4646 4647 DPRINTF("Before killing the child process with %s\n", type); 4648 if (strcmp(type, "ptrace(PT_KILL)") == 0) { 4649 SYSCALL_REQUIRE(ptrace(PT_KILL, child, (void*)1, 0) != -1); 4650 } else if (strcmp(type, "kill(SIGKILL)") == 0) { 4651 kill(child, SIGKILL); 4652 } else if (strcmp(type, "killpg(SIGKILL)") == 0) { 4653 setpgid(child, 0); 4654 killpg(getpgid(child), SIGKILL); 4655 } 4656 4657 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4658 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4659 4660 validate_status_signaled(status, SIGKILL, 0); 4661 4662 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4663 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4664} 4665 4666#define PTRACE_KILL(test, type) \ 4667ATF_TC(test); \ 4668ATF_TC_HEAD(test, tc) \ 4669{ \ 4670 atf_tc_set_md_var(tc, "descr", \ 4671 "Verify killing the child with " type); \ 4672} \ 4673 \ 4674ATF_TC_BODY(test, tc) \ 4675{ \ 4676 \ 4677 ptrace_kill(type); \ 4678} 4679 4680// PT_CONTINUE with SIGKILL is covered by traceme_sendsignal_simple1 4681PTRACE_KILL(kill1, "ptrace(PT_KILL)") 4682PTRACE_KILL(kill2, "kill(SIGKILL)") 4683PTRACE_KILL(kill3, "killpg(SIGKILL)") 4684 4685/// ---------------------------------------------------------------------------- 4686 4687static void 4688traceme_lwpinfo(const int threads) 4689{ 4690 const int sigval = SIGSTOP; 4691 const int sigval2 = SIGINT; 4692 pid_t child, wpid; 4693#if defined(TWAIT_HAVE_STATUS) 4694 int status; 4695#endif 4696 struct ptrace_lwpinfo lwp = {0, 0}; 4697 struct ptrace_siginfo info; 4698 4699 /* Maximum number of supported threads in this test */ 4700 pthread_t t[3]; 4701 int n, rv; 4702 4703 ATF_REQUIRE((int)__arraycount(t) >= threads); 4704 4705 DPRINTF("Before forking process PID=%d\n", getpid()); 4706 SYSCALL_REQUIRE((child = fork()) != -1); 4707 if (child == 0) { 4708 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4709 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4710 4711 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4712 FORKEE_ASSERT(raise(sigval) == 0); 4713 4714 for (n = 0; n < threads; n++) { 4715 rv = pthread_create(&t[n], NULL, infinite_thread, NULL); 4716 FORKEE_ASSERT(rv == 0); 4717 } 4718 4719 DPRINTF("Before raising %s from child\n", strsignal(sigval2)); 4720 FORKEE_ASSERT(raise(sigval2) == 0); 4721 4722 /* NOTREACHED */ 4723 FORKEE_ASSERTX(0 && "Not reached"); 4724 } 4725 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4726 4727 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4728 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4729 4730 validate_status_stopped(status, sigval); 4731 4732 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 4733 SYSCALL_REQUIRE( 4734 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4735 4736 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4737 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 4738 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4739 info.psi_siginfo.si_errno); 4740 4741 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4742 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4743 4744 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4745 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4746 4747 DPRINTF("Assert that there exists a single thread only\n"); 4748 ATF_REQUIRE(lwp.pl_lwpid > 0); 4749 4750 DPRINTF("Assert that lwp thread %d received event PL_EVENT_SIGNAL\n", 4751 lwp.pl_lwpid); 4752 FORKEE_ASSERT_EQ(lwp.pl_event, PL_EVENT_SIGNAL); 4753 4754 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4755 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4756 4757 DPRINTF("Assert that there exists a single thread only\n"); 4758 ATF_REQUIRE_EQ(lwp.pl_lwpid, 0); 4759 4760 DPRINTF("Before resuming the child process where it left off and " 4761 "without signal to be sent\n"); 4762 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4763 4764 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4765 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4766 4767 validate_status_stopped(status, sigval2); 4768 4769 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 4770 SYSCALL_REQUIRE( 4771 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4772 4773 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4774 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 4775 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4776 info.psi_siginfo.si_errno); 4777 4778 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval2); 4779 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4780 4781 memset(&lwp, 0, sizeof(lwp)); 4782 4783 for (n = 0; n <= threads; n++) { 4784 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4785 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4786 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4787 4788 DPRINTF("Assert that the thread exists\n"); 4789 ATF_REQUIRE(lwp.pl_lwpid > 0); 4790 4791 DPRINTF("Assert that lwp thread %d received expected event\n", 4792 lwp.pl_lwpid); 4793 FORKEE_ASSERT_EQ(lwp.pl_event, info.psi_lwpid == lwp.pl_lwpid ? 4794 PL_EVENT_SIGNAL : PL_EVENT_NONE); 4795 } 4796 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4797 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4798 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4799 4800 DPRINTF("Assert that there are no more threads\n"); 4801 ATF_REQUIRE_EQ(lwp.pl_lwpid, 0); 4802 4803 DPRINTF("Before resuming the child process where it left off and " 4804 "without signal to be sent\n"); 4805 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, SIGKILL) != -1); 4806 4807 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4808 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4809 4810 validate_status_signaled(status, SIGKILL, 0); 4811 4812 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4813 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4814} 4815 4816#define TRACEME_LWPINFO(test, threads) \ 4817ATF_TC(test); \ 4818ATF_TC_HEAD(test, tc) \ 4819{ \ 4820 atf_tc_set_md_var(tc, "descr", \ 4821 "Verify LWPINFO with the child with " #threads \ 4822 " spawned extra threads"); \ 4823} \ 4824 \ 4825ATF_TC_BODY(test, tc) \ 4826{ \ 4827 \ 4828 traceme_lwpinfo(threads); \ 4829} 4830 4831TRACEME_LWPINFO(traceme_lwpinfo0, 0) 4832TRACEME_LWPINFO(traceme_lwpinfo1, 1) 4833TRACEME_LWPINFO(traceme_lwpinfo2, 2) 4834TRACEME_LWPINFO(traceme_lwpinfo3, 3) 4835 4836/// ---------------------------------------------------------------------------- 4837 4838#if defined(TWAIT_HAVE_PID) 4839static void 4840attach_lwpinfo(const int threads) 4841{ 4842 const int sigval = SIGINT; 4843 struct msg_fds parent_tracee, parent_tracer; 4844 const int exitval_tracer = 10; 4845 pid_t tracee, tracer, wpid; 4846 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 4847#if defined(TWAIT_HAVE_STATUS) 4848 int status; 4849#endif 4850 struct ptrace_lwpinfo lwp = {0, 0}; 4851 struct ptrace_siginfo info; 4852 4853 /* Maximum number of supported threads in this test */ 4854 pthread_t t[3]; 4855 int n, rv; 4856 4857 DPRINTF("Spawn tracee\n"); 4858 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 4859 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 4860 tracee = atf_utils_fork(); 4861 if (tracee == 0) { 4862 /* Wait for message from the parent */ 4863 CHILD_TO_PARENT("tracee ready", parent_tracee, msg); 4864 4865 CHILD_FROM_PARENT("spawn threads", parent_tracee, msg); 4866 4867 for (n = 0; n < threads; n++) { 4868 rv = pthread_create(&t[n], NULL, infinite_thread, NULL); 4869 FORKEE_ASSERT(rv == 0); 4870 } 4871 4872 CHILD_TO_PARENT("tracee exit", parent_tracee, msg); 4873 4874 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4875 FORKEE_ASSERT(raise(sigval) == 0); 4876 4877 /* NOTREACHED */ 4878 FORKEE_ASSERTX(0 && "Not reached"); 4879 } 4880 PARENT_FROM_CHILD("tracee ready", parent_tracee, msg); 4881 4882 DPRINTF("Spawn debugger\n"); 4883 tracer = atf_utils_fork(); 4884 if (tracer == 0) { 4885 /* No IPC to communicate with the child */ 4886 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 4887 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 4888 4889 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 4890 FORKEE_REQUIRE_SUCCESS( 4891 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 4892 4893 forkee_status_stopped(status, SIGSTOP); 4894 4895 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 4896 "tracee"); 4897 FORKEE_ASSERT( 4898 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 4899 4900 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4901 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 4902 "si_errno=%#x\n", 4903 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4904 info.psi_siginfo.si_errno); 4905 4906 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, SIGSTOP); 4907 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_USER); 4908 4909 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4910 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 4911 != -1); 4912 4913 DPRINTF("Assert that there exists a thread\n"); 4914 FORKEE_ASSERTX(lwp.pl_lwpid > 0); 4915 4916 DPRINTF("Assert that lwp thread %d received event " 4917 "PL_EVENT_SIGNAL\n", lwp.pl_lwpid); 4918 FORKEE_ASSERT_EQ(lwp.pl_event, PL_EVENT_SIGNAL); 4919 4920 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 4921 "tracee\n"); 4922 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 4923 != -1); 4924 4925 DPRINTF("Assert that there are no more lwp threads in " 4926 "tracee\n"); 4927 FORKEE_ASSERT_EQ(lwp.pl_lwpid, 0); 4928 4929 /* Resume tracee with PT_CONTINUE */ 4930 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 4931 4932 /* Inform parent that tracer has attached to tracee */ 4933 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 4934 4935 /* Wait for parent */ 4936 CHILD_FROM_PARENT("tracer wait", parent_tracer, msg); 4937 4938 /* Wait for tracee and assert that it raised a signal */ 4939 FORKEE_REQUIRE_SUCCESS( 4940 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 4941 4942 forkee_status_stopped(status, SIGINT); 4943 4944 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 4945 "child"); 4946 FORKEE_ASSERT( 4947 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 4948 4949 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4950 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 4951 "si_errno=%#x\n", 4952 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4953 info.psi_siginfo.si_errno); 4954 4955 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sigval); 4956 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_LWP); 4957 4958 memset(&lwp, 0, sizeof(lwp)); 4959 4960 for (n = 0; n <= threads; n++) { 4961 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 4962 "child\n"); 4963 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, 4964 sizeof(lwp)) != -1); 4965 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4966 4967 DPRINTF("Assert that the thread exists\n"); 4968 FORKEE_ASSERT(lwp.pl_lwpid > 0); 4969 4970 DPRINTF("Assert that lwp thread %d received expected " 4971 "event\n", lwp.pl_lwpid); 4972 FORKEE_ASSERT_EQ(lwp.pl_event, 4973 info.psi_lwpid == lwp.pl_lwpid ? 4974 PL_EVENT_SIGNAL : PL_EVENT_NONE); 4975 } 4976 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 4977 "tracee\n"); 4978 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 4979 != -1); 4980 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4981 4982 DPRINTF("Assert that there are no more threads\n"); 4983 FORKEE_ASSERT_EQ(lwp.pl_lwpid, 0); 4984 4985 DPRINTF("Before resuming the child process where it left off " 4986 "and without signal to be sent\n"); 4987 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, SIGKILL) 4988 != -1); 4989 4990 /* Wait for tracee and assert that it exited */ 4991 FORKEE_REQUIRE_SUCCESS( 4992 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 4993 4994 forkee_status_signaled(status, SIGKILL, 0); 4995 4996 DPRINTF("Before exiting of the tracer process\n"); 4997 _exit(exitval_tracer); 4998 } 4999 5000 DPRINTF("Wait for the tracer to attach to the tracee\n"); 5001 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 5002 5003 DPRINTF("Resume the tracee and spawn threads\n"); 5004 PARENT_TO_CHILD("spawn threads", parent_tracee, msg); 5005 5006 DPRINTF("Resume the tracee and let it exit\n"); 5007 PARENT_FROM_CHILD("tracee exit", parent_tracee, msg); 5008 5009 DPRINTF("Resume the tracer and let it detect multiple threads\n"); 5010 PARENT_TO_CHILD("tracer wait", parent_tracer, msg); 5011 5012 DPRINTF("Wait for tracer to finish its job and exit - calling %s()\n", 5013 TWAIT_FNAME); 5014 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 5015 tracer); 5016 5017 validate_status_exited(status, exitval_tracer); 5018 5019 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 5020 TWAIT_FNAME); 5021 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 5022 tracee); 5023 5024 validate_status_signaled(status, SIGKILL, 0); 5025 5026 msg_close(&parent_tracer); 5027 msg_close(&parent_tracee); 5028} 5029 5030#define ATTACH_LWPINFO(test, threads) \ 5031ATF_TC(test); \ 5032ATF_TC_HEAD(test, tc) \ 5033{ \ 5034 atf_tc_set_md_var(tc, "descr", \ 5035 "Verify LWPINFO with the child with " #threads \ 5036 " spawned extra threads (tracer is not the original " \ 5037 "parent)"); \ 5038} \ 5039 \ 5040ATF_TC_BODY(test, tc) \ 5041{ \ 5042 \ 5043 attach_lwpinfo(threads); \ 5044} 5045 5046ATTACH_LWPINFO(attach_lwpinfo0, 0) 5047ATTACH_LWPINFO(attach_lwpinfo1, 1) 5048ATTACH_LWPINFO(attach_lwpinfo2, 2) 5049ATTACH_LWPINFO(attach_lwpinfo3, 3) 5050#endif 5051 5052/// ---------------------------------------------------------------------------- 5053 5054static void 5055ptrace_siginfo(bool faked, void (*sah)(int a, siginfo_t *b, void *c), int *signal_caught) 5056{ 5057 const int exitval = 5; 5058 const int sigval = SIGINT; 5059 const int sigfaked = SIGTRAP; 5060 const int sicodefaked = TRAP_BRKPT; 5061 pid_t child, wpid; 5062 struct sigaction sa; 5063#if defined(TWAIT_HAVE_STATUS) 5064 int status; 5065#endif 5066 struct ptrace_siginfo info; 5067 memset(&info, 0, sizeof(info)); 5068 5069 DPRINTF("Before forking process PID=%d\n", getpid()); 5070 SYSCALL_REQUIRE((child = fork()) != -1); 5071 if (child == 0) { 5072 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5073 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5074 5075 sa.sa_sigaction = sah; 5076 sa.sa_flags = SA_SIGINFO; 5077 sigemptyset(&sa.sa_mask); 5078 5079 FORKEE_ASSERT(sigaction(faked ? sigfaked : sigval, &sa, NULL) 5080 != -1); 5081 5082 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5083 FORKEE_ASSERT(raise(sigval) == 0); 5084 5085 FORKEE_ASSERT_EQ(*signal_caught, 1); 5086 5087 DPRINTF("Before exiting of the child process\n"); 5088 _exit(exitval); 5089 } 5090 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5091 5092 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5093 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5094 5095 validate_status_stopped(status, sigval); 5096 5097 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5098 SYSCALL_REQUIRE( 5099 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5100 5101 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5102 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5103 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5104 info.psi_siginfo.si_errno); 5105 5106 if (faked) { 5107 DPRINTF("Before setting new faked signal to signo=%d " 5108 "si_code=%d\n", sigfaked, sicodefaked); 5109 info.psi_siginfo.si_signo = sigfaked; 5110 info.psi_siginfo.si_code = sicodefaked; 5111 } 5112 5113 DPRINTF("Before calling ptrace(2) with PT_SET_SIGINFO for child\n"); 5114 SYSCALL_REQUIRE( 5115 ptrace(PT_SET_SIGINFO, child, &info, sizeof(info)) != -1); 5116 5117 if (faked) { 5118 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5119 "child\n"); 5120 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 5121 sizeof(info)) != -1); 5122 5123 DPRINTF("Before checking siginfo_t\n"); 5124 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigfaked); 5125 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, sicodefaked); 5126 } 5127 5128 DPRINTF("Before resuming the child process where it left off and " 5129 "without signal to be sent\n"); 5130 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 5131 faked ? sigfaked : sigval) != -1); 5132 5133 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5134 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5135 5136 validate_status_exited(status, exitval); 5137 5138 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5139 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5140} 5141 5142#define PTRACE_SIGINFO(test, faked) \ 5143ATF_TC(test); \ 5144ATF_TC_HEAD(test, tc) \ 5145{ \ 5146 atf_tc_set_md_var(tc, "descr", \ 5147 "Verify basic PT_GET_SIGINFO and PT_SET_SIGINFO calls" \ 5148 "with%s setting signal to new value", faked ? "" : "out"); \ 5149} \ 5150 \ 5151static int test##_caught = 0; \ 5152 \ 5153static void \ 5154test##_sighandler(int sig, siginfo_t *info, void *ctx) \ 5155{ \ 5156 if (faked) { \ 5157 FORKEE_ASSERT_EQ(sig, SIGTRAP); \ 5158 FORKEE_ASSERT_EQ(info->si_signo, SIGTRAP); \ 5159 FORKEE_ASSERT_EQ(info->si_code, TRAP_BRKPT); \ 5160 } else { \ 5161 FORKEE_ASSERT_EQ(sig, SIGINT); \ 5162 FORKEE_ASSERT_EQ(info->si_signo, SIGINT); \ 5163 FORKEE_ASSERT_EQ(info->si_code, SI_LWP); \ 5164 } \ 5165 \ 5166 ++ test##_caught; \ 5167} \ 5168 \ 5169ATF_TC_BODY(test, tc) \ 5170{ \ 5171 \ 5172 ptrace_siginfo(faked, test##_sighandler, & test##_caught); \ 5173} 5174 5175PTRACE_SIGINFO(siginfo_set_unmodified, false) 5176PTRACE_SIGINFO(siginfo_set_faked, true) 5177 5178/// ---------------------------------------------------------------------------- 5179 5180static void 5181traceme_exec(bool masked, bool ignored) 5182{ 5183 const int sigval = SIGTRAP; 5184 pid_t child, wpid; 5185#if defined(TWAIT_HAVE_STATUS) 5186 int status; 5187#endif 5188 struct sigaction sa; 5189 struct ptrace_siginfo info; 5190 sigset_t intmask; 5191 struct kinfo_proc2 kp; 5192 size_t len = sizeof(kp); 5193 5194 int name[6]; 5195 const size_t namelen = __arraycount(name); 5196 ki_sigset_t kp_sigmask; 5197 ki_sigset_t kp_sigignore; 5198 5199 memset(&info, 0, sizeof(info)); 5200 5201 DPRINTF("Before forking process PID=%d\n", getpid()); 5202 SYSCALL_REQUIRE((child = fork()) != -1); 5203 if (child == 0) { 5204 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5205 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5206 5207 if (masked) { 5208 sigemptyset(&intmask); 5209 sigaddset(&intmask, sigval); 5210 sigprocmask(SIG_BLOCK, &intmask, NULL); 5211 } 5212 5213 if (ignored) { 5214 memset(&sa, 0, sizeof(sa)); 5215 sa.sa_handler = SIG_IGN; 5216 sigemptyset(&sa.sa_mask); 5217 FORKEE_ASSERT(sigaction(sigval, &sa, NULL) != -1); 5218 } 5219 5220 DPRINTF("Before calling execve(2) from child\n"); 5221 execlp("/bin/echo", "/bin/echo", NULL); 5222 5223 FORKEE_ASSERT(0 && "Not reached"); 5224 } 5225 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5226 5227 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5228 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5229 5230 validate_status_stopped(status, sigval); 5231 5232 name[0] = CTL_KERN, 5233 name[1] = KERN_PROC2, 5234 name[2] = KERN_PROC_PID; 5235 name[3] = getpid(); 5236 name[4] = sizeof(kp); 5237 name[5] = 1; 5238 5239 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5240 5241 if (masked) 5242 kp_sigmask = kp.p_sigmask; 5243 5244 if (ignored) 5245 kp_sigignore = kp.p_sigignore; 5246 5247 name[3] = getpid(); 5248 5249 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5250 5251 if (masked) { 5252 DPRINTF("kp_sigmask=" 5253 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5254 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5255 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5256 5257 DPRINTF("kp.p_sigmask=" 5258 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5259 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5260 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5261 5262 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5263 sizeof(kp_sigmask))); 5264 } 5265 5266 if (ignored) { 5267 DPRINTF("kp_sigignore=" 5268 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5269 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5270 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5271 5272 DPRINTF("kp.p_sigignore=" 5273 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5274 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5275 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5276 5277 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5278 sizeof(kp_sigignore))); 5279 } 5280 5281 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5282 SYSCALL_REQUIRE( 5283 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5284 5285 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5286 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5287 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5288 info.psi_siginfo.si_errno); 5289 5290 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5291 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_EXEC); 5292 5293 DPRINTF("Before resuming the child process where it left off and " 5294 "without signal to be sent\n"); 5295 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5296 5297 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5298 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5299 5300 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5301 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5302} 5303 5304#define TRACEME_EXEC(test, masked, ignored) \ 5305ATF_TC(test); \ 5306ATF_TC_HEAD(test, tc) \ 5307{ \ 5308 atf_tc_set_md_var(tc, "descr", \ 5309 "Detect SIGTRAP TRAP_EXEC from " \ 5310 "child%s%s", masked ? " with masked signal" : "", \ 5311 masked ? " with ignored signal" : ""); \ 5312} \ 5313 \ 5314ATF_TC_BODY(test, tc) \ 5315{ \ 5316 \ 5317 traceme_exec(masked, ignored); \ 5318} 5319 5320TRACEME_EXEC(traceme_exec, false, false) 5321TRACEME_EXEC(traceme_signalmasked_exec, true, false) 5322TRACEME_EXEC(traceme_signalignored_exec, false, true) 5323 5324/// ---------------------------------------------------------------------------- 5325 5326static volatile int done; 5327 5328static void * 5329trace_threads_cb(void *arg __unused) 5330{ 5331 5332 done++; 5333 5334 while (done < 3) 5335 continue; 5336 5337 return NULL; 5338} 5339 5340static void 5341trace_threads(bool trace_create, bool trace_exit) 5342{ 5343 const int sigval = SIGSTOP; 5344 pid_t child, wpid; 5345#if defined(TWAIT_HAVE_STATUS) 5346 int status; 5347#endif 5348 ptrace_state_t state; 5349 const int slen = sizeof(state); 5350 ptrace_event_t event; 5351 const int elen = sizeof(event); 5352 struct ptrace_siginfo info; 5353 5354 pthread_t t[3]; 5355 int rv; 5356 size_t n; 5357 lwpid_t lid; 5358 5359 /* Track created and exited threads */ 5360 bool traced_lwps[__arraycount(t)]; 5361 5362 atf_tc_skip("PR kern/51995"); 5363 5364 DPRINTF("Before forking process PID=%d\n", getpid()); 5365 SYSCALL_REQUIRE((child = fork()) != -1); 5366 if (child == 0) { 5367 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5368 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5369 5370 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5371 FORKEE_ASSERT(raise(sigval) == 0); 5372 5373 for (n = 0; n < __arraycount(t); n++) { 5374 rv = pthread_create(&t[n], NULL, trace_threads_cb, 5375 NULL); 5376 FORKEE_ASSERT(rv == 0); 5377 } 5378 5379 for (n = 0; n < __arraycount(t); n++) { 5380 rv = pthread_join(t[n], NULL); 5381 FORKEE_ASSERT(rv == 0); 5382 } 5383 5384 /* 5385 * There is race between _exit() and pthread_join() detaching 5386 * a thread. For simplicity kill the process after detecting 5387 * LWP events. 5388 */ 5389 while (true) 5390 continue; 5391 5392 FORKEE_ASSERT(0 && "Not reached"); 5393 } 5394 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5395 5396 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5397 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5398 5399 validate_status_stopped(status, sigval); 5400 5401 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5402 SYSCALL_REQUIRE( 5403 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5404 5405 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5406 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5407 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5408 info.psi_siginfo.si_errno); 5409 5410 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5411 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 5412 5413 DPRINTF("Set LWP event mask for the child %d\n", child); 5414 memset(&event, 0, sizeof(event)); 5415 if (trace_create) 5416 event.pe_set_event |= PTRACE_LWP_CREATE; 5417 if (trace_exit) 5418 event.pe_set_event |= PTRACE_LWP_EXIT; 5419 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 5420 5421 DPRINTF("Before resuming the child process where it left off and " 5422 "without signal to be sent\n"); 5423 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5424 5425 memset(traced_lwps, 0, sizeof(traced_lwps)); 5426 5427 for (n = 0; n < (trace_create ? __arraycount(t) : 0); n++) { 5428 DPRINTF("Before calling %s() for the child - expected stopped " 5429 "SIGTRAP\n", TWAIT_FNAME); 5430 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5431 child); 5432 5433 validate_status_stopped(status, SIGTRAP); 5434 5435 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5436 "child\n"); 5437 SYSCALL_REQUIRE( 5438 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5439 5440 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5441 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5442 "si_errno=%#x\n", 5443 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5444 info.psi_siginfo.si_errno); 5445 5446 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5447 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5448 5449 SYSCALL_REQUIRE( 5450 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5451 5452 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_CREATE, 5453 "%d != %d", state.pe_report_event, PTRACE_LWP_CREATE); 5454 5455 lid = state.pe_lwp; 5456 DPRINTF("Reported PTRACE_LWP_CREATE event with lid %d\n", lid); 5457 5458 traced_lwps[lid - 1] = true; 5459 5460 DPRINTF("Before resuming the child process where it left off " 5461 "and without signal to be sent\n"); 5462 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5463 } 5464 5465 for (n = 0; n < (trace_exit ? __arraycount(t) : 0); n++) { 5466 DPRINTF("Before calling %s() for the child - expected stopped " 5467 "SIGTRAP\n", TWAIT_FNAME); 5468 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5469 child); 5470 5471 validate_status_stopped(status, SIGTRAP); 5472 5473 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5474 "child\n"); 5475 SYSCALL_REQUIRE( 5476 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5477 5478 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5479 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5480 "si_errno=%#x\n", 5481 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5482 info.psi_siginfo.si_errno); 5483 5484 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5485 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5486 5487 SYSCALL_REQUIRE( 5488 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5489 5490 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_EXIT, 5491 "%d != %d", state.pe_report_event, PTRACE_LWP_EXIT); 5492 5493 lid = state.pe_lwp; 5494 DPRINTF("Reported PTRACE_LWP_EXIT event with lid %d\n", lid); 5495 5496 if (trace_create) { 5497 ATF_REQUIRE(traced_lwps[lid - 1] == true); 5498 traced_lwps[lid - 1] = false; 5499 } 5500 5501 DPRINTF("Before resuming the child process where it left off " 5502 "and without signal to be sent\n"); 5503 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5504 } 5505 5506 kill(child, SIGKILL); 5507 5508 DPRINTF("Before calling %s() for the child - expected exited\n", 5509 TWAIT_FNAME); 5510 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5511 5512 validate_status_signaled(status, SIGKILL, 0); 5513 5514 DPRINTF("Before calling %s() for the child - expected no process\n", 5515 TWAIT_FNAME); 5516 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5517} 5518 5519#define TRACE_THREADS(test, trace_create, trace_exit) \ 5520ATF_TC(test); \ 5521ATF_TC_HEAD(test, tc) \ 5522{ \ 5523 atf_tc_set_md_var(tc, "descr", \ 5524 "Verify spawning threads with%s tracing LWP create and" \ 5525 "with%s tracing LWP exit", trace_create ? "" : "out", \ 5526 trace_exit ? "" : "out"); \ 5527} \ 5528 \ 5529ATF_TC_BODY(test, tc) \ 5530{ \ 5531 \ 5532 trace_threads(trace_create, trace_exit); \ 5533} 5534 5535TRACE_THREADS(trace_thread1, false, false) 5536TRACE_THREADS(trace_thread2, false, true) 5537TRACE_THREADS(trace_thread3, true, false) 5538TRACE_THREADS(trace_thread4, true, true) 5539 5540/// ---------------------------------------------------------------------------- 5541 5542ATF_TC(signal_mask_unrelated); 5543ATF_TC_HEAD(signal_mask_unrelated, tc) 5544{ 5545 atf_tc_set_md_var(tc, "descr", 5546 "Verify that masking single unrelated signal does not stop tracer " 5547 "from catching other signals"); 5548} 5549 5550ATF_TC_BODY(signal_mask_unrelated, tc) 5551{ 5552 const int exitval = 5; 5553 const int sigval = SIGSTOP; 5554 const int sigmasked = SIGTRAP; 5555 const int signotmasked = SIGINT; 5556 pid_t child, wpid; 5557#if defined(TWAIT_HAVE_STATUS) 5558 int status; 5559#endif 5560 sigset_t intmask; 5561 5562 DPRINTF("Before forking process PID=%d\n", getpid()); 5563 SYSCALL_REQUIRE((child = fork()) != -1); 5564 if (child == 0) { 5565 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5566 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5567 5568 sigemptyset(&intmask); 5569 sigaddset(&intmask, sigmasked); 5570 sigprocmask(SIG_BLOCK, &intmask, NULL); 5571 5572 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5573 FORKEE_ASSERT(raise(sigval) == 0); 5574 5575 DPRINTF("Before raising %s from child\n", 5576 strsignal(signotmasked)); 5577 FORKEE_ASSERT(raise(signotmasked) == 0); 5578 5579 DPRINTF("Before exiting of the child process\n"); 5580 _exit(exitval); 5581 } 5582 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5583 5584 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5585 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5586 5587 validate_status_stopped(status, sigval); 5588 5589 DPRINTF("Before resuming the child process where it left off and " 5590 "without signal to be sent\n"); 5591 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5592 5593 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5594 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5595 5596 validate_status_stopped(status, signotmasked); 5597 5598 DPRINTF("Before resuming the child process where it left off and " 5599 "without signal to be sent\n"); 5600 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5601 5602 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5603 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5604 5605 validate_status_exited(status, exitval); 5606 5607 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5608 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5609} 5610 5611/// ---------------------------------------------------------------------------- 5612 5613#if defined(TWAIT_HAVE_PID) 5614static void 5615fork2_body(bool trackfork, bool trackvfork, bool trackvforkdone, bool masked, 5616 bool ignored) 5617{ 5618 const int exitval = 5; 5619 const int exitval2 = 15; 5620 const int sigval = SIGSTOP; 5621 pid_t child, child2 = 0, wpid; 5622#if defined(TWAIT_HAVE_STATUS) 5623 int status; 5624#endif 5625 ptrace_state_t state; 5626 const int slen = sizeof(state); 5627 ptrace_event_t event; 5628 const int elen = sizeof(event); 5629 pid_t (*fn)(void); 5630 struct sigaction sa; 5631 struct ptrace_siginfo info; 5632 sigset_t intmask; 5633 struct kinfo_proc2 kp; 5634 size_t len = sizeof(kp); 5635 5636 int name[6]; 5637 const size_t namelen = __arraycount(name); 5638 ki_sigset_t kp_sigmask; 5639 ki_sigset_t kp_sigignore; 5640 5641 if (trackfork) 5642 fn = fork; 5643 if (trackvfork || trackvforkdone) 5644 fn = vfork; 5645 5646 DPRINTF("Before forking process PID=%d\n", getpid()); 5647 SYSCALL_REQUIRE((child = fork()) != -1); 5648 if (child == 0) { 5649 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5650 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5651 5652 if (masked) { 5653 sigemptyset(&intmask); 5654 sigaddset(&intmask, SIGTRAP); 5655 sigprocmask(SIG_BLOCK, &intmask, NULL); 5656 } 5657 5658 if (ignored) { 5659 memset(&sa, 0, sizeof(sa)); 5660 sa.sa_handler = SIG_IGN; 5661 sigemptyset(&sa.sa_mask); 5662 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 5663 } 5664 5665 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5666 FORKEE_ASSERT(raise(sigval) == 0); 5667 5668 FORKEE_ASSERT((child2 = (fn)()) != -1); 5669 5670 if (child2 == 0) 5671 _exit(exitval2); 5672 5673 FORKEE_REQUIRE_SUCCESS 5674 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 5675 5676 forkee_status_exited(status, exitval2); 5677 5678 DPRINTF("Before exiting of the child process\n"); 5679 _exit(exitval); 5680 } 5681 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5682 5683 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5684 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5685 5686 validate_status_stopped(status, sigval); 5687 5688 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5689 SYSCALL_REQUIRE( 5690 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5691 5692 DPRINTF("Before checking siginfo_t\n"); 5693 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5694 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 5695 5696 name[0] = CTL_KERN, 5697 name[1] = KERN_PROC2, 5698 name[2] = KERN_PROC_PID; 5699 name[3] = child; 5700 name[4] = sizeof(kp); 5701 name[5] = 1; 5702 5703 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5704 5705 if (masked) 5706 kp_sigmask = kp.p_sigmask; 5707 5708 if (ignored) 5709 kp_sigignore = kp.p_sigignore; 5710 5711 DPRINTF("Set 0%s%s%s in EVENT_MASK for the child %d\n", 5712 trackfork ? "|PTRACE_FORK" : "", 5713 trackvfork ? "|PTRACE_VFORK" : "", 5714 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 5715 event.pe_set_event = 0; 5716 if (trackfork) 5717 event.pe_set_event |= PTRACE_FORK; 5718 if (trackvfork) 5719 event.pe_set_event |= PTRACE_VFORK; 5720 if (trackvforkdone) 5721 event.pe_set_event |= PTRACE_VFORK_DONE; 5722 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 5723 5724 DPRINTF("Before resuming the child process where it left off and " 5725 "without signal to be sent\n"); 5726 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5727 5728 if (trackfork || trackvfork) { 5729 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 5730 child); 5731 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5732 child); 5733 5734 validate_status_stopped(status, SIGTRAP); 5735 5736 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5737 5738 if (masked) { 5739 DPRINTF("kp_sigmask=" 5740 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5741 PRIx32 "\n", 5742 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5743 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5744 5745 DPRINTF("kp.p_sigmask=" 5746 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5747 PRIx32 "\n", 5748 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5749 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5750 5751 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5752 sizeof(kp_sigmask))); 5753 } 5754 5755 if (ignored) { 5756 DPRINTF("kp_sigignore=" 5757 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5758 PRIx32 "\n", 5759 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5760 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5761 5762 DPRINTF("kp.p_sigignore=" 5763 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5764 PRIx32 "\n", 5765 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5766 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5767 5768 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5769 sizeof(kp_sigignore))); 5770 } 5771 5772 SYSCALL_REQUIRE( 5773 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5774 if (trackfork) { 5775 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 5776 PTRACE_FORK); 5777 } 5778 if (trackvfork) { 5779 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 5780 PTRACE_VFORK); 5781 } 5782 5783 child2 = state.pe_other_pid; 5784 DPRINTF("Reported ptrace event with forkee %d\n", child2); 5785 5786 DPRINTF("Before calling %s() for the forkee %d of the child " 5787 "%d\n", TWAIT_FNAME, child2, child); 5788 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 5789 child2); 5790 5791 validate_status_stopped(status, SIGTRAP); 5792 5793 name[3] = child2; 5794 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5795 5796 if (masked) { 5797 DPRINTF("kp_sigmask=" 5798 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5799 PRIx32 "\n", 5800 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5801 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5802 5803 DPRINTF("kp.p_sigmask=" 5804 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5805 PRIx32 "\n", 5806 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5807 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5808 5809 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5810 sizeof(kp_sigmask))); 5811 } 5812 5813 if (ignored) { 5814 DPRINTF("kp_sigignore=" 5815 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5816 PRIx32 "\n", 5817 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5818 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5819 5820 DPRINTF("kp.p_sigignore=" 5821 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5822 PRIx32 "\n", 5823 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5824 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5825 5826 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5827 sizeof(kp_sigignore))); 5828 } 5829 5830 SYSCALL_REQUIRE( 5831 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 5832 if (trackfork) { 5833 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 5834 PTRACE_FORK); 5835 } 5836 if (trackvfork) { 5837 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 5838 PTRACE_VFORK); 5839 } 5840 5841 ATF_REQUIRE_EQ(state.pe_other_pid, child); 5842 5843 DPRINTF("Before resuming the forkee process where it left off " 5844 "and without signal to be sent\n"); 5845 SYSCALL_REQUIRE( 5846 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 5847 5848 DPRINTF("Before resuming the child process where it left off " 5849 "and without signal to be sent\n"); 5850 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5851 } 5852 5853 if (trackvforkdone) { 5854 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 5855 child); 5856 TWAIT_REQUIRE_SUCCESS( 5857 wpid = TWAIT_GENERIC(child, &status, 0), child); 5858 5859 validate_status_stopped(status, SIGTRAP); 5860 5861 name[3] = child; 5862 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5863 5864 /* 5865 * SIGCHLD is now pending in the signal queue and 5866 * the kernel presents it to userland as a masked signal. 5867 */ 5868 sigdelset((sigset_t *)&kp.p_sigmask, SIGCHLD); 5869 5870 if (masked) { 5871 DPRINTF("kp_sigmask=" 5872 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5873 PRIx32 "\n", 5874 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5875 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5876 5877 DPRINTF("kp.p_sigmask=" 5878 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5879 PRIx32 "\n", 5880 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5881 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5882 5883 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5884 sizeof(kp_sigmask))); 5885 } 5886 5887 if (ignored) { 5888 DPRINTF("kp_sigignore=" 5889 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5890 PRIx32 "\n", 5891 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5892 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5893 5894 DPRINTF("kp.p_sigignore=" 5895 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5896 PRIx32 "\n", 5897 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5898 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5899 5900 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5901 sizeof(kp_sigignore))); 5902 } 5903 5904 SYSCALL_REQUIRE( 5905 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5906 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 5907 5908 child2 = state.pe_other_pid; 5909 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 5910 child2); 5911 5912 DPRINTF("Before resuming the child process where it left off " 5913 "and without signal to be sent\n"); 5914 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5915 } 5916 5917 if (trackfork || trackvfork) { 5918 DPRINTF("Before calling %s() for the forkee - expected exited" 5919 "\n", TWAIT_FNAME); 5920 TWAIT_REQUIRE_SUCCESS( 5921 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 5922 5923 validate_status_exited(status, exitval2); 5924 5925 DPRINTF("Before calling %s() for the forkee - expected no " 5926 "process\n", TWAIT_FNAME); 5927 TWAIT_REQUIRE_FAILURE(ECHILD, 5928 wpid = TWAIT_GENERIC(child2, &status, 0)); 5929 } 5930 5931 DPRINTF("Before calling %s() for the child - expected stopped " 5932 "SIGCHLD\n", TWAIT_FNAME); 5933 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5934 5935 validate_status_stopped(status, SIGCHLD); 5936 5937 DPRINTF("Before resuming the child process where it left off and " 5938 "without signal to be sent\n"); 5939 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5940 5941 DPRINTF("Before calling %s() for the child - expected exited\n", 5942 TWAIT_FNAME); 5943 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5944 5945 validate_status_exited(status, exitval); 5946 5947 DPRINTF("Before calling %s() for the child - expected no process\n", 5948 TWAIT_FNAME); 5949 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5950} 5951 5952#define FORK2_TEST(name,trackfork,trackvfork,trackvforkdone, \ 5953 masked,ignored) \ 5954ATF_TC(name); \ 5955ATF_TC_HEAD(name, tc) \ 5956{ \ 5957 atf_tc_set_md_var(tc, "descr", "Verify that %s%s%s is caught " \ 5958 "regardless of signal %s%s", \ 5959 trackfork ? "PTRACE_FORK" : "", \ 5960 trackvfork ? "PTRACE_VFORK" : "", \ 5961 trackvforkdone ? "PTRACE_VFORK_DONE" : "", \ 5962 masked ? "masked" : "", ignored ? "ignored" : ""); \ 5963} \ 5964 \ 5965ATF_TC_BODY(name, tc) \ 5966{ \ 5967 \ 5968 fork2_body(trackfork, trackvfork, trackvforkdone, masked, \ 5969 ignored); \ 5970} 5971 5972FORK2_TEST(fork_singalmasked, true, false, false, true, false) 5973FORK2_TEST(fork_singalignored, true, false, false, false, true) 5974#if TEST_VFORK_ENABLED 5975FORK2_TEST(vfork_singalmasked, false, true, false, true, false) 5976FORK2_TEST(vfork_singalignored, false, true, false, false, true) 5977FORK2_TEST(vforkdone_singalmasked, false, false, true, true, false) 5978FORK2_TEST(vforkdone_singalignored, false, false, true, false, true) 5979#endif 5980#endif 5981 5982/// ---------------------------------------------------------------------------- 5983 5984volatile lwpid_t the_lwp_id = 0; 5985 5986static void 5987lwp_main_func(void *arg) 5988{ 5989 the_lwp_id = _lwp_self(); 5990 _lwp_exit(); 5991} 5992 5993ATF_TC(signal9); 5994ATF_TC_HEAD(signal9, tc) 5995{ 5996 atf_tc_set_md_var(tc, "descr", 5997 "Verify that masking SIGTRAP in tracee does not stop tracer from " 5998 "catching PTRACE_LWP_CREATE breakpoint"); 5999} 6000 6001ATF_TC_BODY(signal9, tc) 6002{ 6003 const int exitval = 5; 6004 const int sigval = SIGSTOP; 6005 const int sigmasked = SIGTRAP; 6006 pid_t child, wpid; 6007#if defined(TWAIT_HAVE_STATUS) 6008 int status; 6009#endif 6010 sigset_t intmask; 6011 ptrace_state_t state; 6012 const int slen = sizeof(state); 6013 ptrace_event_t event; 6014 const int elen = sizeof(event); 6015 ucontext_t uc; 6016 lwpid_t lid; 6017 static const size_t ssize = 16*1024; 6018 void *stack; 6019 6020 atf_tc_expect_fail("PR kern/51918"); 6021 6022 DPRINTF("Before forking process PID=%d\n", getpid()); 6023 SYSCALL_REQUIRE((child = fork()) != -1); 6024 if (child == 0) { 6025 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6026 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6027 6028 sigemptyset(&intmask); 6029 sigaddset(&intmask, sigmasked); 6030 sigprocmask(SIG_BLOCK, &intmask, NULL); 6031 6032 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6033 FORKEE_ASSERT(raise(sigval) == 0); 6034 6035 DPRINTF("Before allocating memory for stack in child\n"); 6036 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6037 6038 DPRINTF("Before making context for new lwp in child\n"); 6039 _lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize); 6040 6041 DPRINTF("Before creating new in child\n"); 6042 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6043 6044 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6045 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6046 6047 DPRINTF("Before verifying that reported %d and running lid %d " 6048 "are the same\n", lid, the_lwp_id); 6049 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6050 6051 DPRINTF("Before exiting of the child process\n"); 6052 _exit(exitval); 6053 } 6054 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6055 6056 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6057 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6058 6059 validate_status_stopped(status, sigval); 6060 6061 DPRINTF("Set empty EVENT_MASK for the child %d\n", child); 6062 event.pe_set_event = PTRACE_LWP_CREATE; 6063 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6064 6065 DPRINTF("Before resuming the child process where it left off and " 6066 "without signal to be sent\n"); 6067 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6068 6069 DPRINTF("Before calling %s() for the child - expected stopped " 6070 "SIGTRAP\n", TWAIT_FNAME); 6071 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6072 6073 validate_status_stopped(status, sigmasked); 6074 6075 SYSCALL_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6076 6077 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_CREATE); 6078 6079 lid = state.pe_lwp; 6080 DPRINTF("Reported PTRACE_LWP_CREATE event with lid %d\n", lid); 6081 6082 DPRINTF("Before resuming the child process where it left off and " 6083 "without signal to be sent\n"); 6084 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6085 6086 DPRINTF("Before calling %s() for the child - expected exited\n", 6087 TWAIT_FNAME); 6088 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6089 6090 validate_status_exited(status, exitval); 6091 6092 DPRINTF("Before calling %s() for the child - expected no process\n", 6093 TWAIT_FNAME); 6094 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6095} 6096 6097ATF_TC(signal10); 6098ATF_TC_HEAD(signal10, tc) 6099{ 6100 atf_tc_set_md_var(tc, "descr", 6101 "Verify that masking SIGTRAP in tracee does not stop tracer from " 6102 "catching PTRACE_LWP_EXIT breakpoint"); 6103} 6104 6105ATF_TC_BODY(signal10, tc) 6106{ 6107 const int exitval = 5; 6108 const int sigval = SIGSTOP; 6109 const int sigmasked = SIGTRAP; 6110 pid_t child, wpid; 6111#if defined(TWAIT_HAVE_STATUS) 6112 int status; 6113#endif 6114 sigset_t intmask; 6115 ptrace_state_t state; 6116 const int slen = sizeof(state); 6117 ptrace_event_t event; 6118 const int elen = sizeof(event); 6119 ucontext_t uc; 6120 lwpid_t lid; 6121 static const size_t ssize = 16*1024; 6122 void *stack; 6123 6124 atf_tc_expect_fail("PR kern/51918"); 6125 6126 DPRINTF("Before forking process PID=%d\n", getpid()); 6127 SYSCALL_REQUIRE((child = fork()) != -1); 6128 if (child == 0) { 6129 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6130 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6131 6132 sigemptyset(&intmask); 6133 sigaddset(&intmask, sigmasked); 6134 sigprocmask(SIG_BLOCK, &intmask, NULL); 6135 6136 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6137 FORKEE_ASSERT(raise(sigval) == 0); 6138 6139 DPRINTF("Before allocating memory for stack in child\n"); 6140 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6141 6142 DPRINTF("Before making context for new lwp in child\n"); 6143 _lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize); 6144 6145 DPRINTF("Before creating new in child\n"); 6146 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6147 6148 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6149 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6150 6151 DPRINTF("Before verifying that reported %d and running lid %d " 6152 "are the same\n", lid, the_lwp_id); 6153 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6154 6155 DPRINTF("Before exiting of the child process\n"); 6156 _exit(exitval); 6157 } 6158 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6159 6160 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6161 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6162 6163 validate_status_stopped(status, sigval); 6164 6165 DPRINTF("Set empty EVENT_MASK for the child %d\n", child); 6166 event.pe_set_event = PTRACE_LWP_EXIT; 6167 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6168 6169 DPRINTF("Before resuming the child process where it left off and " 6170 "without signal to be sent\n"); 6171 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6172 6173 DPRINTF("Before calling %s() for the child - expected stopped " 6174 "SIGTRAP\n", TWAIT_FNAME); 6175 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6176 6177 validate_status_stopped(status, sigmasked); 6178 6179 SYSCALL_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6180 6181 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_EXIT); 6182 6183 lid = state.pe_lwp; 6184 DPRINTF("Reported PTRACE_LWP_EXIT event with lid %d\n", lid); 6185 6186 DPRINTF("Before resuming the child process where it left off and " 6187 "without signal to be sent\n"); 6188 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6189 6190 DPRINTF("Before calling %s() for the child - expected exited\n", 6191 TWAIT_FNAME); 6192 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6193 6194 validate_status_exited(status, exitval); 6195 6196 DPRINTF("Before calling %s() for the child - expected no process\n", 6197 TWAIT_FNAME); 6198 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6199} 6200 6201static void 6202lwp_main_stop(void *arg) 6203{ 6204 the_lwp_id = _lwp_self(); 6205 6206 raise(SIGTRAP); 6207 6208 _lwp_exit(); 6209} 6210 6211ATF_TC(suspend1); 6212ATF_TC_HEAD(suspend1, tc) 6213{ 6214 atf_tc_set_md_var(tc, "descr", 6215 "Verify that a thread can be suspended by a debugger and later " 6216 "resumed by a tracee"); 6217} 6218 6219ATF_TC_BODY(suspend1, tc) 6220{ 6221 const int exitval = 5; 6222 const int sigval = SIGSTOP; 6223 pid_t child, wpid; 6224#if defined(TWAIT_HAVE_STATUS) 6225 int status; 6226#endif 6227 ucontext_t uc; 6228 lwpid_t lid; 6229 static const size_t ssize = 16*1024; 6230 void *stack; 6231 struct ptrace_lwpinfo pl; 6232 struct ptrace_siginfo psi; 6233 volatile int go = 0; 6234 6235 // Feature pending for refactoring 6236 atf_tc_expect_fail("PR kern/51995"); 6237 6238 // Hangs with qemu 6239 ATF_REQUIRE(0 && "In order to get reliable failure, abort"); 6240 6241 DPRINTF("Before forking process PID=%d\n", getpid()); 6242 SYSCALL_REQUIRE((child = fork()) != -1); 6243 if (child == 0) { 6244 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6245 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6246 6247 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6248 FORKEE_ASSERT(raise(sigval) == 0); 6249 6250 DPRINTF("Before allocating memory for stack in child\n"); 6251 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6252 6253 DPRINTF("Before making context for new lwp in child\n"); 6254 _lwp_makecontext(&uc, lwp_main_stop, NULL, NULL, stack, ssize); 6255 6256 DPRINTF("Before creating new in child\n"); 6257 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6258 6259 while (go == 0) 6260 continue; 6261 6262 raise(SIGINT); 6263 6264 FORKEE_ASSERT(_lwp_continue(lid) == 0); 6265 6266 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6267 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6268 6269 DPRINTF("Before verifying that reported %d and running lid %d " 6270 "are the same\n", lid, the_lwp_id); 6271 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6272 6273 DPRINTF("Before exiting of the child process\n"); 6274 _exit(exitval); 6275 } 6276 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6277 6278 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6279 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6280 6281 validate_status_stopped(status, sigval); 6282 6283 DPRINTF("Before resuming the child process where it left off and " 6284 "without signal to be sent\n"); 6285 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6286 6287 DPRINTF("Before calling %s() for the child - expected stopped " 6288 "SIGTRAP\n", TWAIT_FNAME); 6289 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6290 6291 validate_status_stopped(status, SIGTRAP); 6292 6293 DPRINTF("Before reading siginfo and lwpid_t\n"); 6294 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6295 6296 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6297 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6298 6299 DPRINTF("Write new go to tracee (PID=%d) from tracer (PID=%d)\n", 6300 child, getpid()); 6301 SYSCALL_REQUIRE(ptrace(PT_WRITE_D, child, __UNVOLATILE(&go), 1) != -1); 6302 6303 DPRINTF("Before resuming the child process where it left off and " 6304 "without signal to be sent\n"); 6305 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6306 6307 DPRINTF("Before calling %s() for the child - expected stopped " 6308 "SIGINT\n", TWAIT_FNAME); 6309 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6310 6311 validate_status_stopped(status, SIGINT); 6312 6313 pl.pl_lwpid = 0; 6314 6315 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6316 while (pl.pl_lwpid != 0) { 6317 6318 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6319 switch (pl.pl_lwpid) { 6320 case 1: 6321 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SIGNAL); 6322 break; 6323 case 2: 6324 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SUSPENDED); 6325 break; 6326 } 6327 } 6328 6329 DPRINTF("Before resuming the child process where it left off and " 6330 "without signal to be sent\n"); 6331 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6332 6333 DPRINTF("Before calling %s() for the child - expected exited\n", 6334 TWAIT_FNAME); 6335 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6336 6337 validate_status_exited(status, exitval); 6338 6339 DPRINTF("Before calling %s() for the child - expected no process\n", 6340 TWAIT_FNAME); 6341 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6342} 6343 6344ATF_TC(suspend2); 6345ATF_TC_HEAD(suspend2, tc) 6346{ 6347 atf_tc_set_md_var(tc, "descr", 6348 "Verify that the while the only thread within a process is " 6349 "suspended, the whole process cannot be unstopped"); 6350} 6351 6352ATF_TC_BODY(suspend2, tc) 6353{ 6354 const int exitval = 5; 6355 const int sigval = SIGSTOP; 6356 pid_t child, wpid; 6357#if defined(TWAIT_HAVE_STATUS) 6358 int status; 6359#endif 6360 struct ptrace_siginfo psi; 6361 6362 // Feature pending for refactoring 6363 atf_tc_expect_fail("PR kern/51995"); 6364 6365 // Hangs with qemu 6366 ATF_REQUIRE(0 && "In order to get reliable failure, abort"); 6367 6368 DPRINTF("Before forking process PID=%d\n", getpid()); 6369 SYSCALL_REQUIRE((child = fork()) != -1); 6370 if (child == 0) { 6371 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6372 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6373 6374 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6375 FORKEE_ASSERT(raise(sigval) == 0); 6376 6377 DPRINTF("Before exiting of the child process\n"); 6378 _exit(exitval); 6379 } 6380 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6381 6382 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6383 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6384 6385 validate_status_stopped(status, sigval); 6386 6387 DPRINTF("Before reading siginfo and lwpid_t\n"); 6388 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6389 6390 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6391 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6392 6393 DPRINTF("Before resuming the child process where it left off and " 6394 "without signal to be sent\n"); 6395 ATF_REQUIRE_ERRNO(EDEADLK, 6396 ptrace(PT_CONTINUE, child, (void *)1, 0) == -1); 6397 6398 DPRINTF("Before resuming LWP %d\n", psi.psi_lwpid); 6399 SYSCALL_REQUIRE(ptrace(PT_RESUME, child, NULL, psi.psi_lwpid) != -1); 6400 6401 DPRINTF("Before resuming the child process where it left off and " 6402 "without signal to be sent\n"); 6403 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6404 6405 DPRINTF("Before calling %s() for the child - expected exited\n", 6406 TWAIT_FNAME); 6407 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6408 6409 validate_status_exited(status, exitval); 6410 6411 DPRINTF("Before calling %s() for the child - expected no process\n", 6412 TWAIT_FNAME); 6413 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6414} 6415 6416ATF_TC(resume1); 6417ATF_TC_HEAD(resume1, tc) 6418{ 6419 atf_tc_set_md_var(tc, "timeout", "5"); 6420 atf_tc_set_md_var(tc, "descr", 6421 "Verify that a thread can be suspended by a debugger and later " 6422 "resumed by the debugger"); 6423} 6424 6425ATF_TC_BODY(resume1, tc) 6426{ 6427 struct msg_fds fds; 6428 const int exitval = 5; 6429 const int sigval = SIGSTOP; 6430 pid_t child, wpid; 6431 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 6432#if defined(TWAIT_HAVE_STATUS) 6433 int status; 6434#endif 6435 ucontext_t uc; 6436 lwpid_t lid; 6437 static const size_t ssize = 16*1024; 6438 void *stack; 6439 struct ptrace_lwpinfo pl; 6440 struct ptrace_siginfo psi; 6441 6442 // Feature pending for refactoring 6443 atf_tc_expect_fail("PR kern/51995"); 6444 6445 // Hangs with qemu 6446 ATF_REQUIRE(0 && "In order to get reliable failure, abort"); 6447 6448 SYSCALL_REQUIRE(msg_open(&fds) == 0); 6449 6450 DPRINTF("Before forking process PID=%d\n", getpid()); 6451 SYSCALL_REQUIRE((child = fork()) != -1); 6452 if (child == 0) { 6453 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6454 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6455 6456 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6457 FORKEE_ASSERT(raise(sigval) == 0); 6458 6459 DPRINTF("Before allocating memory for stack in child\n"); 6460 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6461 6462 DPRINTF("Before making context for new lwp in child\n"); 6463 _lwp_makecontext(&uc, lwp_main_stop, NULL, NULL, stack, ssize); 6464 6465 DPRINTF("Before creating new in child\n"); 6466 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6467 6468 CHILD_TO_PARENT("Message", fds, msg); 6469 6470 raise(SIGINT); 6471 6472 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6473 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6474 6475 DPRINTF("Before verifying that reported %d and running lid %d " 6476 "are the same\n", lid, the_lwp_id); 6477 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6478 6479 DPRINTF("Before exiting of the child process\n"); 6480 _exit(exitval); 6481 } 6482 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6483 6484 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6485 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6486 6487 validate_status_stopped(status, sigval); 6488 6489 DPRINTF("Before resuming the child process where it left off and " 6490 "without signal to be sent\n"); 6491 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6492 6493 DPRINTF("Before calling %s() for the child - expected stopped " 6494 "SIGTRAP\n", TWAIT_FNAME); 6495 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6496 6497 validate_status_stopped(status, SIGTRAP); 6498 6499 DPRINTF("Before reading siginfo and lwpid_t\n"); 6500 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6501 6502 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6503 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6504 6505 PARENT_FROM_CHILD("Message", fds, msg); 6506 6507 DPRINTF("Before resuming the child process where it left off and " 6508 "without signal to be sent\n"); 6509 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6510 6511 DPRINTF("Before calling %s() for the child - expected stopped " 6512 "SIGINT\n", TWAIT_FNAME); 6513 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6514 6515 validate_status_stopped(status, SIGINT); 6516 6517 pl.pl_lwpid = 0; 6518 6519 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6520 while (pl.pl_lwpid != 0) { 6521 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6522 switch (pl.pl_lwpid) { 6523 case 1: 6524 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SIGNAL); 6525 break; 6526 case 2: 6527 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SUSPENDED); 6528 break; 6529 } 6530 } 6531 6532 DPRINTF("Before resuming LWP %d\n", psi.psi_lwpid); 6533 SYSCALL_REQUIRE(ptrace(PT_RESUME, child, NULL, psi.psi_lwpid) != -1); 6534 6535 DPRINTF("Before resuming the child process where it left off and " 6536 "without signal to be sent\n"); 6537 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6538 6539 DPRINTF("Before calling %s() for the child - expected exited\n", 6540 TWAIT_FNAME); 6541 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6542 6543 validate_status_exited(status, exitval); 6544 6545 DPRINTF("Before calling %s() for the child - expected no process\n", 6546 TWAIT_FNAME); 6547 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6548 6549 msg_close(&fds); 6550 6551 DPRINTF("XXX: Test worked this time but for consistency timeout it\n"); 6552 sleep(10); 6553} 6554 6555ATF_TC(syscall1); 6556ATF_TC_HEAD(syscall1, tc) 6557{ 6558 atf_tc_set_md_var(tc, "descr", 6559 "Verify that getpid(2) can be traced with PT_SYSCALL"); 6560} 6561 6562ATF_TC_BODY(syscall1, tc) 6563{ 6564 const int exitval = 5; 6565 const int sigval = SIGSTOP; 6566 pid_t child, wpid; 6567#if defined(TWAIT_HAVE_STATUS) 6568 int status; 6569#endif 6570 struct ptrace_siginfo info; 6571 memset(&info, 0, sizeof(info)); 6572 6573 DPRINTF("Before forking process PID=%d\n", getpid()); 6574 SYSCALL_REQUIRE((child = fork()) != -1); 6575 if (child == 0) { 6576 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6577 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6578 6579 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6580 FORKEE_ASSERT(raise(sigval) == 0); 6581 6582 syscall(SYS_getpid); 6583 6584 DPRINTF("Before exiting of the child process\n"); 6585 _exit(exitval); 6586 } 6587 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6588 6589 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6590 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6591 6592 validate_status_stopped(status, sigval); 6593 6594 DPRINTF("Before resuming the child process where it left off and " 6595 "without signal to be sent\n"); 6596 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6597 6598 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6599 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6600 6601 validate_status_stopped(status, SIGTRAP); 6602 6603 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 6604 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 6605 6606 DPRINTF("Before checking siginfo_t and lwpid\n"); 6607 ATF_REQUIRE_EQ(info.psi_lwpid, 1); 6608 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 6609 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_SCE); 6610 6611 DPRINTF("Before resuming the child process where it left off and " 6612 "without signal to be sent\n"); 6613 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6614 6615 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6616 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6617 6618 validate_status_stopped(status, SIGTRAP); 6619 6620 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 6621 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 6622 6623 DPRINTF("Before checking siginfo_t and lwpid\n"); 6624 ATF_REQUIRE_EQ(info.psi_lwpid, 1); 6625 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 6626 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_SCX); 6627 6628 DPRINTF("Before resuming the child process where it left off and " 6629 "without signal to be sent\n"); 6630 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6631 6632 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6633 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6634 6635 validate_status_exited(status, exitval); 6636 6637 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6638 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6639} 6640 6641ATF_TC(syscallemu1); 6642ATF_TC_HEAD(syscallemu1, tc) 6643{ 6644 atf_tc_set_md_var(tc, "descr", 6645 "Verify that exit(2) can be intercepted with PT_SYSCALLEMU"); 6646} 6647 6648ATF_TC_BODY(syscallemu1, tc) 6649{ 6650 const int exitval = 5; 6651 const int sigval = SIGSTOP; 6652 pid_t child, wpid; 6653#if defined(TWAIT_HAVE_STATUS) 6654 int status; 6655#endif 6656 6657#if defined(__sparc__) && !defined(__sparc64__) 6658 /* syscallemu does not work on sparc (32-bit) */ 6659 atf_tc_expect_fail("PR kern/52166"); 6660#endif 6661 6662 DPRINTF("Before forking process PID=%d\n", getpid()); 6663 SYSCALL_REQUIRE((child = fork()) != -1); 6664 if (child == 0) { 6665 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6666 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6667 6668 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6669 FORKEE_ASSERT(raise(sigval) == 0); 6670 6671 syscall(SYS_exit, 100); 6672 6673 DPRINTF("Before exiting of the child process\n"); 6674 _exit(exitval); 6675 } 6676 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6677 6678 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6679 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6680 6681 validate_status_stopped(status, sigval); 6682 6683 DPRINTF("Before resuming the child process where it left off and " 6684 "without signal to be sent\n"); 6685 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6686 6687 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6688 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6689 6690 validate_status_stopped(status, SIGTRAP); 6691 6692 DPRINTF("Set SYSCALLEMU for intercepted syscall\n"); 6693 SYSCALL_REQUIRE(ptrace(PT_SYSCALLEMU, child, (void *)1, 0) != -1); 6694 6695 DPRINTF("Before resuming the child process where it left off and " 6696 "without signal to be sent\n"); 6697 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6698 6699 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6700 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6701 6702 validate_status_stopped(status, SIGTRAP); 6703 6704 DPRINTF("Before resuming the child process where it left off and " 6705 "without signal to be sent\n"); 6706 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6707 6708 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6709 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6710 6711 validate_status_exited(status, exitval); 6712 6713 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6714 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6715} 6716 6717/// ---------------------------------------------------------------------------- 6718 6719static void 6720clone_body(int flags, bool trackfork, bool trackvfork, 6721 bool trackvforkdone) 6722{ 6723 const int exitval = 5; 6724 const int exitval2 = 15; 6725 const int sigval = SIGSTOP; 6726 pid_t child, child2 = 0, wpid; 6727#if defined(TWAIT_HAVE_STATUS) 6728 int status; 6729#endif 6730 ptrace_state_t state; 6731 const int slen = sizeof(state); 6732 ptrace_event_t event; 6733 const int elen = sizeof(event); 6734 6735 const size_t stack_size = 1024 * 1024; 6736 void *stack, *stack_base; 6737 6738 stack = malloc(stack_size); 6739 ATF_REQUIRE(stack != NULL); 6740 6741#ifdef __MACHINE_STACK_GROWS_UP 6742 stack_base = stack; 6743#else 6744 stack_base = (char *)stack + stack_size; 6745#endif 6746 6747 DPRINTF("Before forking process PID=%d\n", getpid()); 6748 SYSCALL_REQUIRE((child = fork()) != -1); 6749 if (child == 0) { 6750 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6751 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6752 6753 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6754 FORKEE_ASSERT(raise(sigval) == 0); 6755 6756 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 6757 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 6758 6759 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 6760 child2); 6761 6762 // XXX WALLSIG? 6763 FORKEE_REQUIRE_SUCCESS 6764 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 6765 6766 forkee_status_exited(status, exitval2); 6767 6768 DPRINTF("Before exiting of the child process\n"); 6769 _exit(exitval); 6770 } 6771 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6772 6773 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6774 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6775 6776 validate_status_stopped(status, sigval); 6777 6778 DPRINTF("Set 0%s%s%s in EVENT_MASK for the child %d\n", 6779 trackfork ? "|PTRACE_FORK" : "", 6780 trackvfork ? "|PTRACE_VFORK" : "", 6781 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 6782 event.pe_set_event = 0; 6783 if (trackfork) 6784 event.pe_set_event |= PTRACE_FORK; 6785 if (trackvfork) 6786 event.pe_set_event |= PTRACE_VFORK; 6787 if (trackvforkdone) 6788 event.pe_set_event |= PTRACE_VFORK_DONE; 6789 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6790 6791 DPRINTF("Before resuming the child process where it left off and " 6792 "without signal to be sent\n"); 6793 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6794 6795#if defined(TWAIT_HAVE_PID) 6796 if ((trackfork && !(flags & CLONE_VFORK)) || 6797 (trackvfork && (flags & CLONE_VFORK))) { 6798 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 6799 child); 6800 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 6801 child); 6802 6803 validate_status_stopped(status, SIGTRAP); 6804 6805 SYSCALL_REQUIRE( 6806 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6807 if (trackfork && !(flags & CLONE_VFORK)) { 6808 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 6809 PTRACE_FORK); 6810 } 6811 if (trackvfork && (flags & CLONE_VFORK)) { 6812 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 6813 PTRACE_VFORK); 6814 } 6815 6816 child2 = state.pe_other_pid; 6817 DPRINTF("Reported ptrace event with forkee %d\n", child2); 6818 6819 DPRINTF("Before calling %s() for the forkee %d of the child " 6820 "%d\n", TWAIT_FNAME, child2, child); 6821 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 6822 child2); 6823 6824 validate_status_stopped(status, SIGTRAP); 6825 6826 SYSCALL_REQUIRE( 6827 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 6828 if (trackfork && !(flags & CLONE_VFORK)) { 6829 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 6830 PTRACE_FORK); 6831 } 6832 if (trackvfork && (flags & CLONE_VFORK)) { 6833 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 6834 PTRACE_VFORK); 6835 } 6836 6837 ATF_REQUIRE_EQ(state.pe_other_pid, child); 6838 6839 DPRINTF("Before resuming the forkee process where it left off " 6840 "and without signal to be sent\n"); 6841 SYSCALL_REQUIRE( 6842 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 6843 6844 DPRINTF("Before resuming the child process where it left off " 6845 "and without signal to be sent\n"); 6846 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6847 } 6848#endif 6849 6850 if (trackvforkdone && (flags & CLONE_VFORK)) { 6851 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 6852 child); 6853 TWAIT_REQUIRE_SUCCESS( 6854 wpid = TWAIT_GENERIC(child, &status, 0), child); 6855 6856 validate_status_stopped(status, SIGTRAP); 6857 6858 SYSCALL_REQUIRE( 6859 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6860 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 6861 6862 child2 = state.pe_other_pid; 6863 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 6864 child2); 6865 6866 DPRINTF("Before resuming the child process where it left off " 6867 "and without signal to be sent\n"); 6868 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6869 } 6870 6871#if defined(TWAIT_HAVE_PID) 6872 if ((trackfork && !(flags & CLONE_VFORK)) || 6873 (trackvfork && (flags & CLONE_VFORK))) { 6874 DPRINTF("Before calling %s() for the forkee - expected exited" 6875 "\n", TWAIT_FNAME); 6876 TWAIT_REQUIRE_SUCCESS( 6877 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 6878 6879 validate_status_exited(status, exitval2); 6880 6881 DPRINTF("Before calling %s() for the forkee - expected no " 6882 "process\n", TWAIT_FNAME); 6883 TWAIT_REQUIRE_FAILURE(ECHILD, 6884 wpid = TWAIT_GENERIC(child2, &status, 0)); 6885 } 6886#endif 6887 6888 DPRINTF("Before calling %s() for the child - expected stopped " 6889 "SIGCHLD\n", TWAIT_FNAME); 6890 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6891 6892 validate_status_stopped(status, SIGCHLD); 6893 6894 DPRINTF("Before resuming the child process where it left off and " 6895 "without signal to be sent\n"); 6896 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6897 6898 DPRINTF("Before calling %s() for the child - expected exited\n", 6899 TWAIT_FNAME); 6900 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6901 6902 validate_status_exited(status, exitval); 6903 6904 DPRINTF("Before calling %s() for the child - expected no process\n", 6905 TWAIT_FNAME); 6906 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6907} 6908 6909#define CLONE_TEST(name,flags,tfork,tvfork,tvforkdone) \ 6910ATF_TC(name); \ 6911ATF_TC_HEAD(name, tc) \ 6912{ \ 6913 atf_tc_set_md_var(tc, "descr", "Verify clone(%s) " \ 6914 "called with 0%s%s%s in EVENT_MASK", \ 6915 #flags, \ 6916 tfork ? "|PTRACE_FORK" : "", \ 6917 tvfork ? "|PTRACE_VFORK" : "", \ 6918 tvforkdone ? "|PTRACE_VFORK_DONE" : ""); \ 6919} \ 6920 \ 6921ATF_TC_BODY(name, tc) \ 6922{ \ 6923 \ 6924 clone_body(flags, tfork, tvfork, tvforkdone); \ 6925} 6926 6927CLONE_TEST(clone1, 0, false, false, false) 6928#if defined(TWAIT_HAVE_PID) 6929CLONE_TEST(clone2, 0, true, false, false) 6930CLONE_TEST(clone3, 0, false, true, false) 6931CLONE_TEST(clone4, 0, true, true, false) 6932#endif 6933CLONE_TEST(clone5, 0, false, false, true) 6934#if defined(TWAIT_HAVE_PID) 6935CLONE_TEST(clone6, 0, true, false, true) 6936CLONE_TEST(clone7, 0, false, true, true) 6937CLONE_TEST(clone8, 0, true, true, true) 6938#endif 6939 6940CLONE_TEST(clone_vm1, CLONE_VM, false, false, false) 6941#if defined(TWAIT_HAVE_PID) 6942CLONE_TEST(clone_vm2, CLONE_VM, true, false, false) 6943CLONE_TEST(clone_vm3, CLONE_VM, false, true, false) 6944CLONE_TEST(clone_vm4, CLONE_VM, true, true, false) 6945#endif 6946CLONE_TEST(clone_vm5, CLONE_VM, false, false, true) 6947#if defined(TWAIT_HAVE_PID) 6948CLONE_TEST(clone_vm6, CLONE_VM, true, false, true) 6949CLONE_TEST(clone_vm7, CLONE_VM, false, true, true) 6950CLONE_TEST(clone_vm8, CLONE_VM, true, true, true) 6951#endif 6952 6953CLONE_TEST(clone_fs1, CLONE_FS, false, false, false) 6954#if defined(TWAIT_HAVE_PID) 6955CLONE_TEST(clone_fs2, CLONE_FS, true, false, false) 6956CLONE_TEST(clone_fs3, CLONE_FS, false, true, false) 6957CLONE_TEST(clone_fs4, CLONE_FS, true, true, false) 6958#endif 6959CLONE_TEST(clone_fs5, CLONE_FS, false, false, true) 6960#if defined(TWAIT_HAVE_PID) 6961CLONE_TEST(clone_fs6, CLONE_FS, true, false, true) 6962CLONE_TEST(clone_fs7, CLONE_FS, false, true, true) 6963CLONE_TEST(clone_fs8, CLONE_FS, true, true, true) 6964#endif 6965 6966CLONE_TEST(clone_files1, CLONE_FILES, false, false, false) 6967#if defined(TWAIT_HAVE_PID) 6968CLONE_TEST(clone_files2, CLONE_FILES, true, false, false) 6969CLONE_TEST(clone_files3, CLONE_FILES, false, true, false) 6970CLONE_TEST(clone_files4, CLONE_FILES, true, true, false) 6971#endif 6972CLONE_TEST(clone_files5, CLONE_FILES, false, false, true) 6973#if defined(TWAIT_HAVE_PID) 6974CLONE_TEST(clone_files6, CLONE_FILES, true, false, true) 6975CLONE_TEST(clone_files7, CLONE_FILES, false, true, true) 6976CLONE_TEST(clone_files8, CLONE_FILES, true, true, true) 6977#endif 6978 6979//CLONE_TEST(clone_sighand1, CLONE_SIGHAND, false, false, false) 6980#if defined(TWAIT_HAVE_PID) 6981//CLONE_TEST(clone_sighand2, CLONE_SIGHAND, true, false, false) 6982//CLONE_TEST(clone_sighand3, CLONE_SIGHAND, false, true, false) 6983//CLONE_TEST(clone_sighand4, CLONE_SIGHAND, true, true, false) 6984#endif 6985//CLONE_TEST(clone_sighand5, CLONE_SIGHAND, false, false, true) 6986#if defined(TWAIT_HAVE_PID) 6987//CLONE_TEST(clone_sighand6, CLONE_SIGHAND, true, false, true) 6988//CLONE_TEST(clone_sighand7, CLONE_SIGHAND, false, true, true) 6989//CLONE_TEST(clone_sighand8, CLONE_SIGHAND, true, true, true) 6990#endif 6991 6992#if TEST_VFORK_ENABLED 6993CLONE_TEST(clone_vfork1, CLONE_VFORK, false, false, false) 6994#if defined(TWAIT_HAVE_PID) 6995CLONE_TEST(clone_vfork2, CLONE_VFORK, true, false, false) 6996CLONE_TEST(clone_vfork3, CLONE_VFORK, false, true, false) 6997CLONE_TEST(clone_vfork4, CLONE_VFORK, true, true, false) 6998#endif 6999CLONE_TEST(clone_vfork5, CLONE_VFORK, false, false, true) 7000#if defined(TWAIT_HAVE_PID) 7001CLONE_TEST(clone_vfork6, CLONE_VFORK, true, false, true) 7002CLONE_TEST(clone_vfork7, CLONE_VFORK, false, true, true) 7003CLONE_TEST(clone_vfork8, CLONE_VFORK, true, true, true) 7004#endif 7005#endif 7006 7007/// ---------------------------------------------------------------------------- 7008 7009#if defined(TWAIT_HAVE_PID) 7010static void 7011clone_body2(int flags, bool masked, bool ignored) 7012{ 7013 const int exitval = 5; 7014 const int exitval2 = 15; 7015 const int sigval = SIGSTOP; 7016 pid_t child, child2 = 0, wpid; 7017#if defined(TWAIT_HAVE_STATUS) 7018 int status; 7019#endif 7020 ptrace_state_t state; 7021 const int slen = sizeof(state); 7022 ptrace_event_t event; 7023 const int elen = sizeof(event); 7024 struct sigaction sa; 7025 struct ptrace_siginfo info; 7026 sigset_t intmask; 7027 struct kinfo_proc2 kp; 7028 size_t len = sizeof(kp); 7029 7030 int name[6]; 7031 const size_t namelen = __arraycount(name); 7032 ki_sigset_t kp_sigmask; 7033 ki_sigset_t kp_sigignore; 7034 7035 const size_t stack_size = 1024 * 1024; 7036 void *stack, *stack_base; 7037 7038 stack = malloc(stack_size); 7039 ATF_REQUIRE(stack != NULL); 7040 7041#ifdef __MACHINE_STACK_GROWS_UP 7042 stack_base = stack; 7043#else 7044 stack_base = (char *)stack + stack_size; 7045#endif 7046 7047 SYSCALL_REQUIRE((child = fork()) != -1); 7048 if (child == 0) { 7049 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 7050 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 7051 7052 if (masked) { 7053 sigemptyset(&intmask); 7054 sigaddset(&intmask, SIGTRAP); 7055 sigprocmask(SIG_BLOCK, &intmask, NULL); 7056 } 7057 7058 if (ignored) { 7059 memset(&sa, 0, sizeof(sa)); 7060 sa.sa_handler = SIG_IGN; 7061 sigemptyset(&sa.sa_mask); 7062 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 7063 } 7064 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 7065 FORKEE_ASSERT(raise(sigval) == 0); 7066 7067 DPRINTF("Before forking process PID=%d flags=%#x\n", getpid(), 7068 flags); 7069 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 7070 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 7071 7072 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 7073 child2); 7074 7075 // XXX WALLSIG? 7076 FORKEE_REQUIRE_SUCCESS 7077 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 7078 7079 forkee_status_exited(status, exitval2); 7080 7081 DPRINTF("Before exiting of the child process\n"); 7082 _exit(exitval); 7083 } 7084 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 7085 7086 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 7087 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7088 7089 validate_status_stopped(status, sigval); 7090 7091 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 7092 SYSCALL_REQUIRE( 7093 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 7094 7095 DPRINTF("Before checking siginfo_t\n"); 7096 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 7097 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 7098 7099 name[0] = CTL_KERN, 7100 name[1] = KERN_PROC2, 7101 name[2] = KERN_PROC_PID; 7102 name[3] = child; 7103 name[4] = sizeof(kp); 7104 name[5] = 1; 7105 7106 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7107 7108 if (masked) 7109 kp_sigmask = kp.p_sigmask; 7110 7111 if (ignored) 7112 kp_sigignore = kp.p_sigignore; 7113 7114 DPRINTF("Set PTRACE_FORK | PTRACE_VFORK | PTRACE_VFORK_DONE in " 7115 "EVENT_MASK for the child %d\n", child); 7116 event.pe_set_event = PTRACE_FORK | PTRACE_VFORK | PTRACE_VFORK_DONE; 7117 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 7118 7119 DPRINTF("Before resuming the child process where it left off and " 7120 "without signal to be sent\n"); 7121 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7122 7123 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 7124 child); 7125 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 7126 child); 7127 7128 validate_status_stopped(status, SIGTRAP); 7129 7130 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7131 7132 if (masked) { 7133 DPRINTF("kp_sigmask=" 7134 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7135 PRIx32 "\n", 7136 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7137 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7138 7139 DPRINTF("kp.p_sigmask=" 7140 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7141 PRIx32 "\n", 7142 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7143 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7144 7145 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7146 sizeof(kp_sigmask))); 7147 } 7148 7149 if (ignored) { 7150 DPRINTF("kp_sigignore=" 7151 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7152 PRIx32 "\n", 7153 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7154 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7155 7156 DPRINTF("kp.p_sigignore=" 7157 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7158 PRIx32 "\n", 7159 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7160 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7161 7162 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7163 sizeof(kp_sigignore))); 7164 } 7165 7166 SYSCALL_REQUIRE( 7167 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 7168 DPRINTF("state.pe_report_event=%#x pid=%d\n", state.pe_report_event, 7169 child2); 7170 if (!(flags & CLONE_VFORK)) { 7171 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 7172 PTRACE_FORK); 7173 } else { 7174 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 7175 PTRACE_VFORK); 7176 } 7177 7178 child2 = state.pe_other_pid; 7179 DPRINTF("Reported ptrace event with forkee %d\n", child2); 7180 7181 DPRINTF("Before calling %s() for the forkee %d of the child " 7182 "%d\n", TWAIT_FNAME, child2, child); 7183 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 7184 child2); 7185 7186 validate_status_stopped(status, SIGTRAP); 7187 7188 name[3] = child2; 7189 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7190 7191 if (masked) { 7192 DPRINTF("kp_sigmask=" 7193 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7194 PRIx32 "\n", 7195 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7196 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7197 7198 DPRINTF("kp.p_sigmask=" 7199 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7200 PRIx32 "\n", 7201 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7202 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7203 7204 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7205 sizeof(kp_sigmask))); 7206 } 7207 7208 if (ignored) { 7209 DPRINTF("kp_sigignore=" 7210 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7211 PRIx32 "\n", 7212 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7213 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7214 7215 DPRINTF("kp.p_sigignore=" 7216 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7217 PRIx32 "\n", 7218 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7219 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7220 7221 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7222 sizeof(kp_sigignore))); 7223 } 7224 7225 SYSCALL_REQUIRE( 7226 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 7227 if (!(flags & CLONE_VFORK)) { 7228 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 7229 PTRACE_FORK); 7230 } else { 7231 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 7232 PTRACE_VFORK); 7233 } 7234 7235 ATF_REQUIRE_EQ(state.pe_other_pid, child); 7236 7237 DPRINTF("Before resuming the forkee process where it left off " 7238 "and without signal to be sent\n"); 7239 SYSCALL_REQUIRE( 7240 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 7241 7242 DPRINTF("Before resuming the child process where it left off " 7243 "and without signal to be sent\n"); 7244 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7245 7246 if (flags & CLONE_VFORK) { 7247 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 7248 child); 7249 TWAIT_REQUIRE_SUCCESS( 7250 wpid = TWAIT_GENERIC(child, &status, 0), child); 7251 7252 validate_status_stopped(status, SIGTRAP); 7253 7254 name[3] = child; 7255 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7256 7257 /* 7258 * SIGCHLD is now pending in the signal queue and 7259 * the kernel presents it to userland as a masked signal. 7260 */ 7261 sigdelset((sigset_t *)&kp.p_sigmask, SIGCHLD); 7262 7263 if (masked) { 7264 DPRINTF("kp_sigmask=" 7265 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7266 PRIx32 "\n", 7267 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7268 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7269 7270 DPRINTF("kp.p_sigmask=" 7271 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7272 PRIx32 "\n", 7273 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7274 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7275 7276 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7277 sizeof(kp_sigmask))); 7278 } 7279 7280 if (ignored) { 7281 DPRINTF("kp_sigignore=" 7282 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7283 PRIx32 "\n", 7284 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7285 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7286 7287 DPRINTF("kp.p_sigignore=" 7288 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7289 PRIx32 "\n", 7290 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7291 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7292 7293 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7294 sizeof(kp_sigignore))); 7295 } 7296 7297 SYSCALL_REQUIRE( 7298 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 7299 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 7300 7301 child2 = state.pe_other_pid; 7302 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 7303 child2); 7304 7305 DPRINTF("Before resuming the child process where it left off " 7306 "and without signal to be sent\n"); 7307 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7308 } 7309 7310 DPRINTF("Before calling %s() for the forkee - expected exited" 7311 "\n", TWAIT_FNAME); 7312 TWAIT_REQUIRE_SUCCESS( 7313 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 7314 7315 validate_status_exited(status, exitval2); 7316 7317 DPRINTF("Before calling %s() for the forkee - expected no " 7318 "process\n", TWAIT_FNAME); 7319 TWAIT_REQUIRE_FAILURE(ECHILD, 7320 wpid = TWAIT_GENERIC(child2, &status, 0)); 7321 7322 DPRINTF("Before calling %s() for the child - expected stopped " 7323 "SIGCHLD\n", TWAIT_FNAME); 7324 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7325 7326 validate_status_stopped(status, SIGCHLD); 7327 7328 DPRINTF("Before resuming the child process where it left off and " 7329 "without signal to be sent\n"); 7330 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7331 7332 DPRINTF("Before calling %s() for the child - expected exited\n", 7333 TWAIT_FNAME); 7334 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7335 7336 validate_status_exited(status, exitval); 7337 7338 DPRINTF("Before calling %s() for the child - expected no process\n", 7339 TWAIT_FNAME); 7340 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 7341} 7342 7343#define CLONE_TEST2(name,flags,masked,ignored) \ 7344ATF_TC(name); \ 7345ATF_TC_HEAD(name, tc) \ 7346{ \ 7347 atf_tc_set_md_var(tc, "descr", "Verify that clone(%s) is caught"\ 7348 " regardless of signal %s%s", \ 7349 #flags, masked ? "masked" : "", ignored ? "ignored" : ""); \ 7350} \ 7351 \ 7352ATF_TC_BODY(name, tc) \ 7353{ \ 7354 \ 7355 clone_body2(flags, masked, ignored); \ 7356} 7357 7358CLONE_TEST2(clone_signalignored, 0, true, false) 7359CLONE_TEST2(clone_signalmasked, 0, false, true) 7360CLONE_TEST2(clone_vm_signalignored, CLONE_VM, true, false) 7361CLONE_TEST2(clone_vm_signalmasked, CLONE_VM, false, true) 7362CLONE_TEST2(clone_fs_signalignored, CLONE_FS, true, false) 7363CLONE_TEST2(clone_fs_signalmasked, CLONE_FS, false, true) 7364CLONE_TEST2(clone_files_signalignored, CLONE_FILES, true, false) 7365CLONE_TEST2(clone_files_signalmasked, CLONE_FILES, false, true) 7366//CLONE_TEST2(clone_sighand_signalignored, CLONE_SIGHAND, true, false) // XXX 7367//CLONE_TEST2(clone_sighand_signalmasked, CLONE_SIGHAND, false, true) // XXX 7368#if TEST_VFORK_ENABLED 7369CLONE_TEST2(clone_vfork_signalignored, CLONE_VFORK, true, false) 7370CLONE_TEST2(clone_vfork_signalmasked, CLONE_VFORK, false, true) 7371#endif 7372#endif 7373 7374/// ---------------------------------------------------------------------------- 7375 7376#if TEST_VFORK_ENABLED 7377#if defined(TWAIT_HAVE_PID) 7378static void 7379traceme_vfork_clone_body(int flags) 7380{ 7381 const int exitval = 5; 7382 const int exitval2 = 15; 7383 pid_t child, child2 = 0, wpid; 7384#if defined(TWAIT_HAVE_STATUS) 7385 int status; 7386#endif 7387 7388 const size_t stack_size = 1024 * 1024; 7389 void *stack, *stack_base; 7390 7391 stack = malloc(stack_size); 7392 ATF_REQUIRE(stack != NULL); 7393 7394#ifdef __MACHINE_STACK_GROWS_UP 7395 stack_base = stack; 7396#else 7397 stack_base = (char *)stack + stack_size; 7398#endif 7399 7400 SYSCALL_REQUIRE((child = vfork()) != -1); 7401 if (child == 0) { 7402 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 7403 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 7404 7405 DPRINTF("Before forking process PID=%d flags=%#x\n", getpid(), 7406 flags); 7407 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 7408 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 7409 7410 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 7411 child2); 7412 7413 // XXX WALLSIG? 7414 FORKEE_REQUIRE_SUCCESS 7415 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 7416 7417 forkee_status_exited(status, exitval2); 7418 7419 DPRINTF("Before exiting of the child process\n"); 7420 _exit(exitval); 7421 } 7422 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 7423 7424 DPRINTF("Before calling %s() for the child - expected exited\n", 7425 TWAIT_FNAME); 7426 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7427 7428 validate_status_exited(status, exitval); 7429 7430 DPRINTF("Before calling %s() for the child - expected no process\n", 7431 TWAIT_FNAME); 7432 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 7433} 7434 7435#define TRACEME_VFORK_CLONE_TEST(name,flags) \ 7436ATF_TC(name); \ 7437ATF_TC_HEAD(name, tc) \ 7438{ \ 7439 atf_tc_set_md_var(tc, "descr", "Verify that clone(%s) is " \ 7440 "handled correctly with vfork(2)ed tracer", \ 7441 #flags); \ 7442} \ 7443 \ 7444ATF_TC_BODY(name, tc) \ 7445{ \ 7446 \ 7447 traceme_vfork_clone_body(flags); \ 7448} 7449 7450TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone, 0) 7451TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_vm, CLONE_VM) 7452TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_fs, CLONE_FS) 7453TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_files, CLONE_FILES) 7454//TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_sighand, CLONE_SIGHAND) // XXX 7455TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_vfork, CLONE_VFORK) 7456#endif 7457#endif 7458 7459/// ---------------------------------------------------------------------------- 7460 7461#include "t_ptrace_amd64_wait.h" 7462#include "t_ptrace_i386_wait.h" 7463#include "t_ptrace_x86_wait.h" 7464 7465ATF_TP_ADD_TCS(tp) 7466{ 7467 setvbuf(stdout, NULL, _IONBF, 0); 7468 setvbuf(stderr, NULL, _IONBF, 0); 7469 7470 ATF_TP_ADD_TC(tp, traceme_raise1); 7471 ATF_TP_ADD_TC(tp, traceme_raise2); 7472 ATF_TP_ADD_TC(tp, traceme_raise3); 7473 ATF_TP_ADD_TC(tp, traceme_raise4); 7474 ATF_TP_ADD_TC(tp, traceme_raise5); 7475 ATF_TP_ADD_TC(tp, traceme_raise6); 7476 ATF_TP_ADD_TC(tp, traceme_raise7); 7477 ATF_TP_ADD_TC(tp, traceme_raise8); 7478 ATF_TP_ADD_TC(tp, traceme_raise9); 7479 ATF_TP_ADD_TC(tp, traceme_raise10); 7480 7481 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored1); 7482 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored2); 7483 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored3); 7484 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored4); 7485 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored5); 7486 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored6); 7487 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored7); 7488 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored8); 7489 7490 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked1); 7491 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked2); 7492 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked3); 7493 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked4); 7494 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked5); 7495 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked6); 7496 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked7); 7497 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked8); 7498 7499 ATF_TP_ADD_TC(tp, traceme_crash_trap); 7500 ATF_TP_ADD_TC(tp, traceme_crash_segv); 7501 ATF_TP_ADD_TC(tp, traceme_crash_ill); 7502 ATF_TP_ADD_TC(tp, traceme_crash_fpe); 7503 ATF_TP_ADD_TC(tp, traceme_crash_bus); 7504 7505 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_trap); 7506 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_segv); 7507 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_ill); 7508 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_fpe); 7509 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_bus); 7510 7511 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_trap); 7512 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_segv); 7513 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_ill); 7514 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_fpe); 7515 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_bus); 7516 7517 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle1); 7518 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle2); 7519 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle3); 7520 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle4); 7521 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle5); 7522 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle6); 7523 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle7); 7524 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle8); 7525 7526 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked1); 7527 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked2); 7528 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked3); 7529 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked4); 7530 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked5); 7531 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked6); 7532 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked7); 7533 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked8); 7534 7535 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored1); 7536 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored2); 7537 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored3); 7538 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored4); 7539 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored5); 7540 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored6); 7541 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored7); 7542 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored8); 7543 7544 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple1); 7545 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple2); 7546 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple3); 7547 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple4); 7548 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple5); 7549 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple6); 7550 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple7); 7551 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple8); 7552 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple9); 7553 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple10); 7554 7555 ATF_TP_ADD_TC(tp, traceme_pid1_parent); 7556 7557 ATF_TP_ADD_TC(tp, traceme_vfork_raise1); 7558 ATF_TP_ADD_TC(tp, traceme_vfork_raise2); 7559 ATF_TP_ADD_TC(tp, traceme_vfork_raise3); 7560 ATF_TP_ADD_TC(tp, traceme_vfork_raise4); 7561 ATF_TP_ADD_TC(tp, traceme_vfork_raise5); 7562 ATF_TP_ADD_TC(tp, traceme_vfork_raise6); 7563 ATF_TP_ADD_TC(tp, traceme_vfork_raise7); 7564 ATF_TP_ADD_TC(tp, traceme_vfork_raise8); 7565 ATF_TP_ADD_TC(tp, traceme_vfork_raise9); 7566 ATF_TP_ADD_TC(tp, traceme_vfork_raise10); 7567 ATF_TP_ADD_TC(tp, traceme_vfork_raise11); 7568 ATF_TP_ADD_TC(tp, traceme_vfork_raise12); 7569 ATF_TP_ADD_TC(tp, traceme_vfork_raise13); 7570 7571 ATF_TP_ADD_TC(tp, traceme_vfork_crash_trap); 7572 ATF_TP_ADD_TC(tp, traceme_vfork_crash_segv); 7573 ATF_TP_ADD_TC(tp, traceme_vfork_crash_ill); 7574 ATF_TP_ADD_TC(tp, traceme_vfork_crash_fpe); 7575 ATF_TP_ADD_TC(tp, traceme_vfork_crash_bus); 7576 7577 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_trap); 7578 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_segv); 7579 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_ill); 7580 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_fpe); 7581 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_bus); 7582 7583 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_trap); 7584 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_segv); 7585 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_ill); 7586 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_fpe); 7587 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_bus); 7588 7589 ATF_TP_ADD_TC(tp, traceme_vfork_exec); 7590 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_exec); 7591 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_exec); 7592 7593 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_trap); 7594 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_segv); 7595 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_ill); 7596 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_fpe); 7597 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_bus); 7598 7599 ATF_TP_ADD_TC_HAVE_PID(tp, 7600 unrelated_tracer_sees_signalmasked_crash_trap); 7601 ATF_TP_ADD_TC_HAVE_PID(tp, 7602 unrelated_tracer_sees_signalmasked_crash_segv); 7603 ATF_TP_ADD_TC_HAVE_PID(tp, 7604 unrelated_tracer_sees_signalmasked_crash_ill); 7605 ATF_TP_ADD_TC_HAVE_PID(tp, 7606 unrelated_tracer_sees_signalmasked_crash_fpe); 7607 ATF_TP_ADD_TC_HAVE_PID(tp, 7608 unrelated_tracer_sees_signalmasked_crash_bus); 7609 7610 ATF_TP_ADD_TC_HAVE_PID(tp, 7611 unrelated_tracer_sees_signalignored_crash_trap); 7612 ATF_TP_ADD_TC_HAVE_PID(tp, 7613 unrelated_tracer_sees_signalignored_crash_segv); 7614 ATF_TP_ADD_TC_HAVE_PID(tp, 7615 unrelated_tracer_sees_signalignored_crash_ill); 7616 ATF_TP_ADD_TC_HAVE_PID(tp, 7617 unrelated_tracer_sees_signalignored_crash_fpe); 7618 ATF_TP_ADD_TC_HAVE_PID(tp, 7619 unrelated_tracer_sees_signalignored_crash_bus); 7620 7621 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sees_terminaton_before_the_parent); 7622 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sysctl_lookup_without_duplicates); 7623 ATF_TP_ADD_TC_HAVE_PID(tp, 7624 unrelated_tracer_sees_terminaton_before_the_parent); 7625 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_attach_to_unrelated_stopped_process); 7626 7627 ATF_TP_ADD_TC(tp, parent_attach_to_its_child); 7628 ATF_TP_ADD_TC(tp, parent_attach_to_its_stopped_child); 7629 7630 ATF_TP_ADD_TC(tp, child_attach_to_its_parent); 7631 ATF_TP_ADD_TC(tp, child_attach_to_its_stopped_parent); 7632 7633 ATF_TP_ADD_TC_HAVE_PID(tp, 7634 tracee_sees_its_original_parent_getppid); 7635 ATF_TP_ADD_TC_HAVE_PID(tp, 7636 tracee_sees_its_original_parent_sysctl_kinfo_proc2); 7637 ATF_TP_ADD_TC_HAVE_PID(tp, 7638 tracee_sees_its_original_parent_procfs_status); 7639 7640 ATF_TP_ADD_TC(tp, eventmask_preserved_empty); 7641 ATF_TP_ADD_TC(tp, eventmask_preserved_fork); 7642 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork); 7643 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork_done); 7644 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_create); 7645 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_exit); 7646 7647 ATF_TP_ADD_TC(tp, fork1); 7648 ATF_TP_ADD_TC_HAVE_PID(tp, fork2); 7649 ATF_TP_ADD_TC_HAVE_PID(tp, fork3); 7650 ATF_TP_ADD_TC_HAVE_PID(tp, fork4); 7651 ATF_TP_ADD_TC(tp, fork5); 7652 ATF_TP_ADD_TC_HAVE_PID(tp, fork6); 7653 ATF_TP_ADD_TC_HAVE_PID(tp, fork7); 7654 ATF_TP_ADD_TC_HAVE_PID(tp, fork8); 7655 7656#if TEST_VFORK_ENABLED 7657 ATF_TP_ADD_TC(tp, vfork1); 7658 ATF_TP_ADD_TC_HAVE_PID(tp, vfork2); 7659 ATF_TP_ADD_TC_HAVE_PID(tp, vfork3); 7660 ATF_TP_ADD_TC_HAVE_PID(tp, vfork4); 7661 ATF_TP_ADD_TC(tp, vfork5); 7662 ATF_TP_ADD_TC_HAVE_PID(tp, vfork6); 7663 ATF_TP_ADD_TC_HAVE_PID(tp, vfork7); 7664 ATF_TP_ADD_TC_HAVE_PID(tp, vfork8); 7665#endif 7666 7667 ATF_TP_ADD_TC_HAVE_PID(tp, fork_detach_forker); 7668#if TEST_VFORK_ENABLED 7669 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforker); 7670 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforkerdone); 7671#endif 7672 ATF_TP_ADD_TC_HAVE_PID(tp, fork_kill_forker); 7673#if TEST_VFORK_ENABLED 7674 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforker); 7675 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforkerdone); 7676#endif 7677 7678#if TEST_VFORK_ENABLED 7679 ATF_TP_ADD_TC(tp, traceme_vfork_fork); 7680 ATF_TP_ADD_TC(tp, traceme_vfork_vfork); 7681#endif 7682 7683 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8); 7684 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16); 7685 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32); 7686 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64); 7687 7688 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8); 7689 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16); 7690 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32); 7691 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64); 7692 7693 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8); 7694 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16); 7695 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32); 7696 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64); 7697 7698 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8); 7699 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16); 7700 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32); 7701 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64); 7702 7703 ATF_TP_ADD_TC(tp, bytes_transfer_read_d); 7704 ATF_TP_ADD_TC(tp, bytes_transfer_read_i); 7705 ATF_TP_ADD_TC(tp, bytes_transfer_write_d); 7706 ATF_TP_ADD_TC(tp, bytes_transfer_write_i); 7707 7708 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8_text); 7709 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16_text); 7710 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32_text); 7711 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64_text); 7712 7713 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8_text); 7714 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16_text); 7715 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32_text); 7716 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64_text); 7717 7718 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8_text); 7719 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16_text); 7720 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32_text); 7721 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64_text); 7722 7723 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8_text); 7724 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16_text); 7725 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32_text); 7726 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64_text); 7727 7728 ATF_TP_ADD_TC(tp, bytes_transfer_read_d_text); 7729 ATF_TP_ADD_TC(tp, bytes_transfer_read_i_text); 7730 ATF_TP_ADD_TC(tp, bytes_transfer_write_d_text); 7731 ATF_TP_ADD_TC(tp, bytes_transfer_write_i_text); 7732 7733 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_auxv); 7734 7735 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_i); 7736 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_d); 7737 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_i); 7738 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_d); 7739 7740 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_i); 7741 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_d); 7742 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_i); 7743 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_d); 7744 7745 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_auxv); 7746 7747 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_i); 7748 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_d); 7749 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_i); 7750 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_d); 7751 7752 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_i); 7753 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_d); 7754 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_i); 7755 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_d); 7756 7757 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs1); 7758 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs2); 7759 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs3); 7760 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs4); 7761 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs5); 7762 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs6); 7763 7764 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs1); 7765 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs2); 7766 7767 ATF_TP_ADD_TC_PT_STEP(tp, step1); 7768 ATF_TP_ADD_TC_PT_STEP(tp, step2); 7769 ATF_TP_ADD_TC_PT_STEP(tp, step3); 7770 ATF_TP_ADD_TC_PT_STEP(tp, step4); 7771 7772 ATF_TP_ADD_TC_PT_STEP(tp, setstep1); 7773 ATF_TP_ADD_TC_PT_STEP(tp, setstep2); 7774 ATF_TP_ADD_TC_PT_STEP(tp, setstep3); 7775 ATF_TP_ADD_TC_PT_STEP(tp, setstep4); 7776 7777 ATF_TP_ADD_TC_PT_STEP(tp, step_signalmasked); 7778 ATF_TP_ADD_TC_PT_STEP(tp, step_signalignored); 7779 7780 ATF_TP_ADD_TC(tp, kill1); 7781 ATF_TP_ADD_TC(tp, kill2); 7782 ATF_TP_ADD_TC(tp, kill3); 7783 7784 ATF_TP_ADD_TC(tp, traceme_lwpinfo0); 7785 ATF_TP_ADD_TC(tp, traceme_lwpinfo1); 7786 ATF_TP_ADD_TC(tp, traceme_lwpinfo2); 7787 ATF_TP_ADD_TC(tp, traceme_lwpinfo3); 7788 7789 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo0); 7790 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo1); 7791 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo2); 7792 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo3); 7793 7794 ATF_TP_ADD_TC(tp, siginfo_set_unmodified); 7795 ATF_TP_ADD_TC(tp, siginfo_set_faked); 7796 7797 ATF_TP_ADD_TC(tp, traceme_exec); 7798 ATF_TP_ADD_TC(tp, traceme_signalmasked_exec); 7799 ATF_TP_ADD_TC(tp, traceme_signalignored_exec); 7800 7801 ATF_TP_ADD_TC(tp, trace_thread1); 7802 ATF_TP_ADD_TC(tp, trace_thread2); 7803 ATF_TP_ADD_TC(tp, trace_thread3); 7804 ATF_TP_ADD_TC(tp, trace_thread4); 7805 7806 ATF_TP_ADD_TC(tp, signal_mask_unrelated); 7807 7808 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalmasked); 7809 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalignored); 7810#if TEST_VFORK_ENABLED 7811 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalmasked); 7812 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalignored); 7813 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalmasked); 7814 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalignored); 7815#endif 7816 7817 ATF_TP_ADD_TC(tp, signal9); 7818 ATF_TP_ADD_TC(tp, signal10); 7819 7820 ATF_TP_ADD_TC(tp, suspend1); 7821 ATF_TP_ADD_TC(tp, suspend2); 7822 7823 ATF_TP_ADD_TC(tp, resume1); 7824 7825 ATF_TP_ADD_TC(tp, syscall1); 7826 7827 ATF_TP_ADD_TC(tp, syscallemu1); 7828 7829 ATF_TP_ADD_TC(tp, clone1); 7830 ATF_TP_ADD_TC_HAVE_PID(tp, clone2); 7831 ATF_TP_ADD_TC_HAVE_PID(tp, clone3); 7832 ATF_TP_ADD_TC_HAVE_PID(tp, clone4); 7833 ATF_TP_ADD_TC(tp, clone5); 7834 ATF_TP_ADD_TC_HAVE_PID(tp, clone6); 7835 ATF_TP_ADD_TC_HAVE_PID(tp, clone7); 7836 ATF_TP_ADD_TC_HAVE_PID(tp, clone8); 7837 7838 ATF_TP_ADD_TC(tp, clone_vm1); 7839 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm2); 7840 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm3); 7841 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm4); 7842 ATF_TP_ADD_TC(tp, clone_vm5); 7843 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm6); 7844 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm7); 7845 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm8); 7846 7847 ATF_TP_ADD_TC(tp, clone_fs1); 7848 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs2); 7849 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs3); 7850 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs4); 7851 ATF_TP_ADD_TC(tp, clone_fs5); 7852 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs6); 7853 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs7); 7854 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs8); 7855 7856 ATF_TP_ADD_TC(tp, clone_files1); 7857 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files2); 7858 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files3); 7859 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files4); 7860 ATF_TP_ADD_TC(tp, clone_files5); 7861 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files6); 7862 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files7); 7863 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files8); 7864 7865// ATF_TP_ADD_TC(tp, clone_sighand1); // XXX 7866// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand2); // XXX 7867// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand3); // XXX 7868// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand4); // XXX 7869// ATF_TP_ADD_TC(tp, clone_sighand5); // XXX 7870// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand6); // XXX 7871// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand7); // XXX 7872// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand8); // XXX 7873 7874#if TEST_VFORK_ENABLED 7875 ATF_TP_ADD_TC(tp, clone_vfork1); 7876 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork2); 7877 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork3); 7878 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork4); 7879 ATF_TP_ADD_TC(tp, clone_vfork5); 7880 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork6); 7881 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork7); 7882 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork8); 7883#endif 7884 7885 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalignored); 7886 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalmasked); 7887 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalignored); 7888 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalmasked); 7889 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalignored); 7890 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalmasked); 7891 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalignored); 7892 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalmasked); 7893// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalignored); // XXX 7894// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalmasked); // XXX 7895#if TEST_VFORK_ENABLED 7896 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalignored); 7897 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalmasked); 7898#endif 7899 7900#if TEST_VFORK_ENABLED 7901 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone); 7902 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vm); 7903 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_fs); 7904 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_files); 7905// ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_sighand); // XXX 7906 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vfork); 7907#endif 7908 7909 ATF_TP_ADD_TCS_PTRACE_WAIT_AMD64(); 7910 ATF_TP_ADD_TCS_PTRACE_WAIT_I386(); 7911 ATF_TP_ADD_TCS_PTRACE_WAIT_X86(); 7912 7913 return atf_no_error(); 7914} 7915