t_ptrace_wait.c revision 1.119
1/* $NetBSD: t_ptrace_wait.c,v 1.119 2019/05/02 00:34:06 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.119 2019/05/02 00:34:06 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 if (trace_exit) 5363 atf_tc_skip("PR kern/51995"); 5364 5365 DPRINTF("Before forking process PID=%d\n", getpid()); 5366 SYSCALL_REQUIRE((child = fork()) != -1); 5367 if (child == 0) { 5368 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5369 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5370 5371 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5372 FORKEE_ASSERT(raise(sigval) == 0); 5373 5374 for (n = 0; n < __arraycount(t); n++) { 5375 rv = pthread_create(&t[n], NULL, trace_threads_cb, 5376 NULL); 5377 FORKEE_ASSERT(rv == 0); 5378 } 5379 5380 for (n = 0; n < __arraycount(t); n++) { 5381 rv = pthread_join(t[n], NULL); 5382 FORKEE_ASSERT(rv == 0); 5383 } 5384 5385 /* 5386 * There is race between _exit() and pthread_join() detaching 5387 * a thread. For simplicity kill the process after detecting 5388 * LWP events. 5389 */ 5390 while (true) 5391 continue; 5392 5393 FORKEE_ASSERT(0 && "Not reached"); 5394 } 5395 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5396 5397 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5398 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5399 5400 validate_status_stopped(status, sigval); 5401 5402 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5403 SYSCALL_REQUIRE( 5404 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5405 5406 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5407 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5408 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5409 info.psi_siginfo.si_errno); 5410 5411 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5412 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 5413 5414 DPRINTF("Set LWP event mask for the child %d\n", child); 5415 memset(&event, 0, sizeof(event)); 5416 if (trace_create) 5417 event.pe_set_event |= PTRACE_LWP_CREATE; 5418 if (trace_exit) 5419 event.pe_set_event |= PTRACE_LWP_EXIT; 5420 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 5421 5422 DPRINTF("Before resuming the child process where it left off and " 5423 "without signal to be sent\n"); 5424 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5425 5426 memset(traced_lwps, 0, sizeof(traced_lwps)); 5427 5428 for (n = 0; n < (trace_create ? __arraycount(t) : 0); n++) { 5429 DPRINTF("Before calling %s() for the child - expected stopped " 5430 "SIGTRAP\n", TWAIT_FNAME); 5431 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5432 child); 5433 5434 validate_status_stopped(status, SIGTRAP); 5435 5436 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5437 "child\n"); 5438 SYSCALL_REQUIRE( 5439 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5440 5441 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5442 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5443 "si_errno=%#x\n", 5444 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5445 info.psi_siginfo.si_errno); 5446 5447 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5448 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5449 5450 SYSCALL_REQUIRE( 5451 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5452 5453 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_CREATE, 5454 "%d != %d", state.pe_report_event, PTRACE_LWP_CREATE); 5455 5456 lid = state.pe_lwp; 5457 DPRINTF("Reported PTRACE_LWP_CREATE event with lid %d\n", lid); 5458 5459 traced_lwps[lid - 1] = true; 5460 5461 DPRINTF("Before resuming the child process where it left off " 5462 "and without signal to be sent\n"); 5463 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5464 } 5465 5466 for (n = 0; n < (trace_exit ? __arraycount(t) : 0); n++) { 5467 DPRINTF("Before calling %s() for the child - expected stopped " 5468 "SIGTRAP\n", TWAIT_FNAME); 5469 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5470 child); 5471 5472 validate_status_stopped(status, SIGTRAP); 5473 5474 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5475 "child\n"); 5476 SYSCALL_REQUIRE( 5477 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5478 5479 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5480 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5481 "si_errno=%#x\n", 5482 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5483 info.psi_siginfo.si_errno); 5484 5485 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5486 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5487 5488 SYSCALL_REQUIRE( 5489 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5490 5491 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_EXIT, 5492 "%d != %d", state.pe_report_event, PTRACE_LWP_EXIT); 5493 5494 lid = state.pe_lwp; 5495 DPRINTF("Reported PTRACE_LWP_EXIT event with lid %d\n", lid); 5496 5497 if (trace_create) { 5498 ATF_REQUIRE(traced_lwps[lid - 1] == true); 5499 traced_lwps[lid - 1] = false; 5500 } 5501 5502 DPRINTF("Before resuming the child process where it left off " 5503 "and without signal to be sent\n"); 5504 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5505 } 5506 5507 kill(child, SIGKILL); 5508 5509 DPRINTF("Before calling %s() for the child - expected exited\n", 5510 TWAIT_FNAME); 5511 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5512 5513 validate_status_signaled(status, SIGKILL, 0); 5514 5515 DPRINTF("Before calling %s() for the child - expected no process\n", 5516 TWAIT_FNAME); 5517 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5518} 5519 5520#define TRACE_THREADS(test, trace_create, trace_exit) \ 5521ATF_TC(test); \ 5522ATF_TC_HEAD(test, tc) \ 5523{ \ 5524 atf_tc_set_md_var(tc, "descr", \ 5525 "Verify spawning threads with%s tracing LWP create and" \ 5526 "with%s tracing LWP exit", trace_create ? "" : "out", \ 5527 trace_exit ? "" : "out"); \ 5528} \ 5529 \ 5530ATF_TC_BODY(test, tc) \ 5531{ \ 5532 \ 5533 trace_threads(trace_create, trace_exit); \ 5534} 5535 5536TRACE_THREADS(trace_thread_nolwpevents, false, false) 5537TRACE_THREADS(trace_thread_lwpexit, false, true) 5538TRACE_THREADS(trace_thread_lwpcreate, true, false) 5539TRACE_THREADS(trace_thread_lwpcreate_and_exit, true, true) 5540 5541/// ---------------------------------------------------------------------------- 5542 5543ATF_TC(signal_mask_unrelated); 5544ATF_TC_HEAD(signal_mask_unrelated, tc) 5545{ 5546 atf_tc_set_md_var(tc, "descr", 5547 "Verify that masking single unrelated signal does not stop tracer " 5548 "from catching other signals"); 5549} 5550 5551ATF_TC_BODY(signal_mask_unrelated, tc) 5552{ 5553 const int exitval = 5; 5554 const int sigval = SIGSTOP; 5555 const int sigmasked = SIGTRAP; 5556 const int signotmasked = SIGINT; 5557 pid_t child, wpid; 5558#if defined(TWAIT_HAVE_STATUS) 5559 int status; 5560#endif 5561 sigset_t intmask; 5562 5563 DPRINTF("Before forking process PID=%d\n", getpid()); 5564 SYSCALL_REQUIRE((child = fork()) != -1); 5565 if (child == 0) { 5566 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5567 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5568 5569 sigemptyset(&intmask); 5570 sigaddset(&intmask, sigmasked); 5571 sigprocmask(SIG_BLOCK, &intmask, NULL); 5572 5573 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5574 FORKEE_ASSERT(raise(sigval) == 0); 5575 5576 DPRINTF("Before raising %s from child\n", 5577 strsignal(signotmasked)); 5578 FORKEE_ASSERT(raise(signotmasked) == 0); 5579 5580 DPRINTF("Before exiting of the child process\n"); 5581 _exit(exitval); 5582 } 5583 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5584 5585 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5586 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5587 5588 validate_status_stopped(status, sigval); 5589 5590 DPRINTF("Before resuming the child process where it left off and " 5591 "without signal to be sent\n"); 5592 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5593 5594 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5595 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5596 5597 validate_status_stopped(status, signotmasked); 5598 5599 DPRINTF("Before resuming the child process where it left off and " 5600 "without signal to be sent\n"); 5601 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5602 5603 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5604 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5605 5606 validate_status_exited(status, exitval); 5607 5608 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5609 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5610} 5611 5612/// ---------------------------------------------------------------------------- 5613 5614#if defined(TWAIT_HAVE_PID) 5615static void 5616fork2_body(bool trackfork, bool trackvfork, bool trackvforkdone, bool masked, 5617 bool ignored) 5618{ 5619 const int exitval = 5; 5620 const int exitval2 = 15; 5621 const int sigval = SIGSTOP; 5622 pid_t child, child2 = 0, wpid; 5623#if defined(TWAIT_HAVE_STATUS) 5624 int status; 5625#endif 5626 ptrace_state_t state; 5627 const int slen = sizeof(state); 5628 ptrace_event_t event; 5629 const int elen = sizeof(event); 5630 pid_t (*fn)(void); 5631 struct sigaction sa; 5632 struct ptrace_siginfo info; 5633 sigset_t intmask; 5634 struct kinfo_proc2 kp; 5635 size_t len = sizeof(kp); 5636 5637 int name[6]; 5638 const size_t namelen = __arraycount(name); 5639 ki_sigset_t kp_sigmask; 5640 ki_sigset_t kp_sigignore; 5641 5642 if (trackfork) 5643 fn = fork; 5644 if (trackvfork || trackvforkdone) 5645 fn = vfork; 5646 5647 DPRINTF("Before forking process PID=%d\n", getpid()); 5648 SYSCALL_REQUIRE((child = fork()) != -1); 5649 if (child == 0) { 5650 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5651 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5652 5653 if (masked) { 5654 sigemptyset(&intmask); 5655 sigaddset(&intmask, SIGTRAP); 5656 sigprocmask(SIG_BLOCK, &intmask, NULL); 5657 } 5658 5659 if (ignored) { 5660 memset(&sa, 0, sizeof(sa)); 5661 sa.sa_handler = SIG_IGN; 5662 sigemptyset(&sa.sa_mask); 5663 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 5664 } 5665 5666 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5667 FORKEE_ASSERT(raise(sigval) == 0); 5668 5669 FORKEE_ASSERT((child2 = (fn)()) != -1); 5670 5671 if (child2 == 0) 5672 _exit(exitval2); 5673 5674 FORKEE_REQUIRE_SUCCESS 5675 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 5676 5677 forkee_status_exited(status, exitval2); 5678 5679 DPRINTF("Before exiting of the child process\n"); 5680 _exit(exitval); 5681 } 5682 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5683 5684 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5685 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5686 5687 validate_status_stopped(status, sigval); 5688 5689 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5690 SYSCALL_REQUIRE( 5691 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5692 5693 DPRINTF("Before checking siginfo_t\n"); 5694 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5695 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 5696 5697 name[0] = CTL_KERN, 5698 name[1] = KERN_PROC2, 5699 name[2] = KERN_PROC_PID; 5700 name[3] = child; 5701 name[4] = sizeof(kp); 5702 name[5] = 1; 5703 5704 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5705 5706 if (masked) 5707 kp_sigmask = kp.p_sigmask; 5708 5709 if (ignored) 5710 kp_sigignore = kp.p_sigignore; 5711 5712 DPRINTF("Set 0%s%s%s in EVENT_MASK for the child %d\n", 5713 trackfork ? "|PTRACE_FORK" : "", 5714 trackvfork ? "|PTRACE_VFORK" : "", 5715 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 5716 event.pe_set_event = 0; 5717 if (trackfork) 5718 event.pe_set_event |= PTRACE_FORK; 5719 if (trackvfork) 5720 event.pe_set_event |= PTRACE_VFORK; 5721 if (trackvforkdone) 5722 event.pe_set_event |= PTRACE_VFORK_DONE; 5723 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 5724 5725 DPRINTF("Before resuming the child process where it left off and " 5726 "without signal to be sent\n"); 5727 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5728 5729 if (trackfork || trackvfork) { 5730 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 5731 child); 5732 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5733 child); 5734 5735 validate_status_stopped(status, SIGTRAP); 5736 5737 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5738 5739 if (masked) { 5740 DPRINTF("kp_sigmask=" 5741 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5742 PRIx32 "\n", 5743 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5744 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5745 5746 DPRINTF("kp.p_sigmask=" 5747 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5748 PRIx32 "\n", 5749 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5750 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5751 5752 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5753 sizeof(kp_sigmask))); 5754 } 5755 5756 if (ignored) { 5757 DPRINTF("kp_sigignore=" 5758 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5759 PRIx32 "\n", 5760 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5761 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5762 5763 DPRINTF("kp.p_sigignore=" 5764 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5765 PRIx32 "\n", 5766 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5767 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5768 5769 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5770 sizeof(kp_sigignore))); 5771 } 5772 5773 SYSCALL_REQUIRE( 5774 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5775 if (trackfork) { 5776 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 5777 PTRACE_FORK); 5778 } 5779 if (trackvfork) { 5780 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 5781 PTRACE_VFORK); 5782 } 5783 5784 child2 = state.pe_other_pid; 5785 DPRINTF("Reported ptrace event with forkee %d\n", child2); 5786 5787 DPRINTF("Before calling %s() for the forkee %d of the child " 5788 "%d\n", TWAIT_FNAME, child2, child); 5789 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 5790 child2); 5791 5792 validate_status_stopped(status, SIGTRAP); 5793 5794 name[3] = child2; 5795 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5796 5797 if (masked) { 5798 DPRINTF("kp_sigmask=" 5799 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5800 PRIx32 "\n", 5801 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5802 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5803 5804 DPRINTF("kp.p_sigmask=" 5805 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5806 PRIx32 "\n", 5807 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5808 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5809 5810 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5811 sizeof(kp_sigmask))); 5812 } 5813 5814 if (ignored) { 5815 DPRINTF("kp_sigignore=" 5816 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5817 PRIx32 "\n", 5818 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5819 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5820 5821 DPRINTF("kp.p_sigignore=" 5822 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5823 PRIx32 "\n", 5824 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5825 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5826 5827 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5828 sizeof(kp_sigignore))); 5829 } 5830 5831 SYSCALL_REQUIRE( 5832 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 5833 if (trackfork) { 5834 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 5835 PTRACE_FORK); 5836 } 5837 if (trackvfork) { 5838 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 5839 PTRACE_VFORK); 5840 } 5841 5842 ATF_REQUIRE_EQ(state.pe_other_pid, child); 5843 5844 DPRINTF("Before resuming the forkee process where it left off " 5845 "and without signal to be sent\n"); 5846 SYSCALL_REQUIRE( 5847 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 5848 5849 DPRINTF("Before resuming the child process where it left off " 5850 "and without signal to be sent\n"); 5851 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5852 } 5853 5854 if (trackvforkdone) { 5855 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 5856 child); 5857 TWAIT_REQUIRE_SUCCESS( 5858 wpid = TWAIT_GENERIC(child, &status, 0), child); 5859 5860 validate_status_stopped(status, SIGTRAP); 5861 5862 name[3] = child; 5863 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5864 5865 /* 5866 * SIGCHLD is now pending in the signal queue and 5867 * the kernel presents it to userland as a masked signal. 5868 */ 5869 sigdelset((sigset_t *)&kp.p_sigmask, SIGCHLD); 5870 5871 if (masked) { 5872 DPRINTF("kp_sigmask=" 5873 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5874 PRIx32 "\n", 5875 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5876 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5877 5878 DPRINTF("kp.p_sigmask=" 5879 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5880 PRIx32 "\n", 5881 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5882 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5883 5884 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5885 sizeof(kp_sigmask))); 5886 } 5887 5888 if (ignored) { 5889 DPRINTF("kp_sigignore=" 5890 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5891 PRIx32 "\n", 5892 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5893 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5894 5895 DPRINTF("kp.p_sigignore=" 5896 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 5897 PRIx32 "\n", 5898 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5899 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5900 5901 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5902 sizeof(kp_sigignore))); 5903 } 5904 5905 SYSCALL_REQUIRE( 5906 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5907 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 5908 5909 child2 = state.pe_other_pid; 5910 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 5911 child2); 5912 5913 DPRINTF("Before resuming the child process where it left off " 5914 "and without signal to be sent\n"); 5915 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5916 } 5917 5918 if (trackfork || trackvfork) { 5919 DPRINTF("Before calling %s() for the forkee - expected exited" 5920 "\n", TWAIT_FNAME); 5921 TWAIT_REQUIRE_SUCCESS( 5922 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 5923 5924 validate_status_exited(status, exitval2); 5925 5926 DPRINTF("Before calling %s() for the forkee - expected no " 5927 "process\n", TWAIT_FNAME); 5928 TWAIT_REQUIRE_FAILURE(ECHILD, 5929 wpid = TWAIT_GENERIC(child2, &status, 0)); 5930 } 5931 5932 DPRINTF("Before calling %s() for the child - expected stopped " 5933 "SIGCHLD\n", TWAIT_FNAME); 5934 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5935 5936 validate_status_stopped(status, SIGCHLD); 5937 5938 DPRINTF("Before resuming the child process where it left off and " 5939 "without signal to be sent\n"); 5940 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5941 5942 DPRINTF("Before calling %s() for the child - expected exited\n", 5943 TWAIT_FNAME); 5944 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5945 5946 validate_status_exited(status, exitval); 5947 5948 DPRINTF("Before calling %s() for the child - expected no process\n", 5949 TWAIT_FNAME); 5950 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5951} 5952 5953#define FORK2_TEST(name,trackfork,trackvfork,trackvforkdone, \ 5954 masked,ignored) \ 5955ATF_TC(name); \ 5956ATF_TC_HEAD(name, tc) \ 5957{ \ 5958 atf_tc_set_md_var(tc, "descr", "Verify that %s%s%s is caught " \ 5959 "regardless of signal %s%s", \ 5960 trackfork ? "PTRACE_FORK" : "", \ 5961 trackvfork ? "PTRACE_VFORK" : "", \ 5962 trackvforkdone ? "PTRACE_VFORK_DONE" : "", \ 5963 masked ? "masked" : "", ignored ? "ignored" : ""); \ 5964} \ 5965 \ 5966ATF_TC_BODY(name, tc) \ 5967{ \ 5968 \ 5969 fork2_body(trackfork, trackvfork, trackvforkdone, masked, \ 5970 ignored); \ 5971} 5972 5973FORK2_TEST(fork_singalmasked, true, false, false, true, false) 5974FORK2_TEST(fork_singalignored, true, false, false, false, true) 5975#if TEST_VFORK_ENABLED 5976FORK2_TEST(vfork_singalmasked, false, true, false, true, false) 5977FORK2_TEST(vfork_singalignored, false, true, false, false, true) 5978FORK2_TEST(vforkdone_singalmasked, false, false, true, true, false) 5979FORK2_TEST(vforkdone_singalignored, false, false, true, false, true) 5980#endif 5981#endif 5982 5983/// ---------------------------------------------------------------------------- 5984 5985volatile lwpid_t the_lwp_id = 0; 5986 5987static void 5988lwp_main_func(void *arg) 5989{ 5990 the_lwp_id = _lwp_self(); 5991 _lwp_exit(); 5992} 5993 5994ATF_TC(signal9); 5995ATF_TC_HEAD(signal9, tc) 5996{ 5997 atf_tc_set_md_var(tc, "descr", 5998 "Verify that masking SIGTRAP in tracee does not stop tracer from " 5999 "catching PTRACE_LWP_CREATE breakpoint"); 6000} 6001 6002ATF_TC_BODY(signal9, tc) 6003{ 6004 const int exitval = 5; 6005 const int sigval = SIGSTOP; 6006 const int sigmasked = SIGTRAP; 6007 pid_t child, wpid; 6008#if defined(TWAIT_HAVE_STATUS) 6009 int status; 6010#endif 6011 sigset_t intmask; 6012 ptrace_state_t state; 6013 const int slen = sizeof(state); 6014 ptrace_event_t event; 6015 const int elen = sizeof(event); 6016 ucontext_t uc; 6017 lwpid_t lid; 6018 static const size_t ssize = 16*1024; 6019 void *stack; 6020 6021 DPRINTF("Before forking process PID=%d\n", getpid()); 6022 SYSCALL_REQUIRE((child = fork()) != -1); 6023 if (child == 0) { 6024 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6025 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6026 6027 sigemptyset(&intmask); 6028 sigaddset(&intmask, sigmasked); 6029 sigprocmask(SIG_BLOCK, &intmask, NULL); 6030 6031 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6032 FORKEE_ASSERT(raise(sigval) == 0); 6033 6034 DPRINTF("Before allocating memory for stack in child\n"); 6035 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6036 6037 DPRINTF("Before making context for new lwp in child\n"); 6038 _lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize); 6039 6040 DPRINTF("Before creating new in child\n"); 6041 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6042 6043 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6044 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6045 6046 DPRINTF("Before verifying that reported %d and running lid %d " 6047 "are the same\n", lid, the_lwp_id); 6048 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6049 6050 DPRINTF("Before exiting of the child process\n"); 6051 _exit(exitval); 6052 } 6053 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6054 6055 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6056 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6057 6058 validate_status_stopped(status, sigval); 6059 6060 DPRINTF("Set empty EVENT_MASK for the child %d\n", child); 6061 event.pe_set_event = PTRACE_LWP_CREATE; 6062 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6063 6064 DPRINTF("Before resuming the child process where it left off and " 6065 "without signal to be sent\n"); 6066 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6067 6068 DPRINTF("Before calling %s() for the child - expected stopped " 6069 "SIGTRAP\n", TWAIT_FNAME); 6070 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6071 6072 validate_status_stopped(status, sigmasked); 6073 6074 SYSCALL_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6075 6076 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_CREATE); 6077 6078 lid = state.pe_lwp; 6079 DPRINTF("Reported PTRACE_LWP_CREATE event with lid %d\n", lid); 6080 6081 DPRINTF("Before resuming the child process where it left off and " 6082 "without signal to be sent\n"); 6083 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6084 6085 DPRINTF("Before calling %s() for the child - expected exited\n", 6086 TWAIT_FNAME); 6087 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6088 6089 validate_status_exited(status, exitval); 6090 6091 DPRINTF("Before calling %s() for the child - expected no process\n", 6092 TWAIT_FNAME); 6093 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6094} 6095 6096ATF_TC(signal10); 6097ATF_TC_HEAD(signal10, tc) 6098{ 6099 atf_tc_set_md_var(tc, "descr", 6100 "Verify that masking SIGTRAP in tracee does not stop tracer from " 6101 "catching PTRACE_LWP_EXIT breakpoint"); 6102} 6103 6104ATF_TC_BODY(signal10, tc) 6105{ 6106 const int exitval = 5; 6107 const int sigval = SIGSTOP; 6108 const int sigmasked = SIGTRAP; 6109 pid_t child, wpid; 6110#if defined(TWAIT_HAVE_STATUS) 6111 int status; 6112#endif 6113 sigset_t intmask; 6114 ptrace_state_t state; 6115 const int slen = sizeof(state); 6116 ptrace_event_t event; 6117 const int elen = sizeof(event); 6118 ucontext_t uc; 6119 lwpid_t lid; 6120 static const size_t ssize = 16*1024; 6121 void *stack; 6122 6123 DPRINTF("Before forking process PID=%d\n", getpid()); 6124 SYSCALL_REQUIRE((child = fork()) != -1); 6125 if (child == 0) { 6126 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6127 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6128 6129 sigemptyset(&intmask); 6130 sigaddset(&intmask, sigmasked); 6131 sigprocmask(SIG_BLOCK, &intmask, NULL); 6132 6133 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6134 FORKEE_ASSERT(raise(sigval) == 0); 6135 6136 DPRINTF("Before allocating memory for stack in child\n"); 6137 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6138 6139 DPRINTF("Before making context for new lwp in child\n"); 6140 _lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize); 6141 6142 DPRINTF("Before creating new in child\n"); 6143 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6144 6145 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6146 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6147 6148 DPRINTF("Before verifying that reported %d and running lid %d " 6149 "are the same\n", lid, the_lwp_id); 6150 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6151 6152 DPRINTF("Before exiting of the child process\n"); 6153 _exit(exitval); 6154 } 6155 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6156 6157 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6158 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6159 6160 validate_status_stopped(status, sigval); 6161 6162 DPRINTF("Set empty EVENT_MASK for the child %d\n", child); 6163 event.pe_set_event = PTRACE_LWP_EXIT; 6164 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6165 6166 DPRINTF("Before resuming the child process where it left off and " 6167 "without signal to be sent\n"); 6168 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6169 6170 DPRINTF("Before calling %s() for the child - expected stopped " 6171 "SIGTRAP\n", TWAIT_FNAME); 6172 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6173 6174 validate_status_stopped(status, sigmasked); 6175 6176 SYSCALL_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6177 6178 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_EXIT); 6179 6180 lid = state.pe_lwp; 6181 DPRINTF("Reported PTRACE_LWP_EXIT event with lid %d\n", lid); 6182 6183 DPRINTF("Before resuming the child process where it left off and " 6184 "without signal to be sent\n"); 6185 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6186 6187 DPRINTF("Before calling %s() for the child - expected exited\n", 6188 TWAIT_FNAME); 6189 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6190 6191 validate_status_exited(status, exitval); 6192 6193 DPRINTF("Before calling %s() for the child - expected no process\n", 6194 TWAIT_FNAME); 6195 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6196} 6197 6198static void 6199lwp_main_stop(void *arg) 6200{ 6201 the_lwp_id = _lwp_self(); 6202 6203 raise(SIGTRAP); 6204 6205 _lwp_exit(); 6206} 6207 6208ATF_TC(suspend1); 6209ATF_TC_HEAD(suspend1, tc) 6210{ 6211 atf_tc_set_md_var(tc, "descr", 6212 "Verify that a thread can be suspended by a debugger and later " 6213 "resumed by a tracee"); 6214} 6215 6216ATF_TC_BODY(suspend1, tc) 6217{ 6218 const int exitval = 5; 6219 const int sigval = SIGSTOP; 6220 pid_t child, wpid; 6221#if defined(TWAIT_HAVE_STATUS) 6222 int status; 6223#endif 6224 ucontext_t uc; 6225 lwpid_t lid; 6226 static const size_t ssize = 16*1024; 6227 void *stack; 6228 struct ptrace_lwpinfo pl; 6229 struct ptrace_siginfo psi; 6230 volatile int go = 0; 6231 6232 DPRINTF("Before forking process PID=%d\n", getpid()); 6233 SYSCALL_REQUIRE((child = fork()) != -1); 6234 if (child == 0) { 6235 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6236 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6237 6238 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6239 FORKEE_ASSERT(raise(sigval) == 0); 6240 6241 DPRINTF("Before allocating memory for stack in child\n"); 6242 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6243 6244 DPRINTF("Before making context for new lwp in child\n"); 6245 _lwp_makecontext(&uc, lwp_main_stop, NULL, NULL, stack, ssize); 6246 6247 DPRINTF("Before creating new in child\n"); 6248 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6249 6250 while (go == 0) 6251 continue; 6252 6253 raise(SIGINT); 6254 6255 FORKEE_ASSERT(_lwp_continue(lid) == 0); 6256 6257 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6258 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6259 6260 DPRINTF("Before verifying that reported %d and running lid %d " 6261 "are the same\n", lid, the_lwp_id); 6262 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6263 6264 DPRINTF("Before exiting of the child process\n"); 6265 _exit(exitval); 6266 } 6267 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6268 6269 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6270 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6271 6272 validate_status_stopped(status, sigval); 6273 6274 DPRINTF("Before resuming the child process where it left off and " 6275 "without signal to be sent\n"); 6276 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6277 6278 DPRINTF("Before calling %s() for the child - expected stopped " 6279 "SIGTRAP\n", TWAIT_FNAME); 6280 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6281 6282 validate_status_stopped(status, SIGTRAP); 6283 6284 DPRINTF("Before reading siginfo and lwpid_t\n"); 6285 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6286 6287 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6288 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6289 6290 DPRINTF("Write new go to tracee (PID=%d) from tracer (PID=%d)\n", 6291 child, getpid()); 6292 SYSCALL_REQUIRE(ptrace(PT_WRITE_D, child, __UNVOLATILE(&go), 1) != -1); 6293 6294 DPRINTF("Before resuming the child process where it left off and " 6295 "without signal to be sent\n"); 6296 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6297 6298 DPRINTF("Before calling %s() for the child - expected stopped " 6299 "SIGINT\n", TWAIT_FNAME); 6300 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6301 6302 validate_status_stopped(status, SIGINT); 6303 6304 pl.pl_lwpid = 0; 6305 6306 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6307 while (pl.pl_lwpid != 0) { 6308 6309 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6310 switch (pl.pl_lwpid) { 6311 case 1: 6312 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SIGNAL); 6313 break; 6314 case 2: 6315 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SUSPENDED); 6316 break; 6317 } 6318 } 6319 6320 DPRINTF("Before resuming the child process where it left off and " 6321 "without signal to be sent\n"); 6322 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6323 6324 DPRINTF("Before calling %s() for the child - expected exited\n", 6325 TWAIT_FNAME); 6326 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6327 6328 validate_status_exited(status, exitval); 6329 6330 DPRINTF("Before calling %s() for the child - expected no process\n", 6331 TWAIT_FNAME); 6332 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6333} 6334 6335ATF_TC(suspend2); 6336ATF_TC_HEAD(suspend2, tc) 6337{ 6338 atf_tc_set_md_var(tc, "descr", 6339 "Verify that the while the only thread within a process is " 6340 "suspended, the whole process cannot be unstopped"); 6341} 6342 6343ATF_TC_BODY(suspend2, tc) 6344{ 6345 const int exitval = 5; 6346 const int sigval = SIGSTOP; 6347 pid_t child, wpid; 6348#if defined(TWAIT_HAVE_STATUS) 6349 int status; 6350#endif 6351 struct ptrace_siginfo psi; 6352 6353 DPRINTF("Before forking process PID=%d\n", getpid()); 6354 SYSCALL_REQUIRE((child = fork()) != -1); 6355 if (child == 0) { 6356 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6357 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6358 6359 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6360 FORKEE_ASSERT(raise(sigval) == 0); 6361 6362 DPRINTF("Before exiting of the child process\n"); 6363 _exit(exitval); 6364 } 6365 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6366 6367 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6368 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6369 6370 validate_status_stopped(status, sigval); 6371 6372 DPRINTF("Before reading siginfo and lwpid_t\n"); 6373 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6374 6375 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6376 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6377 6378 DPRINTF("Before resuming the child process where it left off and " 6379 "without signal to be sent\n"); 6380 ATF_REQUIRE_ERRNO(EDEADLK, 6381 ptrace(PT_CONTINUE, child, (void *)1, 0) == -1); 6382 6383 DPRINTF("Before resuming LWP %d\n", psi.psi_lwpid); 6384 SYSCALL_REQUIRE(ptrace(PT_RESUME, child, NULL, psi.psi_lwpid) != -1); 6385 6386 DPRINTF("Before resuming the child process where it left off and " 6387 "without signal to be sent\n"); 6388 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6389 6390 DPRINTF("Before calling %s() for the child - expected exited\n", 6391 TWAIT_FNAME); 6392 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6393 6394 validate_status_exited(status, exitval); 6395 6396 DPRINTF("Before calling %s() for the child - expected no process\n", 6397 TWAIT_FNAME); 6398 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6399} 6400 6401ATF_TC(resume1); 6402ATF_TC_HEAD(resume1, tc) 6403{ 6404 atf_tc_set_md_var(tc, "descr", 6405 "Verify that a thread can be suspended by a debugger and later " 6406 "resumed by the debugger"); 6407} 6408 6409ATF_TC_BODY(resume1, tc) 6410{ 6411 struct msg_fds fds; 6412 const int exitval = 5; 6413 const int sigval = SIGSTOP; 6414 pid_t child, wpid; 6415 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 6416#if defined(TWAIT_HAVE_STATUS) 6417 int status; 6418#endif 6419 ucontext_t uc; 6420 lwpid_t lid; 6421 static const size_t ssize = 16*1024; 6422 void *stack; 6423 struct ptrace_lwpinfo pl; 6424 struct ptrace_siginfo psi; 6425 6426 SYSCALL_REQUIRE(msg_open(&fds) == 0); 6427 6428 DPRINTF("Before forking process PID=%d\n", getpid()); 6429 SYSCALL_REQUIRE((child = fork()) != -1); 6430 if (child == 0) { 6431 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6432 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6433 6434 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6435 FORKEE_ASSERT(raise(sigval) == 0); 6436 6437 DPRINTF("Before allocating memory for stack in child\n"); 6438 FORKEE_ASSERT((stack = malloc(ssize)) != NULL); 6439 6440 DPRINTF("Before making context for new lwp in child\n"); 6441 _lwp_makecontext(&uc, lwp_main_stop, NULL, NULL, stack, ssize); 6442 6443 DPRINTF("Before creating new in child\n"); 6444 FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0); 6445 6446 CHILD_TO_PARENT("Message", fds, msg); 6447 6448 raise(SIGINT); 6449 6450 DPRINTF("Before waiting for lwp %d to exit\n", lid); 6451 FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0); 6452 6453 DPRINTF("Before verifying that reported %d and running lid %d " 6454 "are the same\n", lid, the_lwp_id); 6455 FORKEE_ASSERT_EQ(lid, the_lwp_id); 6456 6457 DPRINTF("Before exiting of the child process\n"); 6458 _exit(exitval); 6459 } 6460 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6461 6462 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6463 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6464 6465 validate_status_stopped(status, sigval); 6466 6467 DPRINTF("Before resuming the child process where it left off and " 6468 "without signal to be sent\n"); 6469 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6470 6471 DPRINTF("Before calling %s() for the child - expected stopped " 6472 "SIGTRAP\n", TWAIT_FNAME); 6473 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6474 6475 validate_status_stopped(status, SIGTRAP); 6476 6477 DPRINTF("Before reading siginfo and lwpid_t\n"); 6478 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &psi, sizeof(psi)) != -1); 6479 6480 DPRINTF("Before suspending LWP %d\n", psi.psi_lwpid); 6481 SYSCALL_REQUIRE(ptrace(PT_SUSPEND, child, NULL, psi.psi_lwpid) != -1); 6482 6483 PARENT_FROM_CHILD("Message", fds, msg); 6484 6485 DPRINTF("Before resuming the child process where it left off and " 6486 "without signal to be sent\n"); 6487 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6488 6489 DPRINTF("Before calling %s() for the child - expected stopped " 6490 "SIGINT\n", TWAIT_FNAME); 6491 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6492 6493 validate_status_stopped(status, SIGINT); 6494 6495 pl.pl_lwpid = 0; 6496 6497 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6498 while (pl.pl_lwpid != 0) { 6499 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &pl, sizeof(pl)) != -1); 6500 switch (pl.pl_lwpid) { 6501 case 1: 6502 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SIGNAL); 6503 break; 6504 case 2: 6505 ATF_REQUIRE_EQ(pl.pl_event, PL_EVENT_SUSPENDED); 6506 break; 6507 } 6508 } 6509 6510 DPRINTF("Before resuming LWP %d\n", psi.psi_lwpid); 6511 SYSCALL_REQUIRE(ptrace(PT_RESUME, child, NULL, psi.psi_lwpid) != -1); 6512 6513 DPRINTF("Before resuming the child process where it left off and " 6514 "without signal to be sent\n"); 6515 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6516 6517 DPRINTF("Before calling %s() for the child - expected exited\n", 6518 TWAIT_FNAME); 6519 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6520 6521 validate_status_exited(status, exitval); 6522 6523 DPRINTF("Before calling %s() for the child - expected no process\n", 6524 TWAIT_FNAME); 6525 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6526 6527 msg_close(&fds); 6528} 6529 6530ATF_TC(syscall1); 6531ATF_TC_HEAD(syscall1, tc) 6532{ 6533 atf_tc_set_md_var(tc, "descr", 6534 "Verify that getpid(2) can be traced with PT_SYSCALL"); 6535} 6536 6537ATF_TC_BODY(syscall1, tc) 6538{ 6539 const int exitval = 5; 6540 const int sigval = SIGSTOP; 6541 pid_t child, wpid; 6542#if defined(TWAIT_HAVE_STATUS) 6543 int status; 6544#endif 6545 struct ptrace_siginfo info; 6546 memset(&info, 0, sizeof(info)); 6547 6548 DPRINTF("Before forking process PID=%d\n", getpid()); 6549 SYSCALL_REQUIRE((child = fork()) != -1); 6550 if (child == 0) { 6551 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6552 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6553 6554 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6555 FORKEE_ASSERT(raise(sigval) == 0); 6556 6557 syscall(SYS_getpid); 6558 6559 DPRINTF("Before exiting of the child process\n"); 6560 _exit(exitval); 6561 } 6562 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6563 6564 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6565 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6566 6567 validate_status_stopped(status, sigval); 6568 6569 DPRINTF("Before resuming the child process where it left off and " 6570 "without signal to be sent\n"); 6571 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6572 6573 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6574 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6575 6576 validate_status_stopped(status, SIGTRAP); 6577 6578 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 6579 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 6580 6581 DPRINTF("Before checking siginfo_t and lwpid\n"); 6582 ATF_REQUIRE_EQ(info.psi_lwpid, 1); 6583 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 6584 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_SCE); 6585 6586 DPRINTF("Before resuming the child process where it left off and " 6587 "without signal to be sent\n"); 6588 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6589 6590 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6591 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6592 6593 validate_status_stopped(status, SIGTRAP); 6594 6595 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 6596 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 6597 6598 DPRINTF("Before checking siginfo_t and lwpid\n"); 6599 ATF_REQUIRE_EQ(info.psi_lwpid, 1); 6600 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 6601 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_SCX); 6602 6603 DPRINTF("Before resuming the child process where it left off and " 6604 "without signal to be sent\n"); 6605 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6606 6607 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6608 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6609 6610 validate_status_exited(status, exitval); 6611 6612 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6613 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6614} 6615 6616ATF_TC(syscallemu1); 6617ATF_TC_HEAD(syscallemu1, tc) 6618{ 6619 atf_tc_set_md_var(tc, "descr", 6620 "Verify that exit(2) can be intercepted with PT_SYSCALLEMU"); 6621} 6622 6623ATF_TC_BODY(syscallemu1, tc) 6624{ 6625 const int exitval = 5; 6626 const int sigval = SIGSTOP; 6627 pid_t child, wpid; 6628#if defined(TWAIT_HAVE_STATUS) 6629 int status; 6630#endif 6631 6632#if defined(__sparc__) && !defined(__sparc64__) 6633 /* syscallemu does not work on sparc (32-bit) */ 6634 atf_tc_expect_fail("PR kern/52166"); 6635#endif 6636 6637 DPRINTF("Before forking process PID=%d\n", getpid()); 6638 SYSCALL_REQUIRE((child = fork()) != -1); 6639 if (child == 0) { 6640 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6641 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6642 6643 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6644 FORKEE_ASSERT(raise(sigval) == 0); 6645 6646 syscall(SYS_exit, 100); 6647 6648 DPRINTF("Before exiting of the child process\n"); 6649 _exit(exitval); 6650 } 6651 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6652 6653 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6654 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6655 6656 validate_status_stopped(status, sigval); 6657 6658 DPRINTF("Before resuming the child process where it left off and " 6659 "without signal to be sent\n"); 6660 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6661 6662 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6663 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6664 6665 validate_status_stopped(status, SIGTRAP); 6666 6667 DPRINTF("Set SYSCALLEMU for intercepted syscall\n"); 6668 SYSCALL_REQUIRE(ptrace(PT_SYSCALLEMU, child, (void *)1, 0) != -1); 6669 6670 DPRINTF("Before resuming the child process where it left off and " 6671 "without signal to be sent\n"); 6672 SYSCALL_REQUIRE(ptrace(PT_SYSCALL, child, (void *)1, 0) != -1); 6673 6674 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6675 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6676 6677 validate_status_stopped(status, SIGTRAP); 6678 6679 DPRINTF("Before resuming the child process where it left off and " 6680 "without signal to be sent\n"); 6681 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6682 6683 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6684 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6685 6686 validate_status_exited(status, exitval); 6687 6688 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6689 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6690} 6691 6692/// ---------------------------------------------------------------------------- 6693 6694static void 6695clone_body(int flags, bool trackfork, bool trackvfork, 6696 bool trackvforkdone) 6697{ 6698 const int exitval = 5; 6699 const int exitval2 = 15; 6700 const int sigval = SIGSTOP; 6701 pid_t child, child2 = 0, wpid; 6702#if defined(TWAIT_HAVE_STATUS) 6703 int status; 6704#endif 6705 ptrace_state_t state; 6706 const int slen = sizeof(state); 6707 ptrace_event_t event; 6708 const int elen = sizeof(event); 6709 6710 const size_t stack_size = 1024 * 1024; 6711 void *stack, *stack_base; 6712 6713 stack = malloc(stack_size); 6714 ATF_REQUIRE(stack != NULL); 6715 6716#ifdef __MACHINE_STACK_GROWS_UP 6717 stack_base = stack; 6718#else 6719 stack_base = (char *)stack + stack_size; 6720#endif 6721 6722 DPRINTF("Before forking process PID=%d\n", getpid()); 6723 SYSCALL_REQUIRE((child = fork()) != -1); 6724 if (child == 0) { 6725 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 6726 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 6727 6728 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 6729 FORKEE_ASSERT(raise(sigval) == 0); 6730 6731 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 6732 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 6733 6734 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 6735 child2); 6736 6737 // XXX WALLSIG? 6738 FORKEE_REQUIRE_SUCCESS 6739 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 6740 6741 forkee_status_exited(status, exitval2); 6742 6743 DPRINTF("Before exiting of the child process\n"); 6744 _exit(exitval); 6745 } 6746 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 6747 6748 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 6749 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6750 6751 validate_status_stopped(status, sigval); 6752 6753 DPRINTF("Set 0%s%s%s in EVENT_MASK for the child %d\n", 6754 trackfork ? "|PTRACE_FORK" : "", 6755 trackvfork ? "|PTRACE_VFORK" : "", 6756 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 6757 event.pe_set_event = 0; 6758 if (trackfork) 6759 event.pe_set_event |= PTRACE_FORK; 6760 if (trackvfork) 6761 event.pe_set_event |= PTRACE_VFORK; 6762 if (trackvforkdone) 6763 event.pe_set_event |= PTRACE_VFORK_DONE; 6764 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 6765 6766 DPRINTF("Before resuming the child process where it left off and " 6767 "without signal to be sent\n"); 6768 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6769 6770#if defined(TWAIT_HAVE_PID) 6771 if ((trackfork && !(flags & CLONE_VFORK)) || 6772 (trackvfork && (flags & CLONE_VFORK))) { 6773 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 6774 child); 6775 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 6776 child); 6777 6778 validate_status_stopped(status, SIGTRAP); 6779 6780 SYSCALL_REQUIRE( 6781 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6782 if (trackfork && !(flags & CLONE_VFORK)) { 6783 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 6784 PTRACE_FORK); 6785 } 6786 if (trackvfork && (flags & CLONE_VFORK)) { 6787 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 6788 PTRACE_VFORK); 6789 } 6790 6791 child2 = state.pe_other_pid; 6792 DPRINTF("Reported ptrace event with forkee %d\n", child2); 6793 6794 DPRINTF("Before calling %s() for the forkee %d of the child " 6795 "%d\n", TWAIT_FNAME, child2, child); 6796 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 6797 child2); 6798 6799 validate_status_stopped(status, SIGTRAP); 6800 6801 SYSCALL_REQUIRE( 6802 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 6803 if (trackfork && !(flags & CLONE_VFORK)) { 6804 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 6805 PTRACE_FORK); 6806 } 6807 if (trackvfork && (flags & CLONE_VFORK)) { 6808 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 6809 PTRACE_VFORK); 6810 } 6811 6812 ATF_REQUIRE_EQ(state.pe_other_pid, child); 6813 6814 DPRINTF("Before resuming the forkee process where it left off " 6815 "and without signal to be sent\n"); 6816 SYSCALL_REQUIRE( 6817 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 6818 6819 DPRINTF("Before resuming the child process where it left off " 6820 "and without signal to be sent\n"); 6821 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6822 } 6823#endif 6824 6825 if (trackvforkdone && (flags & CLONE_VFORK)) { 6826 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 6827 child); 6828 TWAIT_REQUIRE_SUCCESS( 6829 wpid = TWAIT_GENERIC(child, &status, 0), child); 6830 6831 validate_status_stopped(status, SIGTRAP); 6832 6833 SYSCALL_REQUIRE( 6834 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 6835 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 6836 6837 child2 = state.pe_other_pid; 6838 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 6839 child2); 6840 6841 DPRINTF("Before resuming the child process where it left off " 6842 "and without signal to be sent\n"); 6843 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6844 } 6845 6846#if defined(TWAIT_HAVE_PID) 6847 if ((trackfork && !(flags & CLONE_VFORK)) || 6848 (trackvfork && (flags & CLONE_VFORK))) { 6849 DPRINTF("Before calling %s() for the forkee - expected exited" 6850 "\n", TWAIT_FNAME); 6851 TWAIT_REQUIRE_SUCCESS( 6852 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 6853 6854 validate_status_exited(status, exitval2); 6855 6856 DPRINTF("Before calling %s() for the forkee - expected no " 6857 "process\n", TWAIT_FNAME); 6858 TWAIT_REQUIRE_FAILURE(ECHILD, 6859 wpid = TWAIT_GENERIC(child2, &status, 0)); 6860 } 6861#endif 6862 6863 DPRINTF("Before calling %s() for the child - expected stopped " 6864 "SIGCHLD\n", TWAIT_FNAME); 6865 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6866 6867 validate_status_stopped(status, SIGCHLD); 6868 6869 DPRINTF("Before resuming the child process where it left off and " 6870 "without signal to be sent\n"); 6871 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 6872 6873 DPRINTF("Before calling %s() for the child - expected exited\n", 6874 TWAIT_FNAME); 6875 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 6876 6877 validate_status_exited(status, exitval); 6878 6879 DPRINTF("Before calling %s() for the child - expected no process\n", 6880 TWAIT_FNAME); 6881 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 6882} 6883 6884#define CLONE_TEST(name,flags,tfork,tvfork,tvforkdone) \ 6885ATF_TC(name); \ 6886ATF_TC_HEAD(name, tc) \ 6887{ \ 6888 atf_tc_set_md_var(tc, "descr", "Verify clone(%s) " \ 6889 "called with 0%s%s%s in EVENT_MASK", \ 6890 #flags, \ 6891 tfork ? "|PTRACE_FORK" : "", \ 6892 tvfork ? "|PTRACE_VFORK" : "", \ 6893 tvforkdone ? "|PTRACE_VFORK_DONE" : ""); \ 6894} \ 6895 \ 6896ATF_TC_BODY(name, tc) \ 6897{ \ 6898 \ 6899 clone_body(flags, tfork, tvfork, tvforkdone); \ 6900} 6901 6902CLONE_TEST(clone1, 0, false, false, false) 6903#if defined(TWAIT_HAVE_PID) 6904CLONE_TEST(clone2, 0, true, false, false) 6905CLONE_TEST(clone3, 0, false, true, false) 6906CLONE_TEST(clone4, 0, true, true, false) 6907#endif 6908CLONE_TEST(clone5, 0, false, false, true) 6909#if defined(TWAIT_HAVE_PID) 6910CLONE_TEST(clone6, 0, true, false, true) 6911CLONE_TEST(clone7, 0, false, true, true) 6912CLONE_TEST(clone8, 0, true, true, true) 6913#endif 6914 6915CLONE_TEST(clone_vm1, CLONE_VM, false, false, false) 6916#if defined(TWAIT_HAVE_PID) 6917CLONE_TEST(clone_vm2, CLONE_VM, true, false, false) 6918CLONE_TEST(clone_vm3, CLONE_VM, false, true, false) 6919CLONE_TEST(clone_vm4, CLONE_VM, true, true, false) 6920#endif 6921CLONE_TEST(clone_vm5, CLONE_VM, false, false, true) 6922#if defined(TWAIT_HAVE_PID) 6923CLONE_TEST(clone_vm6, CLONE_VM, true, false, true) 6924CLONE_TEST(clone_vm7, CLONE_VM, false, true, true) 6925CLONE_TEST(clone_vm8, CLONE_VM, true, true, true) 6926#endif 6927 6928CLONE_TEST(clone_fs1, CLONE_FS, false, false, false) 6929#if defined(TWAIT_HAVE_PID) 6930CLONE_TEST(clone_fs2, CLONE_FS, true, false, false) 6931CLONE_TEST(clone_fs3, CLONE_FS, false, true, false) 6932CLONE_TEST(clone_fs4, CLONE_FS, true, true, false) 6933#endif 6934CLONE_TEST(clone_fs5, CLONE_FS, false, false, true) 6935#if defined(TWAIT_HAVE_PID) 6936CLONE_TEST(clone_fs6, CLONE_FS, true, false, true) 6937CLONE_TEST(clone_fs7, CLONE_FS, false, true, true) 6938CLONE_TEST(clone_fs8, CLONE_FS, true, true, true) 6939#endif 6940 6941CLONE_TEST(clone_files1, CLONE_FILES, false, false, false) 6942#if defined(TWAIT_HAVE_PID) 6943CLONE_TEST(clone_files2, CLONE_FILES, true, false, false) 6944CLONE_TEST(clone_files3, CLONE_FILES, false, true, false) 6945CLONE_TEST(clone_files4, CLONE_FILES, true, true, false) 6946#endif 6947CLONE_TEST(clone_files5, CLONE_FILES, false, false, true) 6948#if defined(TWAIT_HAVE_PID) 6949CLONE_TEST(clone_files6, CLONE_FILES, true, false, true) 6950CLONE_TEST(clone_files7, CLONE_FILES, false, true, true) 6951CLONE_TEST(clone_files8, CLONE_FILES, true, true, true) 6952#endif 6953 6954//CLONE_TEST(clone_sighand1, CLONE_SIGHAND, false, false, false) 6955#if defined(TWAIT_HAVE_PID) 6956//CLONE_TEST(clone_sighand2, CLONE_SIGHAND, true, false, false) 6957//CLONE_TEST(clone_sighand3, CLONE_SIGHAND, false, true, false) 6958//CLONE_TEST(clone_sighand4, CLONE_SIGHAND, true, true, false) 6959#endif 6960//CLONE_TEST(clone_sighand5, CLONE_SIGHAND, false, false, true) 6961#if defined(TWAIT_HAVE_PID) 6962//CLONE_TEST(clone_sighand6, CLONE_SIGHAND, true, false, true) 6963//CLONE_TEST(clone_sighand7, CLONE_SIGHAND, false, true, true) 6964//CLONE_TEST(clone_sighand8, CLONE_SIGHAND, true, true, true) 6965#endif 6966 6967#if TEST_VFORK_ENABLED 6968CLONE_TEST(clone_vfork1, CLONE_VFORK, false, false, false) 6969#if defined(TWAIT_HAVE_PID) 6970CLONE_TEST(clone_vfork2, CLONE_VFORK, true, false, false) 6971CLONE_TEST(clone_vfork3, CLONE_VFORK, false, true, false) 6972CLONE_TEST(clone_vfork4, CLONE_VFORK, true, true, false) 6973#endif 6974CLONE_TEST(clone_vfork5, CLONE_VFORK, false, false, true) 6975#if defined(TWAIT_HAVE_PID) 6976CLONE_TEST(clone_vfork6, CLONE_VFORK, true, false, true) 6977CLONE_TEST(clone_vfork7, CLONE_VFORK, false, true, true) 6978CLONE_TEST(clone_vfork8, CLONE_VFORK, true, true, true) 6979#endif 6980#endif 6981 6982/// ---------------------------------------------------------------------------- 6983 6984#if defined(TWAIT_HAVE_PID) 6985static void 6986clone_body2(int flags, bool masked, bool ignored) 6987{ 6988 const int exitval = 5; 6989 const int exitval2 = 15; 6990 const int sigval = SIGSTOP; 6991 pid_t child, child2 = 0, wpid; 6992#if defined(TWAIT_HAVE_STATUS) 6993 int status; 6994#endif 6995 ptrace_state_t state; 6996 const int slen = sizeof(state); 6997 ptrace_event_t event; 6998 const int elen = sizeof(event); 6999 struct sigaction sa; 7000 struct ptrace_siginfo info; 7001 sigset_t intmask; 7002 struct kinfo_proc2 kp; 7003 size_t len = sizeof(kp); 7004 7005 int name[6]; 7006 const size_t namelen = __arraycount(name); 7007 ki_sigset_t kp_sigmask; 7008 ki_sigset_t kp_sigignore; 7009 7010 const size_t stack_size = 1024 * 1024; 7011 void *stack, *stack_base; 7012 7013 stack = malloc(stack_size); 7014 ATF_REQUIRE(stack != NULL); 7015 7016#ifdef __MACHINE_STACK_GROWS_UP 7017 stack_base = stack; 7018#else 7019 stack_base = (char *)stack + stack_size; 7020#endif 7021 7022 SYSCALL_REQUIRE((child = fork()) != -1); 7023 if (child == 0) { 7024 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 7025 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 7026 7027 if (masked) { 7028 sigemptyset(&intmask); 7029 sigaddset(&intmask, SIGTRAP); 7030 sigprocmask(SIG_BLOCK, &intmask, NULL); 7031 } 7032 7033 if (ignored) { 7034 memset(&sa, 0, sizeof(sa)); 7035 sa.sa_handler = SIG_IGN; 7036 sigemptyset(&sa.sa_mask); 7037 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 7038 } 7039 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 7040 FORKEE_ASSERT(raise(sigval) == 0); 7041 7042 DPRINTF("Before forking process PID=%d flags=%#x\n", getpid(), 7043 flags); 7044 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 7045 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 7046 7047 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 7048 child2); 7049 7050 // XXX WALLSIG? 7051 FORKEE_REQUIRE_SUCCESS 7052 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 7053 7054 forkee_status_exited(status, exitval2); 7055 7056 DPRINTF("Before exiting of the child process\n"); 7057 _exit(exitval); 7058 } 7059 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 7060 7061 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 7062 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7063 7064 validate_status_stopped(status, sigval); 7065 7066 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 7067 SYSCALL_REQUIRE( 7068 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 7069 7070 DPRINTF("Before checking siginfo_t\n"); 7071 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 7072 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 7073 7074 name[0] = CTL_KERN, 7075 name[1] = KERN_PROC2, 7076 name[2] = KERN_PROC_PID; 7077 name[3] = child; 7078 name[4] = sizeof(kp); 7079 name[5] = 1; 7080 7081 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7082 7083 if (masked) 7084 kp_sigmask = kp.p_sigmask; 7085 7086 if (ignored) 7087 kp_sigignore = kp.p_sigignore; 7088 7089 DPRINTF("Set PTRACE_FORK | PTRACE_VFORK | PTRACE_VFORK_DONE in " 7090 "EVENT_MASK for the child %d\n", child); 7091 event.pe_set_event = PTRACE_FORK | PTRACE_VFORK | PTRACE_VFORK_DONE; 7092 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 7093 7094 DPRINTF("Before resuming the child process where it left off and " 7095 "without signal to be sent\n"); 7096 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7097 7098 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 7099 child); 7100 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 7101 child); 7102 7103 validate_status_stopped(status, SIGTRAP); 7104 7105 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7106 7107 if (masked) { 7108 DPRINTF("kp_sigmask=" 7109 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7110 PRIx32 "\n", 7111 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7112 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7113 7114 DPRINTF("kp.p_sigmask=" 7115 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7116 PRIx32 "\n", 7117 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7118 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7119 7120 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7121 sizeof(kp_sigmask))); 7122 } 7123 7124 if (ignored) { 7125 DPRINTF("kp_sigignore=" 7126 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7127 PRIx32 "\n", 7128 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7129 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7130 7131 DPRINTF("kp.p_sigignore=" 7132 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7133 PRIx32 "\n", 7134 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7135 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7136 7137 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7138 sizeof(kp_sigignore))); 7139 } 7140 7141 SYSCALL_REQUIRE( 7142 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 7143 DPRINTF("state.pe_report_event=%#x pid=%d\n", state.pe_report_event, 7144 child2); 7145 if (!(flags & CLONE_VFORK)) { 7146 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 7147 PTRACE_FORK); 7148 } else { 7149 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 7150 PTRACE_VFORK); 7151 } 7152 7153 child2 = state.pe_other_pid; 7154 DPRINTF("Reported ptrace event with forkee %d\n", child2); 7155 7156 DPRINTF("Before calling %s() for the forkee %d of the child " 7157 "%d\n", TWAIT_FNAME, child2, child); 7158 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 7159 child2); 7160 7161 validate_status_stopped(status, SIGTRAP); 7162 7163 name[3] = child2; 7164 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7165 7166 if (masked) { 7167 DPRINTF("kp_sigmask=" 7168 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7169 PRIx32 "\n", 7170 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7171 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7172 7173 DPRINTF("kp.p_sigmask=" 7174 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7175 PRIx32 "\n", 7176 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7177 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7178 7179 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7180 sizeof(kp_sigmask))); 7181 } 7182 7183 if (ignored) { 7184 DPRINTF("kp_sigignore=" 7185 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7186 PRIx32 "\n", 7187 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7188 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7189 7190 DPRINTF("kp.p_sigignore=" 7191 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7192 PRIx32 "\n", 7193 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7194 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7195 7196 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7197 sizeof(kp_sigignore))); 7198 } 7199 7200 SYSCALL_REQUIRE( 7201 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 7202 if (!(flags & CLONE_VFORK)) { 7203 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 7204 PTRACE_FORK); 7205 } else { 7206 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 7207 PTRACE_VFORK); 7208 } 7209 7210 ATF_REQUIRE_EQ(state.pe_other_pid, child); 7211 7212 DPRINTF("Before resuming the forkee process where it left off " 7213 "and without signal to be sent\n"); 7214 SYSCALL_REQUIRE( 7215 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 7216 7217 DPRINTF("Before resuming the child process where it left off " 7218 "and without signal to be sent\n"); 7219 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7220 7221 if (flags & CLONE_VFORK) { 7222 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 7223 child); 7224 TWAIT_REQUIRE_SUCCESS( 7225 wpid = TWAIT_GENERIC(child, &status, 0), child); 7226 7227 validate_status_stopped(status, SIGTRAP); 7228 7229 name[3] = child; 7230 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 7231 7232 /* 7233 * SIGCHLD is now pending in the signal queue and 7234 * the kernel presents it to userland as a masked signal. 7235 */ 7236 sigdelset((sigset_t *)&kp.p_sigmask, SIGCHLD); 7237 7238 if (masked) { 7239 DPRINTF("kp_sigmask=" 7240 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7241 PRIx32 "\n", 7242 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 7243 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 7244 7245 DPRINTF("kp.p_sigmask=" 7246 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7247 PRIx32 "\n", 7248 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 7249 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 7250 7251 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 7252 sizeof(kp_sigmask))); 7253 } 7254 7255 if (ignored) { 7256 DPRINTF("kp_sigignore=" 7257 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7258 PRIx32 "\n", 7259 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 7260 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 7261 7262 DPRINTF("kp.p_sigignore=" 7263 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 7264 PRIx32 "\n", 7265 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 7266 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 7267 7268 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 7269 sizeof(kp_sigignore))); 7270 } 7271 7272 SYSCALL_REQUIRE( 7273 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 7274 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 7275 7276 child2 = state.pe_other_pid; 7277 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 7278 child2); 7279 7280 DPRINTF("Before resuming the child process where it left off " 7281 "and without signal to be sent\n"); 7282 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7283 } 7284 7285 DPRINTF("Before calling %s() for the forkee - expected exited" 7286 "\n", TWAIT_FNAME); 7287 TWAIT_REQUIRE_SUCCESS( 7288 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 7289 7290 validate_status_exited(status, exitval2); 7291 7292 DPRINTF("Before calling %s() for the forkee - expected no " 7293 "process\n", TWAIT_FNAME); 7294 TWAIT_REQUIRE_FAILURE(ECHILD, 7295 wpid = TWAIT_GENERIC(child2, &status, 0)); 7296 7297 DPRINTF("Before calling %s() for the child - expected stopped " 7298 "SIGCHLD\n", TWAIT_FNAME); 7299 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7300 7301 validate_status_stopped(status, SIGCHLD); 7302 7303 DPRINTF("Before resuming the child process where it left off and " 7304 "without signal to be sent\n"); 7305 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7306 7307 DPRINTF("Before calling %s() for the child - expected exited\n", 7308 TWAIT_FNAME); 7309 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7310 7311 validate_status_exited(status, exitval); 7312 7313 DPRINTF("Before calling %s() for the child - expected no process\n", 7314 TWAIT_FNAME); 7315 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 7316} 7317 7318#define CLONE_TEST2(name,flags,masked,ignored) \ 7319ATF_TC(name); \ 7320ATF_TC_HEAD(name, tc) \ 7321{ \ 7322 atf_tc_set_md_var(tc, "descr", "Verify that clone(%s) is caught"\ 7323 " regardless of signal %s%s", \ 7324 #flags, masked ? "masked" : "", ignored ? "ignored" : ""); \ 7325} \ 7326 \ 7327ATF_TC_BODY(name, tc) \ 7328{ \ 7329 \ 7330 clone_body2(flags, masked, ignored); \ 7331} 7332 7333CLONE_TEST2(clone_signalignored, 0, true, false) 7334CLONE_TEST2(clone_signalmasked, 0, false, true) 7335CLONE_TEST2(clone_vm_signalignored, CLONE_VM, true, false) 7336CLONE_TEST2(clone_vm_signalmasked, CLONE_VM, false, true) 7337CLONE_TEST2(clone_fs_signalignored, CLONE_FS, true, false) 7338CLONE_TEST2(clone_fs_signalmasked, CLONE_FS, false, true) 7339CLONE_TEST2(clone_files_signalignored, CLONE_FILES, true, false) 7340CLONE_TEST2(clone_files_signalmasked, CLONE_FILES, false, true) 7341//CLONE_TEST2(clone_sighand_signalignored, CLONE_SIGHAND, true, false) // XXX 7342//CLONE_TEST2(clone_sighand_signalmasked, CLONE_SIGHAND, false, true) // XXX 7343#if TEST_VFORK_ENABLED 7344CLONE_TEST2(clone_vfork_signalignored, CLONE_VFORK, true, false) 7345CLONE_TEST2(clone_vfork_signalmasked, CLONE_VFORK, false, true) 7346#endif 7347#endif 7348 7349/// ---------------------------------------------------------------------------- 7350 7351#if TEST_VFORK_ENABLED 7352#if defined(TWAIT_HAVE_PID) 7353static void 7354traceme_vfork_clone_body(int flags) 7355{ 7356 const int exitval = 5; 7357 const int exitval2 = 15; 7358 pid_t child, child2 = 0, wpid; 7359#if defined(TWAIT_HAVE_STATUS) 7360 int status; 7361#endif 7362 7363 const size_t stack_size = 1024 * 1024; 7364 void *stack, *stack_base; 7365 7366 stack = malloc(stack_size); 7367 ATF_REQUIRE(stack != NULL); 7368 7369#ifdef __MACHINE_STACK_GROWS_UP 7370 stack_base = stack; 7371#else 7372 stack_base = (char *)stack + stack_size; 7373#endif 7374 7375 SYSCALL_REQUIRE((child = vfork()) != -1); 7376 if (child == 0) { 7377 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 7378 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 7379 7380 DPRINTF("Before forking process PID=%d flags=%#x\n", getpid(), 7381 flags); 7382 SYSCALL_REQUIRE((child2 = __clone(clone_func, stack_base, 7383 flags|SIGCHLD, (void *)(intptr_t)exitval2)) != -1); 7384 7385 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), 7386 child2); 7387 7388 // XXX WALLSIG? 7389 FORKEE_REQUIRE_SUCCESS 7390 (wpid = TWAIT_GENERIC(child2, &status, WALLSIG), child2); 7391 7392 forkee_status_exited(status, exitval2); 7393 7394 DPRINTF("Before exiting of the child process\n"); 7395 _exit(exitval); 7396 } 7397 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 7398 7399 DPRINTF("Before calling %s() for the child - expected exited\n", 7400 TWAIT_FNAME); 7401 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7402 7403 validate_status_exited(status, exitval); 7404 7405 DPRINTF("Before calling %s() for the child - expected no process\n", 7406 TWAIT_FNAME); 7407 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 7408} 7409 7410#define TRACEME_VFORK_CLONE_TEST(name,flags) \ 7411ATF_TC(name); \ 7412ATF_TC_HEAD(name, tc) \ 7413{ \ 7414 atf_tc_set_md_var(tc, "descr", "Verify that clone(%s) is " \ 7415 "handled correctly with vfork(2)ed tracer", \ 7416 #flags); \ 7417} \ 7418 \ 7419ATF_TC_BODY(name, tc) \ 7420{ \ 7421 \ 7422 traceme_vfork_clone_body(flags); \ 7423} 7424 7425TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone, 0) 7426TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_vm, CLONE_VM) 7427TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_fs, CLONE_FS) 7428TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_files, CLONE_FILES) 7429//TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_sighand, CLONE_SIGHAND) // XXX 7430TRACEME_VFORK_CLONE_TEST(traceme_vfork_clone_vfork, CLONE_VFORK) 7431#endif 7432#endif 7433 7434/// ---------------------------------------------------------------------------- 7435 7436#include "t_ptrace_amd64_wait.h" 7437#include "t_ptrace_i386_wait.h" 7438#include "t_ptrace_x86_wait.h" 7439 7440ATF_TP_ADD_TCS(tp) 7441{ 7442 setvbuf(stdout, NULL, _IONBF, 0); 7443 setvbuf(stderr, NULL, _IONBF, 0); 7444 7445 ATF_TP_ADD_TC(tp, traceme_raise1); 7446 ATF_TP_ADD_TC(tp, traceme_raise2); 7447 ATF_TP_ADD_TC(tp, traceme_raise3); 7448 ATF_TP_ADD_TC(tp, traceme_raise4); 7449 ATF_TP_ADD_TC(tp, traceme_raise5); 7450 ATF_TP_ADD_TC(tp, traceme_raise6); 7451 ATF_TP_ADD_TC(tp, traceme_raise7); 7452 ATF_TP_ADD_TC(tp, traceme_raise8); 7453 ATF_TP_ADD_TC(tp, traceme_raise9); 7454 ATF_TP_ADD_TC(tp, traceme_raise10); 7455 7456 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored1); 7457 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored2); 7458 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored3); 7459 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored4); 7460 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored5); 7461 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored6); 7462 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored7); 7463 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored8); 7464 7465 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked1); 7466 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked2); 7467 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked3); 7468 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked4); 7469 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked5); 7470 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked6); 7471 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked7); 7472 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked8); 7473 7474 ATF_TP_ADD_TC(tp, traceme_crash_trap); 7475 ATF_TP_ADD_TC(tp, traceme_crash_segv); 7476 ATF_TP_ADD_TC(tp, traceme_crash_ill); 7477 ATF_TP_ADD_TC(tp, traceme_crash_fpe); 7478 ATF_TP_ADD_TC(tp, traceme_crash_bus); 7479 7480 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_trap); 7481 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_segv); 7482 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_ill); 7483 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_fpe); 7484 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_bus); 7485 7486 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_trap); 7487 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_segv); 7488 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_ill); 7489 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_fpe); 7490 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_bus); 7491 7492 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle1); 7493 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle2); 7494 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle3); 7495 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle4); 7496 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle5); 7497 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle6); 7498 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle7); 7499 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle8); 7500 7501 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked1); 7502 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked2); 7503 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked3); 7504 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked4); 7505 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked5); 7506 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked6); 7507 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked7); 7508 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked8); 7509 7510 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored1); 7511 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored2); 7512 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored3); 7513 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored4); 7514 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored5); 7515 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored6); 7516 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored7); 7517 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored8); 7518 7519 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple1); 7520 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple2); 7521 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple3); 7522 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple4); 7523 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple5); 7524 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple6); 7525 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple7); 7526 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple8); 7527 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple9); 7528 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple10); 7529 7530 ATF_TP_ADD_TC(tp, traceme_pid1_parent); 7531 7532 ATF_TP_ADD_TC(tp, traceme_vfork_raise1); 7533 ATF_TP_ADD_TC(tp, traceme_vfork_raise2); 7534 ATF_TP_ADD_TC(tp, traceme_vfork_raise3); 7535 ATF_TP_ADD_TC(tp, traceme_vfork_raise4); 7536 ATF_TP_ADD_TC(tp, traceme_vfork_raise5); 7537 ATF_TP_ADD_TC(tp, traceme_vfork_raise6); 7538 ATF_TP_ADD_TC(tp, traceme_vfork_raise7); 7539 ATF_TP_ADD_TC(tp, traceme_vfork_raise8); 7540 ATF_TP_ADD_TC(tp, traceme_vfork_raise9); 7541 ATF_TP_ADD_TC(tp, traceme_vfork_raise10); 7542 ATF_TP_ADD_TC(tp, traceme_vfork_raise11); 7543 ATF_TP_ADD_TC(tp, traceme_vfork_raise12); 7544 ATF_TP_ADD_TC(tp, traceme_vfork_raise13); 7545 7546 ATF_TP_ADD_TC(tp, traceme_vfork_crash_trap); 7547 ATF_TP_ADD_TC(tp, traceme_vfork_crash_segv); 7548 ATF_TP_ADD_TC(tp, traceme_vfork_crash_ill); 7549 ATF_TP_ADD_TC(tp, traceme_vfork_crash_fpe); 7550 ATF_TP_ADD_TC(tp, traceme_vfork_crash_bus); 7551 7552 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_trap); 7553 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_segv); 7554 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_ill); 7555 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_fpe); 7556 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_bus); 7557 7558 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_trap); 7559 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_segv); 7560 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_ill); 7561 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_fpe); 7562 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_bus); 7563 7564 ATF_TP_ADD_TC(tp, traceme_vfork_exec); 7565 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_exec); 7566 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_exec); 7567 7568 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_trap); 7569 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_segv); 7570 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_ill); 7571 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_fpe); 7572 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_bus); 7573 7574 ATF_TP_ADD_TC_HAVE_PID(tp, 7575 unrelated_tracer_sees_signalmasked_crash_trap); 7576 ATF_TP_ADD_TC_HAVE_PID(tp, 7577 unrelated_tracer_sees_signalmasked_crash_segv); 7578 ATF_TP_ADD_TC_HAVE_PID(tp, 7579 unrelated_tracer_sees_signalmasked_crash_ill); 7580 ATF_TP_ADD_TC_HAVE_PID(tp, 7581 unrelated_tracer_sees_signalmasked_crash_fpe); 7582 ATF_TP_ADD_TC_HAVE_PID(tp, 7583 unrelated_tracer_sees_signalmasked_crash_bus); 7584 7585 ATF_TP_ADD_TC_HAVE_PID(tp, 7586 unrelated_tracer_sees_signalignored_crash_trap); 7587 ATF_TP_ADD_TC_HAVE_PID(tp, 7588 unrelated_tracer_sees_signalignored_crash_segv); 7589 ATF_TP_ADD_TC_HAVE_PID(tp, 7590 unrelated_tracer_sees_signalignored_crash_ill); 7591 ATF_TP_ADD_TC_HAVE_PID(tp, 7592 unrelated_tracer_sees_signalignored_crash_fpe); 7593 ATF_TP_ADD_TC_HAVE_PID(tp, 7594 unrelated_tracer_sees_signalignored_crash_bus); 7595 7596 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sees_terminaton_before_the_parent); 7597 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sysctl_lookup_without_duplicates); 7598 ATF_TP_ADD_TC_HAVE_PID(tp, 7599 unrelated_tracer_sees_terminaton_before_the_parent); 7600 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_attach_to_unrelated_stopped_process); 7601 7602 ATF_TP_ADD_TC(tp, parent_attach_to_its_child); 7603 ATF_TP_ADD_TC(tp, parent_attach_to_its_stopped_child); 7604 7605 ATF_TP_ADD_TC(tp, child_attach_to_its_parent); 7606 ATF_TP_ADD_TC(tp, child_attach_to_its_stopped_parent); 7607 7608 ATF_TP_ADD_TC_HAVE_PID(tp, 7609 tracee_sees_its_original_parent_getppid); 7610 ATF_TP_ADD_TC_HAVE_PID(tp, 7611 tracee_sees_its_original_parent_sysctl_kinfo_proc2); 7612 ATF_TP_ADD_TC_HAVE_PID(tp, 7613 tracee_sees_its_original_parent_procfs_status); 7614 7615 ATF_TP_ADD_TC(tp, eventmask_preserved_empty); 7616 ATF_TP_ADD_TC(tp, eventmask_preserved_fork); 7617 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork); 7618 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork_done); 7619 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_create); 7620 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_exit); 7621 7622 ATF_TP_ADD_TC(tp, fork1); 7623 ATF_TP_ADD_TC_HAVE_PID(tp, fork2); 7624 ATF_TP_ADD_TC_HAVE_PID(tp, fork3); 7625 ATF_TP_ADD_TC_HAVE_PID(tp, fork4); 7626 ATF_TP_ADD_TC(tp, fork5); 7627 ATF_TP_ADD_TC_HAVE_PID(tp, fork6); 7628 ATF_TP_ADD_TC_HAVE_PID(tp, fork7); 7629 ATF_TP_ADD_TC_HAVE_PID(tp, fork8); 7630 7631#if TEST_VFORK_ENABLED 7632 ATF_TP_ADD_TC(tp, vfork1); 7633 ATF_TP_ADD_TC_HAVE_PID(tp, vfork2); 7634 ATF_TP_ADD_TC_HAVE_PID(tp, vfork3); 7635 ATF_TP_ADD_TC_HAVE_PID(tp, vfork4); 7636 ATF_TP_ADD_TC(tp, vfork5); 7637 ATF_TP_ADD_TC_HAVE_PID(tp, vfork6); 7638 ATF_TP_ADD_TC_HAVE_PID(tp, vfork7); 7639 ATF_TP_ADD_TC_HAVE_PID(tp, vfork8); 7640#endif 7641 7642 ATF_TP_ADD_TC_HAVE_PID(tp, fork_detach_forker); 7643#if TEST_VFORK_ENABLED 7644 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforker); 7645 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforkerdone); 7646#endif 7647 ATF_TP_ADD_TC_HAVE_PID(tp, fork_kill_forker); 7648#if TEST_VFORK_ENABLED 7649 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforker); 7650 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforkerdone); 7651#endif 7652 7653#if TEST_VFORK_ENABLED 7654 ATF_TP_ADD_TC(tp, traceme_vfork_fork); 7655 ATF_TP_ADD_TC(tp, traceme_vfork_vfork); 7656#endif 7657 7658 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8); 7659 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16); 7660 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32); 7661 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64); 7662 7663 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8); 7664 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16); 7665 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32); 7666 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64); 7667 7668 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8); 7669 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16); 7670 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32); 7671 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64); 7672 7673 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8); 7674 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16); 7675 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32); 7676 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64); 7677 7678 ATF_TP_ADD_TC(tp, bytes_transfer_read_d); 7679 ATF_TP_ADD_TC(tp, bytes_transfer_read_i); 7680 ATF_TP_ADD_TC(tp, bytes_transfer_write_d); 7681 ATF_TP_ADD_TC(tp, bytes_transfer_write_i); 7682 7683 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8_text); 7684 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16_text); 7685 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32_text); 7686 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64_text); 7687 7688 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8_text); 7689 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16_text); 7690 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32_text); 7691 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64_text); 7692 7693 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8_text); 7694 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16_text); 7695 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32_text); 7696 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64_text); 7697 7698 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8_text); 7699 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16_text); 7700 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32_text); 7701 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64_text); 7702 7703 ATF_TP_ADD_TC(tp, bytes_transfer_read_d_text); 7704 ATF_TP_ADD_TC(tp, bytes_transfer_read_i_text); 7705 ATF_TP_ADD_TC(tp, bytes_transfer_write_d_text); 7706 ATF_TP_ADD_TC(tp, bytes_transfer_write_i_text); 7707 7708 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_auxv); 7709 7710 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_i); 7711 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_d); 7712 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_i); 7713 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_d); 7714 7715 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_i); 7716 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_d); 7717 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_i); 7718 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_d); 7719 7720 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_auxv); 7721 7722 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_i); 7723 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_d); 7724 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_i); 7725 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_d); 7726 7727 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_i); 7728 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_d); 7729 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_i); 7730 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_d); 7731 7732 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs1); 7733 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs2); 7734 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs3); 7735 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs4); 7736 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs5); 7737 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs6); 7738 7739 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs1); 7740 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs2); 7741 7742 ATF_TP_ADD_TC_PT_STEP(tp, step1); 7743 ATF_TP_ADD_TC_PT_STEP(tp, step2); 7744 ATF_TP_ADD_TC_PT_STEP(tp, step3); 7745 ATF_TP_ADD_TC_PT_STEP(tp, step4); 7746 7747 ATF_TP_ADD_TC_PT_STEP(tp, setstep1); 7748 ATF_TP_ADD_TC_PT_STEP(tp, setstep2); 7749 ATF_TP_ADD_TC_PT_STEP(tp, setstep3); 7750 ATF_TP_ADD_TC_PT_STEP(tp, setstep4); 7751 7752 ATF_TP_ADD_TC_PT_STEP(tp, step_signalmasked); 7753 ATF_TP_ADD_TC_PT_STEP(tp, step_signalignored); 7754 7755 ATF_TP_ADD_TC(tp, kill1); 7756 ATF_TP_ADD_TC(tp, kill2); 7757 ATF_TP_ADD_TC(tp, kill3); 7758 7759 ATF_TP_ADD_TC(tp, traceme_lwpinfo0); 7760 ATF_TP_ADD_TC(tp, traceme_lwpinfo1); 7761 ATF_TP_ADD_TC(tp, traceme_lwpinfo2); 7762 ATF_TP_ADD_TC(tp, traceme_lwpinfo3); 7763 7764 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo0); 7765 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo1); 7766 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo2); 7767 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo3); 7768 7769 ATF_TP_ADD_TC(tp, siginfo_set_unmodified); 7770 ATF_TP_ADD_TC(tp, siginfo_set_faked); 7771 7772 ATF_TP_ADD_TC(tp, traceme_exec); 7773 ATF_TP_ADD_TC(tp, traceme_signalmasked_exec); 7774 ATF_TP_ADD_TC(tp, traceme_signalignored_exec); 7775 7776 ATF_TP_ADD_TC(tp, trace_thread_nolwpevents); 7777 ATF_TP_ADD_TC(tp, trace_thread_lwpexit); 7778 ATF_TP_ADD_TC(tp, trace_thread_lwpcreate); 7779 ATF_TP_ADD_TC(tp, trace_thread_lwpcreate_and_exit); 7780 7781 ATF_TP_ADD_TC(tp, signal_mask_unrelated); 7782 7783 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalmasked); 7784 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalignored); 7785#if TEST_VFORK_ENABLED 7786 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalmasked); 7787 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalignored); 7788 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalmasked); 7789 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalignored); 7790#endif 7791 7792 ATF_TP_ADD_TC(tp, signal9); 7793 ATF_TP_ADD_TC(tp, signal10); 7794 7795 ATF_TP_ADD_TC(tp, suspend1); 7796 ATF_TP_ADD_TC(tp, suspend2); 7797 7798 ATF_TP_ADD_TC(tp, resume1); 7799 7800 ATF_TP_ADD_TC(tp, syscall1); 7801 7802 ATF_TP_ADD_TC(tp, syscallemu1); 7803 7804 ATF_TP_ADD_TC(tp, clone1); 7805 ATF_TP_ADD_TC_HAVE_PID(tp, clone2); 7806 ATF_TP_ADD_TC_HAVE_PID(tp, clone3); 7807 ATF_TP_ADD_TC_HAVE_PID(tp, clone4); 7808 ATF_TP_ADD_TC(tp, clone5); 7809 ATF_TP_ADD_TC_HAVE_PID(tp, clone6); 7810 ATF_TP_ADD_TC_HAVE_PID(tp, clone7); 7811 ATF_TP_ADD_TC_HAVE_PID(tp, clone8); 7812 7813 ATF_TP_ADD_TC(tp, clone_vm1); 7814 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm2); 7815 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm3); 7816 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm4); 7817 ATF_TP_ADD_TC(tp, clone_vm5); 7818 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm6); 7819 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm7); 7820 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm8); 7821 7822 ATF_TP_ADD_TC(tp, clone_fs1); 7823 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs2); 7824 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs3); 7825 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs4); 7826 ATF_TP_ADD_TC(tp, clone_fs5); 7827 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs6); 7828 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs7); 7829 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs8); 7830 7831 ATF_TP_ADD_TC(tp, clone_files1); 7832 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files2); 7833 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files3); 7834 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files4); 7835 ATF_TP_ADD_TC(tp, clone_files5); 7836 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files6); 7837 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files7); 7838 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files8); 7839 7840// ATF_TP_ADD_TC(tp, clone_sighand1); // XXX 7841// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand2); // XXX 7842// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand3); // XXX 7843// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand4); // XXX 7844// ATF_TP_ADD_TC(tp, clone_sighand5); // XXX 7845// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand6); // XXX 7846// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand7); // XXX 7847// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand8); // XXX 7848 7849#if TEST_VFORK_ENABLED 7850 ATF_TP_ADD_TC(tp, clone_vfork1); 7851 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork2); 7852 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork3); 7853 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork4); 7854 ATF_TP_ADD_TC(tp, clone_vfork5); 7855 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork6); 7856 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork7); 7857 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork8); 7858#endif 7859 7860 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalignored); 7861 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalmasked); 7862 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalignored); 7863 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalmasked); 7864 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalignored); 7865 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalmasked); 7866 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalignored); 7867 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalmasked); 7868// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalignored); // XXX 7869// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalmasked); // XXX 7870#if TEST_VFORK_ENABLED 7871 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalignored); 7872 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalmasked); 7873#endif 7874 7875#if TEST_VFORK_ENABLED 7876 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone); 7877 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vm); 7878 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_fs); 7879 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_files); 7880// ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_sighand); // XXX 7881 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vfork); 7882#endif 7883 7884 ATF_TP_ADD_TCS_PTRACE_WAIT_AMD64(); 7885 ATF_TP_ADD_TCS_PTRACE_WAIT_I386(); 7886 ATF_TP_ADD_TCS_PTRACE_WAIT_X86(); 7887 7888 return atf_no_error(); 7889} 7890