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