t_ptrace_wait.c revision 1.140
1/* $NetBSD: t_ptrace_wait.c,v 1.140 2019/10/21 18:36:08 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.140 2019/10/21 18:36:08 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() %s:%d " a, __func__, __FILE__, __LINE__, ##__VA_ARGS__); \ 122 while (/*CONSTCOND*/0) 123 124/// ---------------------------------------------------------------------------- 125 126static void 127traceme_raise(int sigval) 128{ 129 const int exitval = 5; 130 pid_t child, wpid; 131#if defined(TWAIT_HAVE_STATUS) 132 int status; 133#endif 134 135 ptrace_state_t state, zero_state; 136 const int slen = sizeof(state); 137 struct ptrace_siginfo info; 138 memset(&zero_state, 0, sizeof(zero_state)); 139 memset(&info, 0, sizeof(info)); 140 141 DPRINTF("Before forking process PID=%d\n", getpid()); 142 SYSCALL_REQUIRE((child = fork()) != -1); 143 if (child == 0) { 144 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 145 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 146 147 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 148 FORKEE_ASSERT(raise(sigval) == 0); 149 150 switch (sigval) { 151 case SIGKILL: 152 /* NOTREACHED */ 153 FORKEE_ASSERTX(0 && "This shall not be reached"); 154 __unreachable(); 155 default: 156 DPRINTF("Before exiting of the child process\n"); 157 _exit(exitval); 158 } 159 } 160 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 161 162 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 163 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 164 165 switch (sigval) { 166 case SIGKILL: 167 validate_status_signaled(status, sigval, 0); 168 SYSCALL_REQUIRE( 169 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) == -1); 170 171 break; 172 default: 173 validate_status_stopped(status, sigval); 174 175 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 176 "child\n"); 177 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 178 sizeof(info)) != -1); 179 180 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 181 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 182 "si_errno=%#x\n", 183 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 184 info.psi_siginfo.si_errno); 185 186 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 187 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 188 189 DPRINTF("Assert that PT_GET_PROCESS_STATE returns non-error"); 190 SYSCALL_REQUIRE( 191 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 192 ATF_REQUIRE(memcmp(&state, &zero_state, slen) == 0); 193 194 DPRINTF("Before resuming the child process where it left off " 195 "and without signal to be sent\n"); 196 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 197 198 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 199 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 200 child); 201 break; 202 } 203 204 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 205 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 206} 207 208#define TRACEME_RAISE(test, sig) \ 209ATF_TC(test); \ 210ATF_TC_HEAD(test, tc) \ 211{ \ 212 atf_tc_set_md_var(tc, "descr", \ 213 "Verify " #sig " followed by _exit(2) in a child"); \ 214} \ 215 \ 216ATF_TC_BODY(test, tc) \ 217{ \ 218 \ 219 traceme_raise(sig); \ 220} 221 222TRACEME_RAISE(traceme_raise1, SIGKILL) /* non-maskable */ 223TRACEME_RAISE(traceme_raise2, SIGSTOP) /* non-maskable */ 224TRACEME_RAISE(traceme_raise3, SIGABRT) /* regular abort trap */ 225TRACEME_RAISE(traceme_raise4, SIGHUP) /* hangup */ 226TRACEME_RAISE(traceme_raise5, SIGCONT) /* continued? */ 227TRACEME_RAISE(traceme_raise6, SIGTRAP) /* crash signal */ 228TRACEME_RAISE(traceme_raise7, SIGBUS) /* crash signal */ 229TRACEME_RAISE(traceme_raise8, SIGILL) /* crash signal */ 230TRACEME_RAISE(traceme_raise9, SIGFPE) /* crash signal */ 231TRACEME_RAISE(traceme_raise10, SIGSEGV) /* crash signal */ 232 233/// ---------------------------------------------------------------------------- 234 235static void 236traceme_raisesignal_ignored(int sigignored) 237{ 238 const int exitval = 5; 239 const int sigval = SIGSTOP; 240 pid_t child, wpid; 241 struct sigaction sa; 242#if defined(TWAIT_HAVE_STATUS) 243 int status; 244#endif 245 struct ptrace_siginfo info; 246 247 memset(&info, 0, sizeof(info)); 248 249 DPRINTF("Before forking process PID=%d\n", getpid()); 250 SYSCALL_REQUIRE((child = fork()) != -1); 251 if (child == 0) { 252 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 253 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 254 255 memset(&sa, 0, sizeof(sa)); 256 sa.sa_handler = SIG_IGN; 257 sigemptyset(&sa.sa_mask); 258 FORKEE_ASSERT(sigaction(sigignored, &sa, NULL) != -1); 259 260 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 261 FORKEE_ASSERT(raise(sigval) == 0); 262 263 DPRINTF("Before raising %s from child\n", 264 strsignal(sigignored)); 265 FORKEE_ASSERT(raise(sigignored) == 0); 266 267 DPRINTF("Before exiting of the child process\n"); 268 _exit(exitval); 269 } 270 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 271 272 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 273 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 274 275 validate_status_stopped(status, sigval); 276 277 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 278 SYSCALL_REQUIRE( 279 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 280 281 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 282 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 283 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 284 info.psi_siginfo.si_errno); 285 286 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 287 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 288 289 DPRINTF("Before resuming the child process where it left off and " 290 "without signal to be sent\n"); 291 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 292 293 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 294 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 295 296 validate_status_stopped(status, sigignored); 297 298 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 299 SYSCALL_REQUIRE( 300 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 301 302 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 303 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 304 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 305 info.psi_siginfo.si_errno); 306 307 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigignored); 308 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 309 310 DPRINTF("Before resuming the child process where it left off and " 311 "without signal to be sent\n"); 312 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 313 314 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 315 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 316 317 validate_status_exited(status, exitval); 318 319 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 320 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 321} 322 323#define TRACEME_RAISESIGNAL_IGNORED(test, sig) \ 324ATF_TC(test); \ 325ATF_TC_HEAD(test, tc) \ 326{ \ 327 atf_tc_set_md_var(tc, "descr", \ 328 "Verify that ignoring (with SIG_IGN) " #sig " in tracee " \ 329 "does not stop tracer from catching this raised signal"); \ 330} \ 331 \ 332ATF_TC_BODY(test, tc) \ 333{ \ 334 \ 335 traceme_raisesignal_ignored(sig); \ 336} 337 338// A signal handler for SIGKILL and SIGSTOP cannot be ignored. 339TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored1, SIGABRT) /* abort */ 340TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored2, SIGHUP) /* hangup */ 341TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored3, SIGCONT) /* cont. */ 342TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored4, SIGTRAP) /* crash */ 343TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored5, SIGBUS) /* crash */ 344TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored6, SIGILL) /* crash */ 345TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored7, SIGFPE) /* crash */ 346TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored8, SIGSEGV) /* crash */ 347 348/// ---------------------------------------------------------------------------- 349 350static void 351traceme_raisesignal_masked(int sigmasked) 352{ 353 const int exitval = 5; 354 const int sigval = SIGSTOP; 355 pid_t child, wpid; 356#if defined(TWAIT_HAVE_STATUS) 357 int status; 358#endif 359 sigset_t intmask; 360 struct ptrace_siginfo info; 361 362 memset(&info, 0, sizeof(info)); 363 364 DPRINTF("Before forking process PID=%d\n", getpid()); 365 SYSCALL_REQUIRE((child = fork()) != -1); 366 if (child == 0) { 367 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 368 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 369 370 sigemptyset(&intmask); 371 sigaddset(&intmask, sigmasked); 372 sigprocmask(SIG_BLOCK, &intmask, NULL); 373 374 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 375 FORKEE_ASSERT(raise(sigval) == 0); 376 377 DPRINTF("Before raising %s breakpoint from child\n", 378 strsignal(sigmasked)); 379 FORKEE_ASSERT(raise(sigmasked) == 0); 380 381 DPRINTF("Before exiting of the child process\n"); 382 _exit(exitval); 383 } 384 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 385 386 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 387 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 388 389 validate_status_stopped(status, sigval); 390 391 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 392 SYSCALL_REQUIRE( 393 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 394 395 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 396 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 397 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 398 info.psi_siginfo.si_errno); 399 400 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 401 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 402 403 DPRINTF("Before resuming the child process where it left off and " 404 "without signal to be sent\n"); 405 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 406 407 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 408 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 409 410 validate_status_exited(status, exitval); 411 412 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 413 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 414} 415 416#define TRACEME_RAISESIGNAL_MASKED(test, sig) \ 417ATF_TC(test); \ 418ATF_TC_HEAD(test, tc) \ 419{ \ 420 atf_tc_set_md_var(tc, "descr", \ 421 "Verify that masking (with SIG_BLOCK) " #sig " in tracee " \ 422 "stops tracer from catching this raised signal"); \ 423} \ 424 \ 425ATF_TC_BODY(test, tc) \ 426{ \ 427 \ 428 traceme_raisesignal_masked(sig); \ 429} 430 431// A signal handler for SIGKILL and SIGSTOP cannot be masked. 432TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked1, SIGABRT) /* abort trap */ 433TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked2, SIGHUP) /* hangup */ 434TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked3, SIGCONT) /* continued? */ 435TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked4, SIGTRAP) /* crash sig. */ 436TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked5, SIGBUS) /* crash sig. */ 437TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked6, SIGILL) /* crash sig. */ 438TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked7, SIGFPE) /* crash sig. */ 439TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked8, SIGSEGV) /* crash sig. */ 440 441/// ---------------------------------------------------------------------------- 442 443static void 444traceme_crash(int sig) 445{ 446 pid_t child, wpid; 447#if defined(TWAIT_HAVE_STATUS) 448 int status; 449#endif 450 struct ptrace_siginfo info; 451 452#ifndef PTRACE_ILLEGAL_ASM 453 if (sig == SIGILL) 454 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 455#endif 456 457 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 458 atf_tc_skip("FP exceptions are not supported"); 459 460 memset(&info, 0, sizeof(info)); 461 462 DPRINTF("Before forking process PID=%d\n", getpid()); 463 SYSCALL_REQUIRE((child = fork()) != -1); 464 if (child == 0) { 465 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 466 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 467 468 DPRINTF("Before executing a trap\n"); 469 switch (sig) { 470 case SIGTRAP: 471 trigger_trap(); 472 break; 473 case SIGSEGV: 474 trigger_segv(); 475 break; 476 case SIGILL: 477 trigger_ill(); 478 break; 479 case SIGFPE: 480 trigger_fpe(); 481 break; 482 case SIGBUS: 483 trigger_bus(); 484 break; 485 default: 486 /* NOTREACHED */ 487 FORKEE_ASSERTX(0 && "This shall not be reached"); 488 } 489 490 /* NOTREACHED */ 491 FORKEE_ASSERTX(0 && "This shall not be reached"); 492 } 493 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 494 495 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 496 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 497 498 validate_status_stopped(status, sig); 499 500 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 501 SYSCALL_REQUIRE( 502 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 503 504 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 505 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 506 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 507 info.psi_siginfo.si_errno); 508 509 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 510 switch (sig) { 511 case SIGTRAP: 512 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 513 break; 514 case SIGSEGV: 515 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 516 break; 517 case SIGILL: 518 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 519 info.psi_siginfo.si_code <= ILL_BADSTK); 520 break; 521 case SIGFPE: 522 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 523 break; 524 case SIGBUS: 525 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 526 break; 527 } 528 529 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 530 531 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 532 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 533 534 validate_status_signaled(status, SIGKILL, 0); 535 536 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 537 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 538} 539 540#define TRACEME_CRASH(test, sig) \ 541ATF_TC(test); \ 542ATF_TC_HEAD(test, tc) \ 543{ \ 544 atf_tc_set_md_var(tc, "descr", \ 545 "Verify crash signal " #sig " in a child after PT_TRACE_ME"); \ 546} \ 547 \ 548ATF_TC_BODY(test, tc) \ 549{ \ 550 \ 551 traceme_crash(sig); \ 552} 553 554TRACEME_CRASH(traceme_crash_trap, SIGTRAP) 555TRACEME_CRASH(traceme_crash_segv, SIGSEGV) 556TRACEME_CRASH(traceme_crash_ill, SIGILL) 557TRACEME_CRASH(traceme_crash_fpe, SIGFPE) 558TRACEME_CRASH(traceme_crash_bus, SIGBUS) 559 560/// ---------------------------------------------------------------------------- 561 562static void 563traceme_signalmasked_crash(int sig) 564{ 565 const int sigval = SIGSTOP; 566 pid_t child, wpid; 567#if defined(TWAIT_HAVE_STATUS) 568 int status; 569#endif 570 struct ptrace_siginfo info; 571 sigset_t intmask; 572 struct kinfo_proc2 kp; 573 size_t len = sizeof(kp); 574 575 int name[6]; 576 const size_t namelen = __arraycount(name); 577 ki_sigset_t kp_sigmask; 578 579#ifndef PTRACE_ILLEGAL_ASM 580 if (sig == SIGILL) 581 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 582#endif 583 584 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 585 atf_tc_skip("FP exceptions are not supported"); 586 587 memset(&info, 0, sizeof(info)); 588 589 DPRINTF("Before forking process PID=%d\n", getpid()); 590 SYSCALL_REQUIRE((child = fork()) != -1); 591 if (child == 0) { 592 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 593 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 594 595 sigemptyset(&intmask); 596 sigaddset(&intmask, sig); 597 sigprocmask(SIG_BLOCK, &intmask, NULL); 598 599 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 600 FORKEE_ASSERT(raise(sigval) == 0); 601 602 DPRINTF("Before executing a trap\n"); 603 switch (sig) { 604 case SIGTRAP: 605 trigger_trap(); 606 break; 607 case SIGSEGV: 608 trigger_segv(); 609 break; 610 case SIGILL: 611 trigger_ill(); 612 break; 613 case SIGFPE: 614 trigger_fpe(); 615 break; 616 case SIGBUS: 617 trigger_bus(); 618 break; 619 default: 620 /* NOTREACHED */ 621 FORKEE_ASSERTX(0 && "This shall not be reached"); 622 } 623 624 /* NOTREACHED */ 625 FORKEE_ASSERTX(0 && "This shall not be reached"); 626 } 627 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 628 629 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 630 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 631 632 validate_status_stopped(status, sigval); 633 634 name[0] = CTL_KERN, 635 name[1] = KERN_PROC2, 636 name[2] = KERN_PROC_PID; 637 name[3] = child; 638 name[4] = sizeof(kp); 639 name[5] = 1; 640 641 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 642 643 kp_sigmask = kp.p_sigmask; 644 645 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 646 SYSCALL_REQUIRE( 647 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 648 649 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 650 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 651 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 652 info.psi_siginfo.si_errno); 653 654 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 655 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 656 657 DPRINTF("Before resuming the child process where it left off and " 658 "without signal to be sent\n"); 659 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 660 661 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 662 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 663 664 validate_status_stopped(status, sig); 665 666 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 667 SYSCALL_REQUIRE( 668 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 669 670 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 671 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 672 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 673 info.psi_siginfo.si_errno); 674 675 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 676 677 DPRINTF("kp_sigmask=" 678 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 679 kp_sigmask.__bits[0], kp_sigmask.__bits[1], kp_sigmask.__bits[2], 680 kp_sigmask.__bits[3]); 681 682 DPRINTF("kp.p_sigmask=" 683 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 684 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 685 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 686 687 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, sizeof(kp_sigmask))); 688 689 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 690 switch (sig) { 691 case SIGTRAP: 692 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 693 break; 694 case SIGSEGV: 695 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 696 break; 697 case SIGILL: 698 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 699 info.psi_siginfo.si_code <= ILL_BADSTK); 700 break; 701 case SIGFPE: 702 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 703 break; 704 case SIGBUS: 705 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 706 break; 707 } 708 709 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 710 711 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 712 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 713 714 validate_status_signaled(status, SIGKILL, 0); 715 716 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 717 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 718} 719 720#define TRACEME_SIGNALMASKED_CRASH(test, sig) \ 721ATF_TC(test); \ 722ATF_TC_HEAD(test, tc) \ 723{ \ 724 atf_tc_set_md_var(tc, "descr", \ 725 "Verify masked crash signal " #sig " in a child after " \ 726 "PT_TRACE_ME is delivered to its tracer"); \ 727} \ 728 \ 729ATF_TC_BODY(test, tc) \ 730{ \ 731 \ 732 traceme_signalmasked_crash(sig); \ 733} 734 735TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_trap, SIGTRAP) 736TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_segv, SIGSEGV) 737TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_ill, SIGILL) 738TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_fpe, SIGFPE) 739TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_bus, SIGBUS) 740 741/// ---------------------------------------------------------------------------- 742 743static void 744traceme_signalignored_crash(int sig) 745{ 746 const int sigval = SIGSTOP; 747 pid_t child, wpid; 748#if defined(TWAIT_HAVE_STATUS) 749 int status; 750#endif 751 struct sigaction sa; 752 struct ptrace_siginfo info; 753 struct kinfo_proc2 kp; 754 size_t len = sizeof(kp); 755 756 int name[6]; 757 const size_t namelen = __arraycount(name); 758 ki_sigset_t kp_sigignore; 759 760#ifndef PTRACE_ILLEGAL_ASM 761 if (sig == SIGILL) 762 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 763#endif 764 765 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 766 atf_tc_skip("FP exceptions are not supported"); 767 768 memset(&info, 0, sizeof(info)); 769 770 DPRINTF("Before forking process PID=%d\n", getpid()); 771 SYSCALL_REQUIRE((child = fork()) != -1); 772 if (child == 0) { 773 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 774 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 775 776 memset(&sa, 0, sizeof(sa)); 777 sa.sa_handler = SIG_IGN; 778 sigemptyset(&sa.sa_mask); 779 780 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 781 782 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 783 FORKEE_ASSERT(raise(sigval) == 0); 784 785 DPRINTF("Before executing a trap\n"); 786 switch (sig) { 787 case SIGTRAP: 788 trigger_trap(); 789 break; 790 case SIGSEGV: 791 trigger_segv(); 792 break; 793 case SIGILL: 794 trigger_ill(); 795 break; 796 case SIGFPE: 797 trigger_fpe(); 798 break; 799 case SIGBUS: 800 trigger_bus(); 801 break; 802 default: 803 /* NOTREACHED */ 804 FORKEE_ASSERTX(0 && "This shall not be reached"); 805 } 806 807 /* NOTREACHED */ 808 FORKEE_ASSERTX(0 && "This shall not be reached"); 809 } 810 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 811 812 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 813 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 814 815 validate_status_stopped(status, sigval); 816 817 name[0] = CTL_KERN, 818 name[1] = KERN_PROC2, 819 name[2] = KERN_PROC_PID; 820 name[3] = child; 821 name[4] = sizeof(kp); 822 name[5] = 1; 823 824 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 825 826 kp_sigignore = kp.p_sigignore; 827 828 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 829 SYSCALL_REQUIRE( 830 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 831 832 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 833 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 834 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 835 info.psi_siginfo.si_errno); 836 837 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 838 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 839 840 DPRINTF("Before resuming the child process where it left off and " 841 "without signal to be sent\n"); 842 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 843 844 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 845 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 846 847 validate_status_stopped(status, sig); 848 849 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 850 SYSCALL_REQUIRE( 851 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 852 853 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 854 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 855 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 856 info.psi_siginfo.si_errno); 857 858 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 859 860 DPRINTF("kp_sigignore=" 861 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 862 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 863 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 864 865 DPRINTF("kp.p_sigignore=" 866 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 867 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 868 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 869 870 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, sizeof(kp_sigignore))); 871 872 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sig); 873 switch (sig) { 874 case SIGTRAP: 875 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 876 break; 877 case SIGSEGV: 878 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 879 break; 880 case SIGILL: 881 ATF_REQUIRE(info.psi_siginfo.si_code >= ILL_ILLOPC && 882 info.psi_siginfo.si_code <= ILL_BADSTK); 883 break; 884 case SIGFPE: 885 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 886 break; 887 case SIGBUS: 888 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 889 break; 890 } 891 892 SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1); 893 894 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 895 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 896 897 validate_status_signaled(status, SIGKILL, 0); 898 899 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 900 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 901} 902 903#define TRACEME_SIGNALIGNORED_CRASH(test, sig) \ 904ATF_TC(test); \ 905ATF_TC_HEAD(test, tc) \ 906{ \ 907 atf_tc_set_md_var(tc, "descr", \ 908 "Verify ignored crash signal " #sig " in a child after " \ 909 "PT_TRACE_ME is delivered to its tracer"); \ 910} \ 911 \ 912ATF_TC_BODY(test, tc) \ 913{ \ 914 \ 915 traceme_signalignored_crash(sig); \ 916} 917 918TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_trap, SIGTRAP) 919TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_segv, SIGSEGV) 920TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_ill, SIGILL) 921TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_fpe, SIGFPE) 922TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_bus, SIGBUS) 923 924/// ---------------------------------------------------------------------------- 925 926static void 927traceme_sendsignal_handle(int sigsent, void (*sah)(int a), int *traceme_caught) 928{ 929 const int exitval = 5; 930 const int sigval = SIGSTOP; 931 pid_t child, wpid; 932 struct sigaction sa; 933#if defined(TWAIT_HAVE_STATUS) 934 int status; 935#endif 936 struct ptrace_siginfo info; 937 938 memset(&info, 0, sizeof(info)); 939 940 DPRINTF("Before forking process PID=%d\n", getpid()); 941 SYSCALL_REQUIRE((child = fork()) != -1); 942 if (child == 0) { 943 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 944 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 945 946 sa.sa_handler = sah; 947 sa.sa_flags = SA_SIGINFO; 948 sigemptyset(&sa.sa_mask); 949 950 FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1); 951 952 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 953 FORKEE_ASSERT(raise(sigval) == 0); 954 955 FORKEE_ASSERT_EQ(*traceme_caught, 1); 956 957 DPRINTF("Before exiting of the child process\n"); 958 _exit(exitval); 959 } 960 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 961 962 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 963 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 964 965 validate_status_stopped(status, sigval); 966 967 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 968 SYSCALL_REQUIRE( 969 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 970 971 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 972 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 973 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 974 info.psi_siginfo.si_errno); 975 976 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 977 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 978 979 DPRINTF("Before resuming the child process where it left off and with " 980 "signal %s to be sent\n", strsignal(sigsent)); 981 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 982 983 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 984 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 985 986 validate_status_exited(status, exitval); 987 988 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 989 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 990} 991 992#define TRACEME_SENDSIGNAL_HANDLE(test, sig) \ 993ATF_TC(test); \ 994ATF_TC_HEAD(test, tc) \ 995{ \ 996 atf_tc_set_md_var(tc, "descr", \ 997 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 998 "handled correctly and caught by a signal handler"); \ 999} \ 1000 \ 1001static int test##_caught = 0; \ 1002 \ 1003static void \ 1004test##_sighandler(int arg) \ 1005{ \ 1006 FORKEE_ASSERT_EQ(arg, sig); \ 1007 \ 1008 ++ test##_caught; \ 1009} \ 1010 \ 1011ATF_TC_BODY(test, tc) \ 1012{ \ 1013 \ 1014 traceme_sendsignal_handle(sig, test##_sighandler, & test##_caught); \ 1015} 1016 1017// A signal handler for SIGKILL and SIGSTOP cannot be registered. 1018TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle1, SIGABRT) /* abort trap */ 1019TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle2, SIGHUP) /* hangup */ 1020TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle3, SIGCONT) /* continued? */ 1021TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle4, SIGTRAP) /* crash sig. */ 1022TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle5, SIGBUS) /* crash sig. */ 1023TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle6, SIGILL) /* crash sig. */ 1024TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle7, SIGFPE) /* crash sig. */ 1025TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle8, SIGSEGV) /* crash sig. */ 1026 1027/// ---------------------------------------------------------------------------- 1028 1029static void 1030traceme_sendsignal_masked(int sigsent) 1031{ 1032 const int exitval = 5; 1033 const int sigval = SIGSTOP; 1034 pid_t child, wpid; 1035 sigset_t set; 1036#if defined(TWAIT_HAVE_STATUS) 1037 int status; 1038#endif 1039 struct ptrace_siginfo info; 1040 1041 memset(&info, 0, sizeof(info)); 1042 1043 DPRINTF("Before forking process PID=%d\n", getpid()); 1044 SYSCALL_REQUIRE((child = fork()) != -1); 1045 if (child == 0) { 1046 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1047 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1048 1049 sigemptyset(&set); 1050 sigaddset(&set, sigsent); 1051 FORKEE_ASSERT(sigprocmask(SIG_BLOCK, &set, NULL) != -1); 1052 1053 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1054 FORKEE_ASSERT(raise(sigval) == 0); 1055 1056 _exit(exitval); 1057 } 1058 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1059 1060 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1061 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1062 1063 validate_status_stopped(status, sigval); 1064 1065 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1066 SYSCALL_REQUIRE( 1067 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1068 1069 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1070 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1071 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1072 info.psi_siginfo.si_errno); 1073 1074 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1075 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1076 1077 DPRINTF("Before resuming the child process where it left off and with " 1078 "signal %s to be sent\n", strsignal(sigsent)); 1079 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1080 1081 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1082 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1083 1084 validate_status_exited(status, exitval); 1085 1086 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1087 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1088} 1089 1090#define TRACEME_SENDSIGNAL_MASKED(test, sig) \ 1091ATF_TC(test); \ 1092ATF_TC_HEAD(test, tc) \ 1093{ \ 1094 atf_tc_set_md_var(tc, "descr", \ 1095 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1096 "handled correctly and the signal is masked by SIG_BLOCK"); \ 1097} \ 1098 \ 1099ATF_TC_BODY(test, tc) \ 1100{ \ 1101 \ 1102 traceme_sendsignal_masked(sig); \ 1103} 1104 1105// A signal handler for SIGKILL and SIGSTOP cannot be masked. 1106TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked1, SIGABRT) /* abort trap */ 1107TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked2, SIGHUP) /* hangup */ 1108TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked3, SIGCONT) /* continued? */ 1109TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked4, SIGTRAP) /* crash sig. */ 1110TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked5, SIGBUS) /* crash sig. */ 1111TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked6, SIGILL) /* crash sig. */ 1112TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked7, SIGFPE) /* crash sig. */ 1113TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked8, SIGSEGV) /* crash sig. */ 1114 1115/// ---------------------------------------------------------------------------- 1116 1117static void 1118traceme_sendsignal_ignored(int sigsent) 1119{ 1120 const int exitval = 5; 1121 const int sigval = SIGSTOP; 1122 pid_t child, wpid; 1123 struct sigaction sa; 1124#if defined(TWAIT_HAVE_STATUS) 1125 int status; 1126#endif 1127 struct ptrace_siginfo info; 1128 1129 memset(&info, 0, sizeof(info)); 1130 1131 DPRINTF("Before forking process PID=%d\n", getpid()); 1132 SYSCALL_REQUIRE((child = fork()) != -1); 1133 if (child == 0) { 1134 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1135 1136 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1137 1138 memset(&sa, 0, sizeof(sa)); 1139 sa.sa_handler = SIG_IGN; 1140 sigemptyset(&sa.sa_mask); 1141 FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1); 1142 1143 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1144 FORKEE_ASSERT(raise(sigval) == 0); 1145 1146 _exit(exitval); 1147 } 1148 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1149 1150 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1151 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1152 1153 validate_status_stopped(status, sigval); 1154 1155 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1156 SYSCALL_REQUIRE( 1157 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1158 1159 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1160 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1161 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1162 info.psi_siginfo.si_errno); 1163 1164 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1165 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1166 1167 DPRINTF("Before resuming the child process where it left off and with " 1168 "signal %s to be sent\n", strsignal(sigsent)); 1169 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1170 1171 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1172 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1173 1174 validate_status_exited(status, exitval); 1175 1176 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1177 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1178} 1179 1180#define TRACEME_SENDSIGNAL_IGNORED(test, sig) \ 1181ATF_TC(test); \ 1182ATF_TC_HEAD(test, tc) \ 1183{ \ 1184 atf_tc_set_md_var(tc, "descr", \ 1185 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1186 "handled correctly and the signal is masked by SIG_IGN"); \ 1187} \ 1188 \ 1189ATF_TC_BODY(test, tc) \ 1190{ \ 1191 \ 1192 traceme_sendsignal_ignored(sig); \ 1193} 1194 1195// A signal handler for SIGKILL and SIGSTOP cannot be ignored. 1196TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored1, SIGABRT) /* abort */ 1197TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored2, SIGHUP) /* hangup */ 1198TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored3, SIGCONT) /* continued */ 1199TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored4, SIGTRAP) /* crash s. */ 1200TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored5, SIGBUS) /* crash s. */ 1201TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored6, SIGILL) /* crash s. */ 1202TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored7, SIGFPE) /* crash s. */ 1203TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored8, SIGSEGV) /* crash s. */ 1204 1205/// ---------------------------------------------------------------------------- 1206 1207static void 1208traceme_sendsignal_simple(int sigsent) 1209{ 1210 const int sigval = SIGSTOP; 1211 int exitval = 0; 1212 pid_t child, wpid; 1213#if defined(TWAIT_HAVE_STATUS) 1214 int status; 1215 int expect_core; 1216 1217 switch (sigsent) { 1218 case SIGABRT: 1219 case SIGTRAP: 1220 case SIGBUS: 1221 case SIGILL: 1222 case SIGFPE: 1223 case SIGSEGV: 1224 expect_core = 1; 1225 break; 1226 default: 1227 expect_core = 0; 1228 break; 1229 } 1230#endif 1231 struct ptrace_siginfo info; 1232 1233 memset(&info, 0, sizeof(info)); 1234 1235 DPRINTF("Before forking process PID=%d\n", getpid()); 1236 SYSCALL_REQUIRE((child = fork()) != -1); 1237 if (child == 0) { 1238 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1239 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1240 1241 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1242 FORKEE_ASSERT(raise(sigval) == 0); 1243 1244 switch (sigsent) { 1245 case SIGCONT: 1246 case SIGSTOP: 1247 _exit(exitval); 1248 default: 1249 /* NOTREACHED */ 1250 FORKEE_ASSERTX(0 && "This shall not be reached"); 1251 } 1252 } 1253 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1254 1255 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1256 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1257 1258 validate_status_stopped(status, sigval); 1259 1260 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1261 SYSCALL_REQUIRE( 1262 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1263 1264 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1265 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1266 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1267 info.psi_siginfo.si_errno); 1268 1269 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1270 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1271 1272 DPRINTF("Before resuming the child process where it left off and with " 1273 "signal %s to be sent\n", strsignal(sigsent)); 1274 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1); 1275 1276 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1277 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1278 1279 switch (sigsent) { 1280 case SIGSTOP: 1281 validate_status_stopped(status, sigsent); 1282 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 1283 "child\n"); 1284 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 1285 sizeof(info)) != -1); 1286 1287 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1288 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 1289 "si_errno=%#x\n", 1290 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1291 info.psi_siginfo.si_errno); 1292 1293 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1294 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 1295 1296 DPRINTF("Before resuming the child process where it left off " 1297 "and with signal %s to be sent\n", strsignal(sigsent)); 1298 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 1299 1300 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1301 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 1302 child); 1303 /* FALLTHROUGH */ 1304 case SIGCONT: 1305 validate_status_exited(status, exitval); 1306 break; 1307 default: 1308 validate_status_signaled(status, sigsent, expect_core); 1309 break; 1310 } 1311 1312 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 1313 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1314} 1315 1316#define TRACEME_SENDSIGNAL_SIMPLE(test, sig) \ 1317ATF_TC(test); \ 1318ATF_TC_HEAD(test, tc) \ 1319{ \ 1320 atf_tc_set_md_var(tc, "descr", \ 1321 "Verify that a signal " #sig " emitted by a tracer to a child is " \ 1322 "handled correctly in a child without a signal handler"); \ 1323} \ 1324 \ 1325ATF_TC_BODY(test, tc) \ 1326{ \ 1327 \ 1328 traceme_sendsignal_simple(sig); \ 1329} 1330 1331TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple1, SIGKILL) /* non-maskable*/ 1332TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple2, SIGSTOP) /* non-maskable*/ 1333TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple3, SIGABRT) /* abort trap */ 1334TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple4, SIGHUP) /* hangup */ 1335TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple5, SIGCONT) /* continued? */ 1336TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple6, SIGTRAP) /* crash sig. */ 1337TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple7, SIGBUS) /* crash sig. */ 1338TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple8, SIGILL) /* crash sig. */ 1339TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple9, SIGFPE) /* crash sig. */ 1340TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple10, SIGSEGV) /* crash sig. */ 1341 1342/// ---------------------------------------------------------------------------- 1343 1344ATF_TC(traceme_pid1_parent); 1345ATF_TC_HEAD(traceme_pid1_parent, tc) 1346{ 1347 atf_tc_set_md_var(tc, "descr", 1348 "Verify that PT_TRACE_ME is not allowed when our parent is PID1"); 1349} 1350 1351ATF_TC_BODY(traceme_pid1_parent, tc) 1352{ 1353 struct msg_fds parent_child; 1354 int exitval_child1 = 1, exitval_child2 = 2; 1355 pid_t child1, child2, wpid; 1356 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 1357#if defined(TWAIT_HAVE_STATUS) 1358 int status; 1359#endif 1360 1361 SYSCALL_REQUIRE(msg_open(&parent_child) == 0); 1362 1363 DPRINTF("Before forking process PID=%d\n", getpid()); 1364 SYSCALL_REQUIRE((child1 = fork()) != -1); 1365 if (child1 == 0) { 1366 DPRINTF("Before forking process PID=%d\n", getpid()); 1367 SYSCALL_REQUIRE((child2 = fork()) != -1); 1368 if (child2 != 0) { 1369 DPRINTF("Parent process PID=%d, child2's PID=%d\n", 1370 getpid(), child2); 1371 _exit(exitval_child1); 1372 } 1373 CHILD_FROM_PARENT("exit child1", parent_child, msg); 1374 1375 DPRINTF("Assert that our parent is PID1 (initproc)\n"); 1376 FORKEE_ASSERT_EQ(getppid(), 1); 1377 1378 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1379 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) == -1); 1380 SYSCALL_REQUIRE_ERRNO(errno, EPERM); 1381 1382 CHILD_TO_PARENT("child2 exiting", parent_child, msg); 1383 1384 _exit(exitval_child2); 1385 } 1386 DPRINTF("Parent process PID=%d, child1's PID=%d\n", getpid(), child1); 1387 1388 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1389 TWAIT_REQUIRE_SUCCESS( 1390 wpid = TWAIT_GENERIC(child1, &status, WEXITED), child1); 1391 1392 validate_status_exited(status, exitval_child1); 1393 1394 DPRINTF("Notify that child1 is dead\n"); 1395 PARENT_TO_CHILD("exit child1", parent_child, msg); 1396 1397 DPRINTF("Wait for exiting of child2\n"); 1398 PARENT_FROM_CHILD("child2 exiting", parent_child, msg); 1399} 1400 1401/// ---------------------------------------------------------------------------- 1402 1403static void 1404traceme_vfork_raise(int sigval) 1405{ 1406 const int exitval = 5, exitval_watcher = 10; 1407 pid_t child, parent, watcher, wpid; 1408 int rv; 1409#if defined(TWAIT_HAVE_STATUS) 1410 int status; 1411 1412 /* volatile workarounds GCC -Werror=clobbered */ 1413 volatile int expect_core; 1414 1415 switch (sigval) { 1416 case SIGABRT: 1417 case SIGTRAP: 1418 case SIGBUS: 1419 case SIGILL: 1420 case SIGFPE: 1421 case SIGSEGV: 1422 expect_core = 1; 1423 break; 1424 default: 1425 expect_core = 0; 1426 break; 1427 } 1428#endif 1429 1430 /* 1431 * Spawn a dedicated thread to watch for a stopped child and emit 1432 * the SIGKILL signal to it. 1433 * 1434 * vfork(2) might clobber watcher, this means that it's safer and 1435 * simpler to reparent this process to initproc and forget about it. 1436 */ 1437 if (sigval == SIGSTOP) { 1438 parent = getpid(); 1439 1440 watcher = fork(); 1441 ATF_REQUIRE(watcher != 1); 1442 if (watcher == 0) { 1443 /* Double fork(2) trick to reparent to initproc */ 1444 watcher = fork(); 1445 FORKEE_ASSERT_NEQ(watcher, -1); 1446 if (watcher != 0) 1447 _exit(exitval_watcher); 1448 1449 child = await_stopped_child(parent); 1450 1451 errno = 0; 1452 rv = kill(child, SIGKILL); 1453 FORKEE_ASSERT_EQ(rv, 0); 1454 FORKEE_ASSERT_EQ(errno, 0); 1455 1456 /* This exit value will be collected by initproc */ 1457 _exit(0); 1458 } 1459 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1460 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(watcher, &status, 0), 1461 watcher); 1462 1463 validate_status_exited(status, exitval_watcher); 1464 1465 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1466 TWAIT_REQUIRE_FAILURE(ECHILD, 1467 wpid = TWAIT_GENERIC(watcher, &status, 0)); 1468 } 1469 1470 DPRINTF("Before forking process PID=%d\n", getpid()); 1471 SYSCALL_REQUIRE((child = vfork()) != -1); 1472 if (child == 0) { 1473 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1474 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1475 1476 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 1477 FORKEE_ASSERT(raise(sigval) == 0); 1478 1479 switch (sigval) { 1480 case SIGSTOP: 1481 case SIGKILL: 1482 case SIGABRT: 1483 case SIGHUP: 1484 case SIGTRAP: 1485 case SIGBUS: 1486 case SIGILL: 1487 case SIGFPE: 1488 case SIGSEGV: 1489 /* NOTREACHED */ 1490 FORKEE_ASSERTX(0 && "This shall not be reached"); 1491 __unreachable(); 1492 default: 1493 DPRINTF("Before exiting of the child process\n"); 1494 _exit(exitval); 1495 } 1496 } 1497 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1498 1499 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1500 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1501 1502 switch (sigval) { 1503 case SIGKILL: 1504 case SIGABRT: 1505 case SIGHUP: 1506 case SIGTRAP: 1507 case SIGBUS: 1508 case SIGILL: 1509 case SIGFPE: 1510 case SIGSEGV: 1511 validate_status_signaled(status, sigval, expect_core); 1512 break; 1513 case SIGSTOP: 1514 validate_status_signaled(status, SIGKILL, 0); 1515 break; 1516 case SIGCONT: 1517 case SIGTSTP: 1518 case SIGTTIN: 1519 case SIGTTOU: 1520 validate_status_exited(status, exitval); 1521 break; 1522 default: 1523 /* NOTREACHED */ 1524 ATF_REQUIRE(0 && "NOT IMPLEMENTED"); 1525 break; 1526 } 1527 1528 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1529 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1530} 1531 1532#define TRACEME_VFORK_RAISE(test, sig) \ 1533ATF_TC(test); \ 1534ATF_TC_HEAD(test, tc) \ 1535{ \ 1536 atf_tc_set_md_var(tc, "descr", \ 1537 "Verify PT_TRACE_ME followed by raise of " #sig " in a " \ 1538 "vfork(2)ed child"); \ 1539} \ 1540 \ 1541ATF_TC_BODY(test, tc) \ 1542{ \ 1543 \ 1544 traceme_vfork_raise(sig); \ 1545} 1546 1547TRACEME_VFORK_RAISE(traceme_vfork_raise1, SIGKILL) /* non-maskable */ 1548TRACEME_VFORK_RAISE(traceme_vfork_raise2, SIGSTOP) /* non-maskable */ 1549TRACEME_VFORK_RAISE(traceme_vfork_raise3, SIGTSTP) /* ignored in vfork(2) */ 1550TRACEME_VFORK_RAISE(traceme_vfork_raise4, SIGTTIN) /* ignored in vfork(2) */ 1551TRACEME_VFORK_RAISE(traceme_vfork_raise5, SIGTTOU) /* ignored in vfork(2) */ 1552TRACEME_VFORK_RAISE(traceme_vfork_raise6, SIGABRT) /* regular abort trap */ 1553TRACEME_VFORK_RAISE(traceme_vfork_raise7, SIGHUP) /* hangup */ 1554TRACEME_VFORK_RAISE(traceme_vfork_raise8, SIGCONT) /* continued? */ 1555TRACEME_VFORK_RAISE(traceme_vfork_raise9, SIGTRAP) /* crash signal */ 1556TRACEME_VFORK_RAISE(traceme_vfork_raise10, SIGBUS) /* crash signal */ 1557TRACEME_VFORK_RAISE(traceme_vfork_raise11, SIGILL) /* crash signal */ 1558TRACEME_VFORK_RAISE(traceme_vfork_raise12, SIGFPE) /* crash signal */ 1559TRACEME_VFORK_RAISE(traceme_vfork_raise13, SIGSEGV) /* crash signal */ 1560 1561/// ---------------------------------------------------------------------------- 1562 1563static void 1564traceme_vfork_crash(int sig) 1565{ 1566 pid_t child, wpid; 1567#if defined(TWAIT_HAVE_STATUS) 1568 int status; 1569#endif 1570 1571#ifndef PTRACE_ILLEGAL_ASM 1572 if (sig == SIGILL) 1573 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1574#endif 1575 1576 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1577 atf_tc_skip("FP exceptions are not supported"); 1578 1579 DPRINTF("Before forking process PID=%d\n", getpid()); 1580 SYSCALL_REQUIRE((child = vfork()) != -1); 1581 if (child == 0) { 1582 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1583 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1584 1585 DPRINTF("Before executing a trap\n"); 1586 switch (sig) { 1587 case SIGTRAP: 1588 trigger_trap(); 1589 break; 1590 case SIGSEGV: 1591 trigger_segv(); 1592 break; 1593 case SIGILL: 1594 trigger_ill(); 1595 break; 1596 case SIGFPE: 1597 trigger_fpe(); 1598 break; 1599 case SIGBUS: 1600 trigger_bus(); 1601 break; 1602 default: 1603 /* NOTREACHED */ 1604 FORKEE_ASSERTX(0 && "This shall not be reached"); 1605 } 1606 1607 /* NOTREACHED */ 1608 FORKEE_ASSERTX(0 && "This shall not be reached"); 1609 } 1610 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1611 1612 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1613 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1614 1615 validate_status_signaled(status, sig, 1); 1616 1617 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1618 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1619} 1620 1621#define TRACEME_VFORK_CRASH(test, sig) \ 1622ATF_TC(test); \ 1623ATF_TC_HEAD(test, tc) \ 1624{ \ 1625 atf_tc_set_md_var(tc, "descr", \ 1626 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1627 "vfork(2)ed child"); \ 1628} \ 1629 \ 1630ATF_TC_BODY(test, tc) \ 1631{ \ 1632 \ 1633 traceme_vfork_crash(sig); \ 1634} 1635 1636TRACEME_VFORK_CRASH(traceme_vfork_crash_trap, SIGTRAP) 1637TRACEME_VFORK_CRASH(traceme_vfork_crash_segv, SIGSEGV) 1638TRACEME_VFORK_CRASH(traceme_vfork_crash_ill, SIGILL) 1639TRACEME_VFORK_CRASH(traceme_vfork_crash_fpe, SIGFPE) 1640TRACEME_VFORK_CRASH(traceme_vfork_crash_bus, SIGBUS) 1641 1642/// ---------------------------------------------------------------------------- 1643 1644static void 1645traceme_vfork_signalmasked_crash(int sig) 1646{ 1647 pid_t child, wpid; 1648#if defined(TWAIT_HAVE_STATUS) 1649 int status; 1650#endif 1651 sigset_t intmask; 1652 1653#ifndef PTRACE_ILLEGAL_ASM 1654 if (sig == SIGILL) 1655 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1656#endif 1657 1658 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1659 atf_tc_skip("FP exceptions are not supported"); 1660 1661 DPRINTF("Before forking process PID=%d\n", getpid()); 1662 SYSCALL_REQUIRE((child = vfork()) != -1); 1663 if (child == 0) { 1664 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1665 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1666 1667 sigemptyset(&intmask); 1668 sigaddset(&intmask, sig); 1669 sigprocmask(SIG_BLOCK, &intmask, NULL); 1670 1671 DPRINTF("Before executing a trap\n"); 1672 switch (sig) { 1673 case SIGTRAP: 1674 trigger_trap(); 1675 break; 1676 case SIGSEGV: 1677 trigger_segv(); 1678 break; 1679 case SIGILL: 1680 trigger_ill(); 1681 break; 1682 case SIGFPE: 1683 trigger_fpe(); 1684 break; 1685 case SIGBUS: 1686 trigger_bus(); 1687 break; 1688 default: 1689 /* NOTREACHED */ 1690 FORKEE_ASSERTX(0 && "This shall not be reached"); 1691 } 1692 1693 /* NOTREACHED */ 1694 FORKEE_ASSERTX(0 && "This shall not be reached"); 1695 } 1696 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1697 1698 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1699 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1700 1701 validate_status_signaled(status, sig, 1); 1702 1703 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1704 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1705} 1706 1707#define TRACEME_VFORK_SIGNALMASKED_CRASH(test, sig) \ 1708ATF_TC(test); \ 1709ATF_TC_HEAD(test, tc) \ 1710{ \ 1711 atf_tc_set_md_var(tc, "descr", \ 1712 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1713 "vfork(2)ed child with a masked signal"); \ 1714} \ 1715 \ 1716ATF_TC_BODY(test, tc) \ 1717{ \ 1718 \ 1719 traceme_vfork_signalmasked_crash(sig); \ 1720} 1721 1722TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_trap, SIGTRAP) 1723TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_segv, SIGSEGV) 1724TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_ill, SIGILL) 1725TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_fpe, SIGFPE) 1726TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_bus, SIGBUS) 1727 1728/// ---------------------------------------------------------------------------- 1729 1730static void 1731traceme_vfork_signalignored_crash(int sig) 1732{ 1733 pid_t child, wpid; 1734#if defined(TWAIT_HAVE_STATUS) 1735 int status; 1736#endif 1737 struct sigaction sa; 1738 1739#ifndef PTRACE_ILLEGAL_ASM 1740 if (sig == SIGILL) 1741 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1742#endif 1743 1744 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1745 atf_tc_skip("FP exceptions are not supported"); 1746 1747 DPRINTF("Before forking process PID=%d\n", getpid()); 1748 SYSCALL_REQUIRE((child = vfork()) != -1); 1749 if (child == 0) { 1750 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1751 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1752 1753 memset(&sa, 0, sizeof(sa)); 1754 sa.sa_handler = SIG_IGN; 1755 sigemptyset(&sa.sa_mask); 1756 1757 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 1758 1759 DPRINTF("Before executing a trap\n"); 1760 switch (sig) { 1761 case SIGTRAP: 1762 trigger_trap(); 1763 break; 1764 case SIGSEGV: 1765 trigger_segv(); 1766 break; 1767 case SIGILL: 1768 trigger_ill(); 1769 break; 1770 case SIGFPE: 1771 trigger_fpe(); 1772 break; 1773 case SIGBUS: 1774 trigger_bus(); 1775 break; 1776 default: 1777 /* NOTREACHED */ 1778 FORKEE_ASSERTX(0 && "This shall not be reached"); 1779 } 1780 1781 /* NOTREACHED */ 1782 FORKEE_ASSERTX(0 && "This shall not be reached"); 1783 } 1784 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1785 1786 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1787 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1788 1789 validate_status_signaled(status, sig, 1); 1790 1791 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1792 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1793} 1794 1795#define TRACEME_VFORK_SIGNALIGNORED_CRASH(test, sig) \ 1796ATF_TC(test); \ 1797ATF_TC_HEAD(test, tc) \ 1798{ \ 1799 atf_tc_set_md_var(tc, "descr", \ 1800 "Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \ 1801 "vfork(2)ed child with ignored signal"); \ 1802} \ 1803 \ 1804ATF_TC_BODY(test, tc) \ 1805{ \ 1806 \ 1807 traceme_vfork_signalignored_crash(sig); \ 1808} 1809 1810TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_trap, 1811 SIGTRAP) 1812TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_segv, 1813 SIGSEGV) 1814TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_ill, 1815 SIGILL) 1816TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_fpe, 1817 SIGFPE) 1818TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_bus, 1819 SIGBUS) 1820 1821/// ---------------------------------------------------------------------------- 1822 1823static void 1824traceme_vfork_exec(bool masked, bool ignored) 1825{ 1826 const int sigval = SIGTRAP; 1827 pid_t child, wpid; 1828#if defined(TWAIT_HAVE_STATUS) 1829 int status; 1830#endif 1831 struct sigaction sa; 1832 struct ptrace_siginfo info; 1833 sigset_t intmask; 1834 struct kinfo_proc2 kp; 1835 size_t len = sizeof(kp); 1836 1837 int name[6]; 1838 const size_t namelen = __arraycount(name); 1839 ki_sigset_t kp_sigmask; 1840 ki_sigset_t kp_sigignore; 1841 1842 memset(&info, 0, sizeof(info)); 1843 1844 DPRINTF("Before forking process PID=%d\n", getpid()); 1845 SYSCALL_REQUIRE((child = vfork()) != -1); 1846 if (child == 0) { 1847 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 1848 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 1849 1850 if (masked) { 1851 sigemptyset(&intmask); 1852 sigaddset(&intmask, sigval); 1853 sigprocmask(SIG_BLOCK, &intmask, NULL); 1854 } 1855 1856 if (ignored) { 1857 memset(&sa, 0, sizeof(sa)); 1858 sa.sa_handler = SIG_IGN; 1859 sigemptyset(&sa.sa_mask); 1860 FORKEE_ASSERT(sigaction(sigval, &sa, NULL) != -1); 1861 } 1862 1863 DPRINTF("Before calling execve(2) from child\n"); 1864 execlp("/bin/echo", "/bin/echo", NULL); 1865 1866 /* NOTREACHED */ 1867 FORKEE_ASSERTX(0 && "Not reached"); 1868 } 1869 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 1870 1871 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1872 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1873 1874 validate_status_stopped(status, sigval); 1875 1876 name[0] = CTL_KERN, 1877 name[1] = KERN_PROC2, 1878 name[2] = KERN_PROC_PID; 1879 name[3] = getpid(); 1880 name[4] = sizeof(kp); 1881 name[5] = 1; 1882 1883 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 1884 1885 if (masked) 1886 kp_sigmask = kp.p_sigmask; 1887 1888 if (ignored) 1889 kp_sigignore = kp.p_sigignore; 1890 1891 name[3] = getpid(); 1892 1893 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 1894 1895 if (masked) { 1896 DPRINTF("kp_sigmask=" 1897 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1898 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 1899 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 1900 1901 DPRINTF("kp.p_sigmask=" 1902 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1903 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 1904 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 1905 1906 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 1907 sizeof(kp_sigmask))); 1908 } 1909 1910 if (ignored) { 1911 DPRINTF("kp_sigignore=" 1912 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1913 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 1914 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 1915 1916 DPRINTF("kp.p_sigignore=" 1917 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 1918 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 1919 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 1920 1921 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 1922 sizeof(kp_sigignore))); 1923 } 1924 1925 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 1926 SYSCALL_REQUIRE( 1927 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 1928 1929 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 1930 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 1931 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 1932 info.psi_siginfo.si_errno); 1933 1934 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 1935 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_EXEC); 1936 1937 DPRINTF("Before resuming the child process where it left off and " 1938 "without signal to be sent\n"); 1939 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 1940 1941 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1942 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 1943 1944 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 1945 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 1946} 1947 1948#define TRACEME_VFORK_EXEC(test, masked, ignored) \ 1949ATF_TC(test); \ 1950ATF_TC_HEAD(test, tc) \ 1951{ \ 1952 atf_tc_set_md_var(tc, "descr", \ 1953 "Verify PT_TRACE_ME followed by exec(3) in a vfork(2)ed " \ 1954 "child%s%s", masked ? " with masked signal" : "", \ 1955 masked ? " with ignored signal" : ""); \ 1956} \ 1957 \ 1958ATF_TC_BODY(test, tc) \ 1959{ \ 1960 \ 1961 traceme_vfork_exec(masked, ignored); \ 1962} 1963 1964TRACEME_VFORK_EXEC(traceme_vfork_exec, false, false) 1965TRACEME_VFORK_EXEC(traceme_vfork_signalmasked_exec, true, false) 1966TRACEME_VFORK_EXEC(traceme_vfork_signalignored_exec, false, true) 1967 1968/// ---------------------------------------------------------------------------- 1969 1970#if defined(TWAIT_HAVE_PID) 1971static void 1972unrelated_tracer_sees_crash(int sig, bool masked, bool ignored) 1973{ 1974 const int sigval = SIGSTOP; 1975 struct msg_fds parent_tracee, parent_tracer; 1976 const int exitval = 10; 1977 pid_t tracee, tracer, wpid; 1978 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 1979#if defined(TWAIT_HAVE_STATUS) 1980 int status; 1981#endif 1982 struct sigaction sa; 1983 struct ptrace_siginfo info; 1984 sigset_t intmask; 1985 struct kinfo_proc2 kp; 1986 size_t len = sizeof(kp); 1987 1988 int name[6]; 1989 const size_t namelen = __arraycount(name); 1990 ki_sigset_t kp_sigmask; 1991 ki_sigset_t kp_sigignore; 1992 1993#ifndef PTRACE_ILLEGAL_ASM 1994 if (sig == SIGILL) 1995 atf_tc_skip("PTRACE_ILLEGAL_ASM not defined"); 1996#endif 1997 1998 if (sig == SIGFPE && !are_fpu_exceptions_supported()) 1999 atf_tc_skip("FP exceptions are not supported"); 2000 2001 memset(&info, 0, sizeof(info)); 2002 2003 DPRINTF("Spawn tracee\n"); 2004 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2005 tracee = atf_utils_fork(); 2006 if (tracee == 0) { 2007 // Wait for parent to let us crash 2008 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 2009 2010 if (masked) { 2011 sigemptyset(&intmask); 2012 sigaddset(&intmask, sig); 2013 sigprocmask(SIG_BLOCK, &intmask, NULL); 2014 } 2015 2016 if (ignored) { 2017 memset(&sa, 0, sizeof(sa)); 2018 sa.sa_handler = SIG_IGN; 2019 sigemptyset(&sa.sa_mask); 2020 FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1); 2021 } 2022 2023 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 2024 FORKEE_ASSERT(raise(sigval) == 0); 2025 2026 DPRINTF("Before executing a trap\n"); 2027 switch (sig) { 2028 case SIGTRAP: 2029 trigger_trap(); 2030 break; 2031 case SIGSEGV: 2032 trigger_segv(); 2033 break; 2034 case SIGILL: 2035 trigger_ill(); 2036 break; 2037 case SIGFPE: 2038 trigger_fpe(); 2039 break; 2040 case SIGBUS: 2041 trigger_bus(); 2042 break; 2043 default: 2044 /* NOTREACHED */ 2045 FORKEE_ASSERTX(0 && "This shall not be reached"); 2046 } 2047 2048 /* NOTREACHED */ 2049 FORKEE_ASSERTX(0 && "This shall not be reached"); 2050 } 2051 2052 DPRINTF("Spawn debugger\n"); 2053 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2054 tracer = atf_utils_fork(); 2055 if (tracer == 0) { 2056 /* Fork again and drop parent to reattach to PID 1 */ 2057 tracer = atf_utils_fork(); 2058 if (tracer != 0) 2059 _exit(exitval); 2060 2061 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2062 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2063 2064 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2065 FORKEE_REQUIRE_SUCCESS( 2066 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2067 2068 forkee_status_stopped(status, SIGSTOP); 2069 2070 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2071 "traced process\n"); 2072 SYSCALL_REQUIRE( 2073 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2074 2075 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2076 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2077 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2078 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2079 2080 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, SIGSTOP); 2081 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_USER); 2082 2083 /* Resume tracee with PT_CONTINUE */ 2084 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2085 2086 /* Inform parent that tracer has attached to tracee */ 2087 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2088 2089 /* Wait for parent to tell use that tracee should have exited */ 2090 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2091 2092 /* Wait for tracee and assert that it exited */ 2093 FORKEE_REQUIRE_SUCCESS( 2094 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2095 2096 forkee_status_stopped(status, sigval); 2097 2098 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2099 "traced process\n"); 2100 SYSCALL_REQUIRE( 2101 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2102 2103 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2104 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2105 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2106 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2107 2108 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sigval); 2109 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_LWP); 2110 2111 name[0] = CTL_KERN, 2112 name[1] = KERN_PROC2, 2113 name[2] = KERN_PROC_PID; 2114 name[3] = tracee; 2115 name[4] = sizeof(kp); 2116 name[5] = 1; 2117 2118 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2119 2120 if (masked) 2121 kp_sigmask = kp.p_sigmask; 2122 2123 if (ignored) 2124 kp_sigignore = kp.p_sigignore; 2125 2126 /* Resume tracee with PT_CONTINUE */ 2127 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2128 2129 /* Wait for tracee and assert that it exited */ 2130 FORKEE_REQUIRE_SUCCESS( 2131 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2132 2133 forkee_status_stopped(status, sig); 2134 2135 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the " 2136 "traced process\n"); 2137 SYSCALL_REQUIRE( 2138 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 2139 2140 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 2141 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 2142 "si_errno=%#x\n", info.psi_siginfo.si_signo, 2143 info.psi_siginfo.si_code, info.psi_siginfo.si_errno); 2144 2145 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sig); 2146 2147 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2148 2149 if (masked) { 2150 DPRINTF("kp_sigmask=" 2151 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2152 PRIx32 "\n", 2153 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 2154 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 2155 2156 DPRINTF("kp.p_sigmask=" 2157 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2158 PRIx32 "\n", 2159 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 2160 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 2161 2162 FORKEE_ASSERTX(!memcmp(&kp_sigmask, &kp.p_sigmask, 2163 sizeof(kp_sigmask))); 2164 } 2165 2166 if (ignored) { 2167 DPRINTF("kp_sigignore=" 2168 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2169 PRIx32 "\n", 2170 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 2171 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 2172 2173 DPRINTF("kp.p_sigignore=" 2174 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 2175 PRIx32 "\n", 2176 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 2177 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 2178 2179 FORKEE_ASSERTX(!memcmp(&kp_sigignore, &kp.p_sigignore, 2180 sizeof(kp_sigignore))); 2181 } 2182 2183 switch (sig) { 2184 case SIGTRAP: 2185 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, TRAP_BRKPT); 2186 break; 2187 case SIGSEGV: 2188 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SEGV_MAPERR); 2189 break; 2190 case SIGILL: 2191 FORKEE_ASSERT(info.psi_siginfo.si_code >= ILL_ILLOPC && 2192 info.psi_siginfo.si_code <= ILL_BADSTK); 2193 break; 2194 case SIGFPE: 2195 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, FPE_INTDIV); 2196 break; 2197 case SIGBUS: 2198 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, BUS_ADRERR); 2199 break; 2200 } 2201 2202 FORKEE_ASSERT(ptrace(PT_KILL, tracee, NULL, 0) != -1); 2203 DPRINTF("Before calling %s() for the tracee\n", TWAIT_FNAME); 2204 FORKEE_REQUIRE_SUCCESS( 2205 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2206 2207 forkee_status_signaled(status, SIGKILL, 0); 2208 2209 /* Inform parent that tracer is exiting normally */ 2210 CHILD_TO_PARENT("tracer done", parent_tracer, msg); 2211 2212 DPRINTF("Before exiting of the tracer process\n"); 2213 _exit(0 /* collect by initproc */); 2214 } 2215 2216 DPRINTF("Wait for the tracer process (direct child) to exit " 2217 "calling %s()\n", TWAIT_FNAME); 2218 TWAIT_REQUIRE_SUCCESS( 2219 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2220 2221 validate_status_exited(status, exitval); 2222 2223 DPRINTF("Wait for the non-exited tracee process with %s()\n", 2224 TWAIT_FNAME); 2225 TWAIT_REQUIRE_SUCCESS( 2226 wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0); 2227 2228 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2229 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2230 2231 DPRINTF("Resume the tracee and let it crash\n"); 2232 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2233 2234 DPRINTF("Resume the tracer and let it detect crashed tracee\n"); 2235 PARENT_TO_CHILD("Message 2", parent_tracer, msg); 2236 2237 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2238 TWAIT_FNAME); 2239 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2240 2241 validate_status_signaled(status, SIGKILL, 0); 2242 2243 DPRINTF("Await normal exit of tracer\n"); 2244 PARENT_FROM_CHILD("tracer done", parent_tracer, msg); 2245 2246 msg_close(&parent_tracer); 2247 msg_close(&parent_tracee); 2248} 2249 2250#define UNRELATED_TRACER_SEES_CRASH(test, sig) \ 2251ATF_TC(test); \ 2252ATF_TC_HEAD(test, tc) \ 2253{ \ 2254 atf_tc_set_md_var(tc, "descr", \ 2255 "Assert that an unrelated tracer sees crash signal from " \ 2256 "the debuggee"); \ 2257} \ 2258 \ 2259ATF_TC_BODY(test, tc) \ 2260{ \ 2261 \ 2262 unrelated_tracer_sees_crash(sig, false, false); \ 2263} 2264 2265UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_trap, SIGTRAP) 2266UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_segv, SIGSEGV) 2267UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_ill, SIGILL) 2268UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_fpe, SIGFPE) 2269UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_bus, SIGBUS) 2270 2271#define UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(test, sig) \ 2272ATF_TC(test); \ 2273ATF_TC_HEAD(test, tc) \ 2274{ \ 2275 atf_tc_set_md_var(tc, "descr", \ 2276 "Assert that an unrelated tracer sees crash signal from " \ 2277 "the debuggee with masked signal"); \ 2278} \ 2279 \ 2280ATF_TC_BODY(test, tc) \ 2281{ \ 2282 \ 2283 unrelated_tracer_sees_crash(sig, true, false); \ 2284} 2285 2286UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2287 unrelated_tracer_sees_signalmasked_crash_trap, SIGTRAP) 2288UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2289 unrelated_tracer_sees_signalmasked_crash_segv, SIGSEGV) 2290UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2291 unrelated_tracer_sees_signalmasked_crash_ill, SIGILL) 2292UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2293 unrelated_tracer_sees_signalmasked_crash_fpe, SIGFPE) 2294UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH( 2295 unrelated_tracer_sees_signalmasked_crash_bus, SIGBUS) 2296 2297#define UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(test, sig) \ 2298ATF_TC(test); \ 2299ATF_TC_HEAD(test, tc) \ 2300{ \ 2301 atf_tc_set_md_var(tc, "descr", \ 2302 "Assert that an unrelated tracer sees crash signal from " \ 2303 "the debuggee with signal ignored"); \ 2304} \ 2305 \ 2306ATF_TC_BODY(test, tc) \ 2307{ \ 2308 \ 2309 unrelated_tracer_sees_crash(sig, false, true); \ 2310} 2311 2312UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2313 unrelated_tracer_sees_signalignored_crash_trap, SIGTRAP) 2314UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2315 unrelated_tracer_sees_signalignored_crash_segv, SIGSEGV) 2316UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2317 unrelated_tracer_sees_signalignored_crash_ill, SIGILL) 2318UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2319 unrelated_tracer_sees_signalignored_crash_fpe, SIGFPE) 2320UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH( 2321 unrelated_tracer_sees_signalignored_crash_bus, SIGBUS) 2322#endif 2323 2324/// ---------------------------------------------------------------------------- 2325 2326#if defined(TWAIT_HAVE_PID) 2327static void 2328tracer_sees_terminaton_before_the_parent_raw(bool notimeout, bool unrelated, 2329 bool stopped) 2330{ 2331 /* 2332 * notimeout - disable timeout in await zombie function 2333 * unrelated - attach from unrelated tracer reparented to initproc 2334 * stopped - attach to a stopped process 2335 */ 2336 2337 struct msg_fds parent_tracee, parent_tracer; 2338 const int exitval_tracee = 5; 2339 const int exitval_tracer = 10; 2340 pid_t tracee, tracer, wpid; 2341 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2342#if defined(TWAIT_HAVE_STATUS) 2343 int status; 2344#endif 2345 2346 /* 2347 * Only a subset of options are supported. 2348 */ 2349 ATF_REQUIRE((!notimeout && !unrelated && !stopped) || 2350 (!notimeout && unrelated && !stopped) || 2351 (notimeout && !unrelated && !stopped) || 2352 (!notimeout && unrelated && stopped)); 2353 2354 DPRINTF("Spawn tracee\n"); 2355 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2356 tracee = atf_utils_fork(); 2357 if (tracee == 0) { 2358 if (stopped) { 2359 DPRINTF("Stop self PID %d\n", getpid()); 2360 raise(SIGSTOP); 2361 } 2362 2363 // Wait for parent to let us exit 2364 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 2365 _exit(exitval_tracee); 2366 } 2367 2368 DPRINTF("Spawn debugger\n"); 2369 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2370 tracer = atf_utils_fork(); 2371 if (tracer == 0) { 2372 if(unrelated) { 2373 /* Fork again and drop parent to reattach to PID 1 */ 2374 tracer = atf_utils_fork(); 2375 if (tracer != 0) 2376 _exit(exitval_tracer); 2377 } 2378 2379 if (stopped) { 2380 DPRINTF("Await for a stopped parent PID %d\n", tracee); 2381 await_stopped(tracee); 2382 } 2383 2384 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2385 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2386 2387 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2388 FORKEE_REQUIRE_SUCCESS( 2389 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2390 2391 forkee_status_stopped(status, SIGSTOP); 2392 2393 /* Resume tracee with PT_CONTINUE */ 2394 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2395 2396 /* Inform parent that tracer has attached to tracee */ 2397 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2398 2399 /* Wait for parent to tell use that tracee should have exited */ 2400 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2401 2402 /* Wait for tracee and assert that it exited */ 2403 FORKEE_REQUIRE_SUCCESS( 2404 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2405 2406 forkee_status_exited(status, exitval_tracee); 2407 DPRINTF("Tracee %d exited with %d\n", tracee, exitval_tracee); 2408 2409 DPRINTF("Before exiting of the tracer process\n"); 2410 _exit(unrelated ? 0 /* collect by initproc */ : exitval_tracer); 2411 } 2412 2413 if (unrelated) { 2414 DPRINTF("Wait for the tracer process (direct child) to exit " 2415 "calling %s()\n", TWAIT_FNAME); 2416 TWAIT_REQUIRE_SUCCESS( 2417 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2418 2419 validate_status_exited(status, exitval_tracer); 2420 2421 DPRINTF("Wait for the non-exited tracee process with %s()\n", 2422 TWAIT_FNAME); 2423 TWAIT_REQUIRE_SUCCESS( 2424 wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0); 2425 } 2426 2427 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2428 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2429 2430 DPRINTF("Resume the tracee and let it exit\n"); 2431 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2432 2433 DPRINTF("Detect that tracee is zombie\n"); 2434 if (notimeout) 2435 await_zombie_raw(tracee, 0); 2436 else 2437 await_zombie(tracee); 2438 2439 DPRINTF("Assert that there is no status about tracee %d - " 2440 "Tracer must detect zombie first - calling %s()\n", tracee, 2441 TWAIT_FNAME); 2442 TWAIT_REQUIRE_SUCCESS( 2443 wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0); 2444 2445 if (unrelated) { 2446 DPRINTF("Resume the tracer and let it detect exited tracee\n"); 2447 PARENT_TO_CHILD("Message 2", parent_tracer, msg); 2448 } else { 2449 DPRINTF("Tell the tracer child should have exited\n"); 2450 PARENT_TO_CHILD("wait for tracee exit", parent_tracer, msg); 2451 DPRINTF("Wait for tracer to finish its job and exit - calling " 2452 "%s()\n", TWAIT_FNAME); 2453 2454 DPRINTF("Wait from tracer child to complete waiting for " 2455 "tracee\n"); 2456 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 2457 tracer); 2458 2459 validate_status_exited(status, exitval_tracer); 2460 } 2461 2462 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2463 TWAIT_FNAME); 2464 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2465 2466 validate_status_exited(status, exitval_tracee); 2467 2468 msg_close(&parent_tracer); 2469 msg_close(&parent_tracee); 2470} 2471 2472ATF_TC(tracer_sees_terminaton_before_the_parent); 2473ATF_TC_HEAD(tracer_sees_terminaton_before_the_parent, tc) 2474{ 2475 atf_tc_set_md_var(tc, "descr", 2476 "Assert that tracer sees process termination before the parent"); 2477} 2478 2479ATF_TC_BODY(tracer_sees_terminaton_before_the_parent, tc) 2480{ 2481 2482 tracer_sees_terminaton_before_the_parent_raw(false, false, false); 2483} 2484 2485ATF_TC(tracer_sysctl_lookup_without_duplicates); 2486ATF_TC_HEAD(tracer_sysctl_lookup_without_duplicates, tc) 2487{ 2488 atf_tc_set_md_var(tc, "descr", 2489 "Assert that await_zombie() in attach1 always finds a single " 2490 "process and no other error is reported"); 2491} 2492 2493ATF_TC_BODY(tracer_sysctl_lookup_without_duplicates, tc) 2494{ 2495 time_t start, end; 2496 double diff; 2497 unsigned long N = 0; 2498 2499 /* 2500 * Reuse this test with tracer_sees_terminaton_before_the_parent_raw(). 2501 * This test body isn't specific to this race, however it's just good 2502 * enough for this purposes, no need to invent a dedicated code flow. 2503 */ 2504 2505 start = time(NULL); 2506 while (true) { 2507 DPRINTF("Step: %lu\n", N); 2508 tracer_sees_terminaton_before_the_parent_raw(true, false, 2509 false); 2510 end = time(NULL); 2511 diff = difftime(end, start); 2512 if (diff >= 5.0) 2513 break; 2514 ++N; 2515 } 2516 DPRINTF("Iterations: %lu\n", N); 2517} 2518 2519ATF_TC(unrelated_tracer_sees_terminaton_before_the_parent); 2520ATF_TC_HEAD(unrelated_tracer_sees_terminaton_before_the_parent, tc) 2521{ 2522 atf_tc_set_md_var(tc, "descr", 2523 "Assert that tracer sees process termination before the parent"); 2524} 2525 2526ATF_TC_BODY(unrelated_tracer_sees_terminaton_before_the_parent, tc) 2527{ 2528 2529 tracer_sees_terminaton_before_the_parent_raw(false, true, false); 2530} 2531 2532ATF_TC(tracer_attach_to_unrelated_stopped_process); 2533ATF_TC_HEAD(tracer_attach_to_unrelated_stopped_process, tc) 2534{ 2535 atf_tc_set_md_var(tc, "descr", 2536 "Assert that tracer can attach to an unrelated stopped process"); 2537} 2538 2539ATF_TC_BODY(tracer_attach_to_unrelated_stopped_process, tc) 2540{ 2541 2542 tracer_sees_terminaton_before_the_parent_raw(false, true, true); 2543} 2544#endif 2545 2546/// ---------------------------------------------------------------------------- 2547 2548static void 2549parent_attach_to_its_child(bool stopped) 2550{ 2551 struct msg_fds parent_tracee; 2552 const int exitval_tracee = 5; 2553 pid_t tracee, wpid; 2554 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2555#if defined(TWAIT_HAVE_STATUS) 2556 int status; 2557#endif 2558 2559 DPRINTF("Spawn tracee\n"); 2560 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2561 tracee = atf_utils_fork(); 2562 if (tracee == 0) { 2563 CHILD_FROM_PARENT("Message 1", parent_tracee, msg); 2564 DPRINTF("Parent should now attach to tracee\n"); 2565 2566 if (stopped) { 2567 DPRINTF("Stop self PID %d\n", getpid()); 2568 SYSCALL_REQUIRE(raise(SIGSTOP) != -1); 2569 } 2570 2571 CHILD_FROM_PARENT("Message 2", parent_tracee, msg); 2572 /* Wait for message from the parent */ 2573 _exit(exitval_tracee); 2574 } 2575 PARENT_TO_CHILD("Message 1", parent_tracee, msg); 2576 2577 if (stopped) { 2578 DPRINTF("Await for a stopped tracee PID %d\n", tracee); 2579 await_stopped(tracee); 2580 } 2581 2582 DPRINTF("Before calling PT_ATTACH for tracee %d\n", tracee); 2583 SYSCALL_REQUIRE(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2584 2585 DPRINTF("Wait for the stopped tracee process with %s()\n", 2586 TWAIT_FNAME); 2587 TWAIT_REQUIRE_SUCCESS( 2588 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2589 2590 validate_status_stopped(status, SIGSTOP); 2591 2592 DPRINTF("Resume tracee with PT_CONTINUE\n"); 2593 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2594 2595 DPRINTF("Let the tracee exit now\n"); 2596 PARENT_TO_CHILD("Message 2", parent_tracee, msg); 2597 2598 DPRINTF("Wait for tracee to exit with %s()\n", TWAIT_FNAME); 2599 TWAIT_REQUIRE_SUCCESS( 2600 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2601 2602 validate_status_exited(status, exitval_tracee); 2603 2604 DPRINTF("Before calling %s() for tracee\n", TWAIT_FNAME); 2605 TWAIT_REQUIRE_FAILURE(ECHILD, 2606 wpid = TWAIT_GENERIC(tracee, &status, 0)); 2607 2608 msg_close(&parent_tracee); 2609} 2610 2611ATF_TC(parent_attach_to_its_child); 2612ATF_TC_HEAD(parent_attach_to_its_child, tc) 2613{ 2614 atf_tc_set_md_var(tc, "descr", 2615 "Assert that tracer parent can PT_ATTACH to its child"); 2616} 2617 2618ATF_TC_BODY(parent_attach_to_its_child, tc) 2619{ 2620 2621 parent_attach_to_its_child(false); 2622} 2623 2624ATF_TC(parent_attach_to_its_stopped_child); 2625ATF_TC_HEAD(parent_attach_to_its_stopped_child, tc) 2626{ 2627 atf_tc_set_md_var(tc, "descr", 2628 "Assert that tracer parent can PT_ATTACH to its stopped child"); 2629} 2630 2631ATF_TC_BODY(parent_attach_to_its_stopped_child, tc) 2632{ 2633 2634 parent_attach_to_its_child(true); 2635} 2636 2637/// ---------------------------------------------------------------------------- 2638 2639static void 2640child_attach_to_its_parent(bool stopped) 2641{ 2642 struct msg_fds parent_tracee; 2643 const int exitval_tracer = 5; 2644 pid_t tracer, wpid; 2645 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2646#if defined(TWAIT_HAVE_STATUS) 2647 int status; 2648#endif 2649 2650 DPRINTF("Spawn tracer\n"); 2651 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2652 tracer = atf_utils_fork(); 2653 if (tracer == 0) { 2654 /* Wait for message from the parent */ 2655 CHILD_FROM_PARENT("Message 1", parent_tracee, msg); 2656 2657 if (stopped) { 2658 DPRINTF("Await for a stopped parent PID %d\n", 2659 getppid()); 2660 await_stopped(getppid()); 2661 } 2662 2663 DPRINTF("Attach to parent PID %d with PT_ATTACH from child\n", 2664 getppid()); 2665 FORKEE_ASSERT(ptrace(PT_ATTACH, getppid(), NULL, 0) != -1); 2666 2667 DPRINTF("Wait for the stopped parent process with %s()\n", 2668 TWAIT_FNAME); 2669 FORKEE_REQUIRE_SUCCESS( 2670 wpid = TWAIT_GENERIC(getppid(), &status, 0), getppid()); 2671 2672 forkee_status_stopped(status, SIGSTOP); 2673 2674 DPRINTF("Resume parent with PT_DETACH\n"); 2675 FORKEE_ASSERT(ptrace(PT_DETACH, getppid(), (void *)1, 0) 2676 != -1); 2677 2678 /* Tell parent we are ready */ 2679 CHILD_TO_PARENT("Message 1", parent_tracee, msg); 2680 2681 _exit(exitval_tracer); 2682 } 2683 2684 DPRINTF("Wait for the tracer to become ready\n"); 2685 PARENT_TO_CHILD("Message 1", parent_tracee, msg); 2686 2687 if (stopped) { 2688 DPRINTF("Stop self PID %d\n", getpid()); 2689 SYSCALL_REQUIRE(raise(SIGSTOP) != -1); 2690 } 2691 2692 DPRINTF("Allow the tracer to exit now\n"); 2693 PARENT_FROM_CHILD("Message 1", parent_tracee, msg); 2694 2695 DPRINTF("Wait for tracer to exit with %s()\n", TWAIT_FNAME); 2696 TWAIT_REQUIRE_SUCCESS( 2697 wpid = TWAIT_GENERIC(tracer, &status, 0), tracer); 2698 2699 validate_status_exited(status, exitval_tracer); 2700 2701 DPRINTF("Before calling %s() for tracer\n", TWAIT_FNAME); 2702 TWAIT_REQUIRE_FAILURE(ECHILD, 2703 wpid = TWAIT_GENERIC(tracer, &status, 0)); 2704 2705 msg_close(&parent_tracee); 2706} 2707 2708ATF_TC(child_attach_to_its_parent); 2709ATF_TC_HEAD(child_attach_to_its_parent, tc) 2710{ 2711 atf_tc_set_md_var(tc, "descr", 2712 "Assert that tracer child can PT_ATTACH to its parent"); 2713} 2714 2715ATF_TC_BODY(child_attach_to_its_parent, tc) 2716{ 2717 2718 child_attach_to_its_parent(false); 2719} 2720 2721ATF_TC(child_attach_to_its_stopped_parent); 2722ATF_TC_HEAD(child_attach_to_its_stopped_parent, tc) 2723{ 2724 atf_tc_set_md_var(tc, "descr", 2725 "Assert that tracer child can PT_ATTACH to its stopped parent"); 2726} 2727 2728ATF_TC_BODY(child_attach_to_its_stopped_parent, tc) 2729{ 2730 /* 2731 * The ATF framework (atf-run) does not tolerate raise(SIGSTOP), as 2732 * this causes a pipe (established from atf-run) to be broken. 2733 * atf-run uses this mechanism to monitor whether a test is alive. 2734 * 2735 * As a workaround spawn this test as a subprocess. 2736 */ 2737 2738 const int exitval = 15; 2739 pid_t child, wpid; 2740#if defined(TWAIT_HAVE_STATUS) 2741 int status; 2742#endif 2743 2744 SYSCALL_REQUIRE((child = fork()) != -1); 2745 if (child == 0) { 2746 child_attach_to_its_parent(true); 2747 _exit(exitval); 2748 } else { 2749 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2750 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2751 2752 validate_status_exited(status, exitval); 2753 2754 DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME); 2755 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 2756 } 2757} 2758 2759/// ---------------------------------------------------------------------------- 2760 2761#if defined(TWAIT_HAVE_PID) 2762 2763enum tracee_sees_its_original_parent_type { 2764 TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID, 2765 TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2, 2766 TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS 2767}; 2768 2769static void 2770tracee_sees_its_original_parent(enum tracee_sees_its_original_parent_type type) 2771{ 2772 struct msg_fds parent_tracer, parent_tracee; 2773 const int exitval_tracee = 5; 2774 const int exitval_tracer = 10; 2775 pid_t parent, tracee, tracer, wpid; 2776 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 2777#if defined(TWAIT_HAVE_STATUS) 2778 int status; 2779#endif 2780 /* sysctl(3) - kinfo_proc2 */ 2781 int name[CTL_MAXNAME]; 2782 struct kinfo_proc2 kp; 2783 size_t len = sizeof(kp); 2784 unsigned int namelen; 2785 2786 /* procfs - status */ 2787 FILE *fp; 2788 struct stat st; 2789 const char *fname = "/proc/curproc/status"; 2790 char s_executable[MAXPATHLEN]; 2791 int s_pid, s_ppid; 2792 int rv; 2793 2794 if (type == TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS) { 2795 SYSCALL_REQUIRE( 2796 (rv = stat(fname, &st)) == 0 || (errno == ENOENT)); 2797 if (rv != 0) 2798 atf_tc_skip("/proc/curproc/status not found"); 2799 } 2800 2801 DPRINTF("Spawn tracee\n"); 2802 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 2803 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 2804 tracee = atf_utils_fork(); 2805 if (tracee == 0) { 2806 parent = getppid(); 2807 2808 /* Emit message to the parent */ 2809 CHILD_TO_PARENT("tracee ready", parent_tracee, msg); 2810 CHILD_FROM_PARENT("exit tracee", parent_tracee, msg); 2811 2812 switch (type) { 2813 case TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID: 2814 FORKEE_ASSERT_EQ(parent, getppid()); 2815 break; 2816 case TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2: 2817 namelen = 0; 2818 name[namelen++] = CTL_KERN; 2819 name[namelen++] = KERN_PROC2; 2820 name[namelen++] = KERN_PROC_PID; 2821 name[namelen++] = getpid(); 2822 name[namelen++] = len; 2823 name[namelen++] = 1; 2824 2825 FORKEE_ASSERT_EQ( 2826 sysctl(name, namelen, &kp, &len, NULL, 0), 0); 2827 FORKEE_ASSERT_EQ(parent, kp.p_ppid); 2828 break; 2829 case TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS: 2830 /* 2831 * Format: 2832 * EXECUTABLE PID PPID ... 2833 */ 2834 FORKEE_ASSERT((fp = fopen(fname, "r")) != NULL); 2835 fscanf(fp, "%s %d %d", s_executable, &s_pid, &s_ppid); 2836 FORKEE_ASSERT_EQ(fclose(fp), 0); 2837 FORKEE_ASSERT_EQ(parent, s_ppid); 2838 break; 2839 } 2840 2841 _exit(exitval_tracee); 2842 } 2843 DPRINTF("Wait for child to record its parent identifier (pid)\n"); 2844 PARENT_FROM_CHILD("tracee ready", parent_tracee, msg); 2845 2846 DPRINTF("Spawn debugger\n"); 2847 tracer = atf_utils_fork(); 2848 if (tracer == 0) { 2849 /* No IPC to communicate with the child */ 2850 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 2851 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 2852 2853 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 2854 FORKEE_REQUIRE_SUCCESS( 2855 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2856 2857 forkee_status_stopped(status, SIGSTOP); 2858 2859 /* Resume tracee with PT_CONTINUE */ 2860 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 2861 2862 /* Inform parent that tracer has attached to tracee */ 2863 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 2864 2865 /* Wait for parent to tell use that tracee should have exited */ 2866 CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg); 2867 2868 /* Wait for tracee and assert that it exited */ 2869 FORKEE_REQUIRE_SUCCESS( 2870 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 2871 2872 forkee_status_exited(status, exitval_tracee); 2873 2874 DPRINTF("Before exiting of the tracer process\n"); 2875 _exit(exitval_tracer); 2876 } 2877 2878 DPRINTF("Wait for the tracer to attach to the tracee\n"); 2879 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 2880 2881 DPRINTF("Resume the tracee and let it exit\n"); 2882 PARENT_TO_CHILD("exit tracee", parent_tracee, msg); 2883 2884 DPRINTF("Detect that tracee is zombie\n"); 2885 await_zombie(tracee); 2886 2887 DPRINTF("Assert that there is no status about tracee - " 2888 "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME); 2889 TWAIT_REQUIRE_SUCCESS( 2890 wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0); 2891 2892 DPRINTF("Tell the tracer child should have exited\n"); 2893 PARENT_TO_CHILD("wait for tracee exit", parent_tracer, msg); 2894 2895 DPRINTF("Wait from tracer child to complete waiting for tracee\n"); 2896 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 2897 tracer); 2898 2899 validate_status_exited(status, exitval_tracer); 2900 2901 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 2902 TWAIT_FNAME); 2903 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 2904 tracee); 2905 2906 validate_status_exited(status, exitval_tracee); 2907 2908 msg_close(&parent_tracer); 2909 msg_close(&parent_tracee); 2910} 2911 2912#define TRACEE_SEES_ITS_ORIGINAL_PARENT(test, type, descr) \ 2913ATF_TC(test); \ 2914ATF_TC_HEAD(test, tc) \ 2915{ \ 2916 atf_tc_set_md_var(tc, "descr", \ 2917 "Assert that tracee sees its original parent when being traced " \ 2918 "(check " descr ")"); \ 2919} \ 2920 \ 2921ATF_TC_BODY(test, tc) \ 2922{ \ 2923 \ 2924 tracee_sees_its_original_parent(type); \ 2925} 2926 2927TRACEE_SEES_ITS_ORIGINAL_PARENT( 2928 tracee_sees_its_original_parent_getppid, 2929 TRACEE_SEES_ITS_ORIGINAL_PARENT_GETPPID, 2930 "getppid(2)"); 2931TRACEE_SEES_ITS_ORIGINAL_PARENT( 2932 tracee_sees_its_original_parent_sysctl_kinfo_proc2, 2933 TRACEE_SEES_ITS_ORIGINAL_PARENT_SYSCTL_KINFO_PROC2, 2934 "sysctl(3) and kinfo_proc2"); 2935TRACEE_SEES_ITS_ORIGINAL_PARENT( 2936 tracee_sees_its_original_parent_procfs_status, 2937 TRACEE_SEES_ITS_ORIGINAL_PARENT_PROCFS_STATUS, 2938 "the status file in procfs"); 2939#endif 2940 2941/// ---------------------------------------------------------------------------- 2942 2943static void 2944eventmask_preserved(int event) 2945{ 2946 const int exitval = 5; 2947 const int sigval = SIGSTOP; 2948 pid_t child, wpid; 2949#if defined(TWAIT_HAVE_STATUS) 2950 int status; 2951#endif 2952 ptrace_event_t set_event, get_event; 2953 const int len = sizeof(ptrace_event_t); 2954 2955 DPRINTF("Before forking process PID=%d\n", getpid()); 2956 SYSCALL_REQUIRE((child = fork()) != -1); 2957 if (child == 0) { 2958 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 2959 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 2960 2961 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 2962 FORKEE_ASSERT(raise(sigval) == 0); 2963 2964 DPRINTF("Before exiting of the child process\n"); 2965 _exit(exitval); 2966 } 2967 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 2968 2969 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2970 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2971 2972 validate_status_stopped(status, sigval); 2973 2974 set_event.pe_set_event = event; 2975 SYSCALL_REQUIRE( 2976 ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1); 2977 SYSCALL_REQUIRE( 2978 ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1); 2979 DPRINTF("set_event=%#x get_event=%#x\n", set_event.pe_set_event, 2980 get_event.pe_set_event); 2981 ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0); 2982 2983 DPRINTF("Before resuming the child process where it left off and " 2984 "without signal to be sent\n"); 2985 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 2986 2987 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2988 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2989 2990 validate_status_exited(status, exitval); 2991 2992 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2993 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 2994} 2995 2996#define EVENTMASK_PRESERVED(test, event) \ 2997ATF_TC(test); \ 2998ATF_TC_HEAD(test, tc) \ 2999{ \ 3000 atf_tc_set_md_var(tc, "descr", \ 3001 "Verify that eventmask " #event " is preserved"); \ 3002} \ 3003 \ 3004ATF_TC_BODY(test, tc) \ 3005{ \ 3006 \ 3007 eventmask_preserved(event); \ 3008} 3009 3010EVENTMASK_PRESERVED(eventmask_preserved_empty, 0) 3011EVENTMASK_PRESERVED(eventmask_preserved_fork, PTRACE_FORK) 3012EVENTMASK_PRESERVED(eventmask_preserved_vfork, PTRACE_VFORK) 3013EVENTMASK_PRESERVED(eventmask_preserved_vfork_done, PTRACE_VFORK_DONE) 3014EVENTMASK_PRESERVED(eventmask_preserved_lwp_create, PTRACE_LWP_CREATE) 3015EVENTMASK_PRESERVED(eventmask_preserved_lwp_exit, PTRACE_LWP_EXIT) 3016EVENTMASK_PRESERVED(eventmask_preserved_posix_spawn, PTRACE_POSIX_SPAWN) 3017 3018/// ---------------------------------------------------------------------------- 3019 3020static void 3021fork_body(const char *fn, bool trackspawn, bool trackfork, bool trackvfork, 3022 bool trackvforkdone) 3023{ 3024 const int exitval = 5; 3025 const int exitval2 = 0; /* This matched exit status from /bin/echo */ 3026 const int sigval = SIGSTOP; 3027 pid_t child, child2 = 0, wpid; 3028#if defined(TWAIT_HAVE_STATUS) 3029 int status; 3030#endif 3031 ptrace_state_t state; 3032 const int slen = sizeof(state); 3033 ptrace_event_t event; 3034 const int elen = sizeof(event); 3035 3036 char * const arg[] = { __UNCONST("/bin/echo"), NULL }; 3037 3038 DPRINTF("Before forking process PID=%d\n", getpid()); 3039 SYSCALL_REQUIRE((child = fork()) != -1); 3040 if (child == 0) { 3041 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3042 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3043 3044 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3045 FORKEE_ASSERT(raise(sigval) == 0); 3046 3047 if (strcmp(fn, "spawn") == 0) { 3048 FORKEE_ASSERT_EQ(posix_spawn(&child2, 3049 arg[0], NULL, NULL, arg, NULL), 0); 3050 } else { 3051 if (strcmp(fn, "fork") == 0) { 3052 FORKEE_ASSERT((child2 = fork()) != -1); 3053 } else if (strcmp(fn, "vfork") == 0) { 3054 FORKEE_ASSERT((child2 = vfork()) != -1); 3055 } 3056 3057 if (child2 == 0) 3058 _exit(exitval2); 3059 } 3060 FORKEE_REQUIRE_SUCCESS 3061 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3062 3063 forkee_status_exited(status, exitval2); 3064 3065 DPRINTF("Before exiting of the child process\n"); 3066 _exit(exitval); 3067 } 3068 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3069 3070 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3071 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3072 3073 validate_status_stopped(status, sigval); 3074 3075 DPRINTF("Set 0%s%s%s%s in EVENT_MASK for the child %d\n", 3076 trackspawn ? "|PTRACE_POSIX_SPAWN" : "", 3077 trackfork ? "|PTRACE_FORK" : "", 3078 trackvfork ? "|PTRACE_VFORK" : "", 3079 trackvforkdone ? "|PTRACE_VFORK_DONE" : "", child); 3080 event.pe_set_event = 0; 3081 if (trackspawn) 3082 event.pe_set_event |= PTRACE_POSIX_SPAWN; 3083 if (trackfork) 3084 event.pe_set_event |= PTRACE_FORK; 3085 if (trackvfork) 3086 event.pe_set_event |= PTRACE_VFORK; 3087 if (trackvforkdone) 3088 event.pe_set_event |= PTRACE_VFORK_DONE; 3089 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 3090 3091 DPRINTF("Before resuming the child process where it left off and " 3092 "without signal to be sent\n"); 3093 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3094 3095#if defined(TWAIT_HAVE_PID) 3096 if ((trackspawn && strcmp(fn, "spawn") == 0) || 3097 (trackfork && strcmp(fn, "fork") == 0) || 3098 (trackvfork && strcmp(fn, "vfork") == 0)) { 3099 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3100 child); 3101 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 3102 child); 3103 3104 validate_status_stopped(status, SIGTRAP); 3105 3106 SYSCALL_REQUIRE( 3107 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3108 if (trackspawn && strcmp(fn, "spawn") == 0) { 3109 ATF_REQUIRE_EQ( 3110 state.pe_report_event & PTRACE_POSIX_SPAWN, 3111 PTRACE_POSIX_SPAWN); 3112 } 3113 if (trackfork && strcmp(fn, "fork") == 0) { 3114 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 3115 PTRACE_FORK); 3116 } 3117 if (trackvfork && strcmp(fn, "vfork") == 0) { 3118 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 3119 PTRACE_VFORK); 3120 } 3121 3122 child2 = state.pe_other_pid; 3123 DPRINTF("Reported ptrace event with forkee %d\n", child2); 3124 3125 DPRINTF("Before calling %s() for the forkee %d of the child " 3126 "%d\n", TWAIT_FNAME, child2, child); 3127 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), 3128 child2); 3129 3130 validate_status_stopped(status, SIGTRAP); 3131 3132 SYSCALL_REQUIRE( 3133 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 3134 if (trackspawn && strcmp(fn, "spawn") == 0) { 3135 ATF_REQUIRE_EQ( 3136 state.pe_report_event & PTRACE_POSIX_SPAWN, 3137 PTRACE_POSIX_SPAWN); 3138 } 3139 if (trackfork && strcmp(fn, "fork") == 0) { 3140 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_FORK, 3141 PTRACE_FORK); 3142 } 3143 if (trackvfork && strcmp(fn, "vfork") == 0) { 3144 ATF_REQUIRE_EQ(state.pe_report_event & PTRACE_VFORK, 3145 PTRACE_VFORK); 3146 } 3147 3148 ATF_REQUIRE_EQ(state.pe_other_pid, child); 3149 3150 DPRINTF("Before resuming the forkee process where it left off " 3151 "and without signal to be sent\n"); 3152 SYSCALL_REQUIRE( 3153 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 3154 3155 DPRINTF("Before resuming the child process where it left off " 3156 "and without signal to be sent\n"); 3157 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3158 } 3159#endif 3160 3161 if (trackvforkdone && strcmp(fn, "vfork") == 0) { 3162 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3163 child); 3164 TWAIT_REQUIRE_SUCCESS( 3165 wpid = TWAIT_GENERIC(child, &status, 0), child); 3166 3167 validate_status_stopped(status, SIGTRAP); 3168 3169 SYSCALL_REQUIRE( 3170 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3171 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 3172 3173 child2 = state.pe_other_pid; 3174 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 3175 child2); 3176 3177 DPRINTF("Before resuming the child process where it left off " 3178 "and without signal to be sent\n"); 3179 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3180 } 3181 3182#if defined(TWAIT_HAVE_PID) 3183 if ((trackspawn && strcmp(fn, "spawn") == 0) || 3184 (trackfork && strcmp(fn, "fork") == 0) || 3185 (trackvfork && strcmp(fn, "vfork") == 0)) { 3186 DPRINTF("Before calling %s() for the forkee - expected exited" 3187 "\n", TWAIT_FNAME); 3188 TWAIT_REQUIRE_SUCCESS( 3189 wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3190 3191 validate_status_exited(status, exitval2); 3192 3193 DPRINTF("Before calling %s() for the forkee - expected no " 3194 "process\n", TWAIT_FNAME); 3195 TWAIT_REQUIRE_FAILURE(ECHILD, 3196 wpid = TWAIT_GENERIC(child2, &status, 0)); 3197 } 3198#endif 3199 3200 DPRINTF("Before calling %s() for the child - expected stopped " 3201 "SIGCHLD\n", TWAIT_FNAME); 3202 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3203 3204 validate_status_stopped(status, SIGCHLD); 3205 3206 DPRINTF("Before resuming the child process where it left off and " 3207 "without signal to be sent\n"); 3208 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3209 3210 DPRINTF("Before calling %s() for the child - expected exited\n", 3211 TWAIT_FNAME); 3212 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3213 3214 validate_status_exited(status, exitval); 3215 3216 DPRINTF("Before calling %s() for the child - expected no process\n", 3217 TWAIT_FNAME); 3218 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3219} 3220 3221#define FORK_TEST(name,fun,tspawn,tfork,tvfork,tvforkdone) \ 3222ATF_TC(name); \ 3223ATF_TC_HEAD(name, tc) \ 3224{ \ 3225 atf_tc_set_md_var(tc, "descr", "Verify " fun "() " \ 3226 "called with 0%s%s%s%s in EVENT_MASK", \ 3227 tspawn ? "|PTRACE_POSIX_SPAWN" : "", \ 3228 tfork ? "|PTRACE_FORK" : "", \ 3229 tvfork ? "|PTRACE_VFORK" : "", \ 3230 tvforkdone ? "|PTRACE_VFORK_DONE" : ""); \ 3231} \ 3232 \ 3233ATF_TC_BODY(name, tc) \ 3234{ \ 3235 \ 3236 fork_body(fun, tspawn, tfork, tvfork, tvforkdone); \ 3237} 3238 3239FORK_TEST(fork1, "fork", false, false, false, false) 3240#if defined(TWAIT_HAVE_PID) 3241FORK_TEST(fork2, "fork", false, true, false, false) 3242FORK_TEST(fork3, "fork", false, false, true, false) 3243FORK_TEST(fork4, "fork", false, true, true, false) 3244#endif 3245FORK_TEST(fork5, "fork", false, false, false, true) 3246#if defined(TWAIT_HAVE_PID) 3247FORK_TEST(fork6, "fork", false, true, false, true) 3248FORK_TEST(fork7, "fork", false, false, true, true) 3249FORK_TEST(fork8, "fork", false, true, true, true) 3250#endif 3251FORK_TEST(fork9, "fork", true, false, false, false) 3252#if defined(TWAIT_HAVE_PID) 3253FORK_TEST(fork10, "fork", true, true, false, false) 3254FORK_TEST(fork11, "fork", true, false, true, false) 3255FORK_TEST(fork12, "fork", true, true, true, false) 3256#endif 3257FORK_TEST(fork13, "fork", true, false, false, true) 3258#if defined(TWAIT_HAVE_PID) 3259FORK_TEST(fork14, "fork", true, true, false, true) 3260FORK_TEST(fork15, "fork", true, false, true, true) 3261FORK_TEST(fork16, "fork", true, true, true, true) 3262#endif 3263 3264FORK_TEST(vfork1, "vfork", false, false, false, false) 3265#if defined(TWAIT_HAVE_PID) 3266FORK_TEST(vfork2, "vfork", false, true, false, false) 3267FORK_TEST(vfork3, "vfork", false, false, true, false) 3268FORK_TEST(vfork4, "vfork", false, true, true, false) 3269#endif 3270FORK_TEST(vfork5, "vfork", false, false, false, true) 3271#if defined(TWAIT_HAVE_PID) 3272FORK_TEST(vfork6, "vfork", false, true, false, true) 3273FORK_TEST(vfork7, "vfork", false, false, true, true) 3274FORK_TEST(vfork8, "vfork", false, true, true, true) 3275#endif 3276FORK_TEST(vfork9, "vfork", true, false, false, false) 3277#if defined(TWAIT_HAVE_PID) 3278FORK_TEST(vfork10, "vfork", true, true, false, false) 3279FORK_TEST(vfork11, "vfork", true, false, true, false) 3280FORK_TEST(vfork12, "vfork", true, true, true, false) 3281#endif 3282FORK_TEST(vfork13, "vfork", true, false, false, true) 3283#if defined(TWAIT_HAVE_PID) 3284FORK_TEST(vfork14, "vfork", true, true, false, true) 3285FORK_TEST(vfork15, "vfork", true, false, true, true) 3286FORK_TEST(vfork16, "vfork", true, true, true, true) 3287#endif 3288 3289FORK_TEST(posix_spawn1, "spawn", false, false, false, false) 3290FORK_TEST(posix_spawn2, "spawn", false, true, false, false) 3291FORK_TEST(posix_spawn3, "spawn", false, false, true, false) 3292FORK_TEST(posix_spawn4, "spawn", false, true, true, false) 3293FORK_TEST(posix_spawn5, "spawn", false, false, false, true) 3294FORK_TEST(posix_spawn6, "spawn", false, true, false, true) 3295FORK_TEST(posix_spawn7, "spawn", false, false, true, true) 3296FORK_TEST(posix_spawn8, "spawn", false, true, true, true) 3297#if defined(TWAIT_HAVE_PID) 3298FORK_TEST(posix_spawn9, "spawn", true, false, false, false) 3299FORK_TEST(posix_spawn10, "spawn", true, true, false, false) 3300FORK_TEST(posix_spawn11, "spawn", true, false, true, false) 3301FORK_TEST(posix_spawn12, "spawn", true, true, true, false) 3302FORK_TEST(posix_spawn13, "spawn", true, false, false, true) 3303FORK_TEST(posix_spawn14, "spawn", true, true, false, true) 3304FORK_TEST(posix_spawn15, "spawn", true, false, true, true) 3305FORK_TEST(posix_spawn16, "spawn", true, true, true, true) 3306#endif 3307 3308/// ---------------------------------------------------------------------------- 3309 3310#if defined(TWAIT_HAVE_PID) 3311static void 3312fork_detach_forker_body(const char *fn, bool kill_process) 3313{ 3314 const int exitval = 5; 3315 const int exitval2 = 0; /* Matches exit value from /bin/echo */ 3316 const int sigval = SIGSTOP; 3317 pid_t child, child2 = 0, wpid; 3318#if defined(TWAIT_HAVE_STATUS) 3319 int status; 3320#endif 3321 ptrace_state_t state; 3322 const int slen = sizeof(state); 3323 ptrace_event_t event; 3324 const int elen = sizeof(event); 3325 3326 int op; 3327 3328 char * const arg[] = { __UNCONST("/bin/echo"), NULL }; 3329 3330 DPRINTF("Before forking process PID=%d\n", getpid()); 3331 SYSCALL_REQUIRE((child = fork()) != -1); 3332 if (child == 0) { 3333 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3334 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3335 3336 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3337 FORKEE_ASSERT(raise(sigval) == 0); 3338 3339 if (strcmp(fn, "spawn") == 0) { 3340 FORKEE_ASSERT_EQ(posix_spawn(&child2, 3341 arg[0], NULL, NULL, arg, NULL), 0); 3342 } else { 3343 if (strcmp(fn, "fork") == 0) { 3344 FORKEE_ASSERT((child2 = fork()) != -1); 3345 } else { 3346 FORKEE_ASSERT((child2 = vfork()) != -1); 3347 } 3348 3349 if (child2 == 0) 3350 _exit(exitval2); 3351 } 3352 3353 FORKEE_REQUIRE_SUCCESS 3354 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3355 3356 forkee_status_exited(status, exitval2); 3357 3358 DPRINTF("Before exiting of the child process\n"); 3359 _exit(exitval); 3360 } 3361 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3362 3363 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3364 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3365 3366 validate_status_stopped(status, sigval); 3367 3368 DPRINTF("Set EVENT_MASK for the child %d\n", child); 3369 event.pe_set_event = PTRACE_POSIX_SPAWN | PTRACE_FORK | PTRACE_VFORK 3370 | PTRACE_VFORK_DONE; 3371 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 3372 3373 DPRINTF("Before resuming the child process where it left off and " 3374 "without signal to be sent\n"); 3375 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3376 3377 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, child); 3378 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3379 3380 validate_status_stopped(status, SIGTRAP); 3381 3382 SYSCALL_REQUIRE( 3383 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3384 3385 if (strcmp(fn, "spawn") == 0) 3386 op = PTRACE_POSIX_SPAWN; 3387 else if (strcmp(fn, "fork") == 0) 3388 op = PTRACE_FORK; 3389 else 3390 op = PTRACE_VFORK; 3391 3392 ATF_REQUIRE_EQ(state.pe_report_event & op, op); 3393 3394 child2 = state.pe_other_pid; 3395 DPRINTF("Reported ptrace event with forkee %d\n", child2); 3396 3397 if (strcmp(fn, "spawn") == 0 || strcmp(fn, "fork") == 0 || 3398 strcmp(fn, "vfork") == 0) 3399 op = kill_process ? PT_KILL : PT_DETACH; 3400 else 3401 op = PT_CONTINUE; 3402 SYSCALL_REQUIRE(ptrace(op, child, (void *)1, 0) != -1); 3403 3404 DPRINTF("Before calling %s() for the forkee %d of the child %d\n", 3405 TWAIT_FNAME, child2, child); 3406 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3407 3408 validate_status_stopped(status, SIGTRAP); 3409 3410 SYSCALL_REQUIRE( 3411 ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1); 3412 if (strcmp(fn, "spawn") == 0) 3413 op = PTRACE_POSIX_SPAWN; 3414 else if (strcmp(fn, "fork") == 0) 3415 op = PTRACE_FORK; 3416 else 3417 op = PTRACE_VFORK; 3418 3419 ATF_REQUIRE_EQ(state.pe_report_event & op, op); 3420 ATF_REQUIRE_EQ(state.pe_other_pid, child); 3421 3422 DPRINTF("Before resuming the forkee process where it left off " 3423 "and without signal to be sent\n"); 3424 SYSCALL_REQUIRE( 3425 ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1); 3426 3427 if (strcmp(fn, "vforkdone") == 0) { 3428 DPRINTF("Before calling %s() for the child %d\n", TWAIT_FNAME, 3429 child); 3430 TWAIT_REQUIRE_SUCCESS( 3431 wpid = TWAIT_GENERIC(child, &status, 0), child); 3432 3433 validate_status_stopped(status, SIGTRAP); 3434 3435 SYSCALL_REQUIRE( 3436 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 3437 ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE); 3438 3439 child2 = state.pe_other_pid; 3440 DPRINTF("Reported PTRACE_VFORK_DONE event with forkee %d\n", 3441 child2); 3442 3443 op = kill_process ? PT_KILL : PT_DETACH; 3444 DPRINTF("Before resuming the child process where it left off " 3445 "and without signal to be sent\n"); 3446 SYSCALL_REQUIRE(ptrace(op, child, (void *)1, 0) != -1); 3447 } 3448 3449 DPRINTF("Before calling %s() for the forkee - expected exited\n", 3450 TWAIT_FNAME); 3451 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3452 3453 validate_status_exited(status, exitval2); 3454 3455 DPRINTF("Before calling %s() for the forkee - expected no process\n", 3456 TWAIT_FNAME); 3457 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child2, &status, 0)); 3458 3459 DPRINTF("Before calling %s() for the forkee - expected exited\n", 3460 TWAIT_FNAME); 3461 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3462 3463 if (kill_process) { 3464 validate_status_signaled(status, SIGKILL, 0); 3465 } else { 3466 validate_status_exited(status, exitval); 3467 } 3468 3469 DPRINTF("Before calling %s() for the child - expected no process\n", 3470 TWAIT_FNAME); 3471 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3472} 3473 3474#define FORK_DETACH_FORKER(name,event,kprocess) \ 3475ATF_TC(name); \ 3476ATF_TC_HEAD(name, tc) \ 3477{ \ 3478 atf_tc_set_md_var(tc, "descr", "Verify %s " event, \ 3479 kprocess ? "killed" : "detached"); \ 3480} \ 3481 \ 3482ATF_TC_BODY(name, tc) \ 3483{ \ 3484 \ 3485 fork_detach_forker_body(event, kprocess); \ 3486} 3487 3488FORK_DETACH_FORKER(posix_spawn_detach_spawner, "spawn", false) 3489FORK_DETACH_FORKER(fork_detach_forker, "fork", false) 3490FORK_DETACH_FORKER(vfork_detach_vforker, "vfork", false) 3491FORK_DETACH_FORKER(vfork_detach_vforkerdone, "vforkdone", false) 3492 3493FORK_DETACH_FORKER(posix_spawn_kill_spawner, "spawn", true) 3494FORK_DETACH_FORKER(fork_kill_forker, "fork", true) 3495FORK_DETACH_FORKER(vfork_kill_vforker, "vfork", true) 3496FORK_DETACH_FORKER(vfork_kill_vforkerdone, "vforkdone", true) 3497#endif 3498 3499/// ---------------------------------------------------------------------------- 3500 3501static void 3502traceme_vfork_fork_body(pid_t (*fn)(void)) 3503{ 3504 const int exitval = 5; 3505 const int exitval2 = 15; 3506 pid_t child, child2 = 0, wpid; 3507#if defined(TWAIT_HAVE_STATUS) 3508 int status; 3509#endif 3510 3511 DPRINTF("Before forking process PID=%d\n", getpid()); 3512 SYSCALL_REQUIRE((child = vfork()) != -1); 3513 if (child == 0) { 3514 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3515 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3516 3517 FORKEE_ASSERT((child2 = (fn)()) != -1); 3518 3519 if (child2 == 0) 3520 _exit(exitval2); 3521 3522 FORKEE_REQUIRE_SUCCESS 3523 (wpid = TWAIT_GENERIC(child2, &status, 0), child2); 3524 3525 forkee_status_exited(status, exitval2); 3526 3527 DPRINTF("Before exiting of the child process\n"); 3528 _exit(exitval); 3529 } 3530 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3531 3532 DPRINTF("Before calling %s() for the child - expected exited\n", 3533 TWAIT_FNAME); 3534 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3535 3536 validate_status_exited(status, exitval); 3537 3538 DPRINTF("Before calling %s() for the child - expected no process\n", 3539 TWAIT_FNAME); 3540 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3541} 3542 3543#define TRACEME_VFORK_FORK_TEST(name,fun) \ 3544ATF_TC(name); \ 3545ATF_TC_HEAD(name, tc) \ 3546{ \ 3547 atf_tc_set_md_var(tc, "descr", "Verify " #fun "(2) " \ 3548 "called from vfork(2)ed child"); \ 3549} \ 3550 \ 3551ATF_TC_BODY(name, tc) \ 3552{ \ 3553 \ 3554 traceme_vfork_fork_body(fun); \ 3555} 3556 3557TRACEME_VFORK_FORK_TEST(traceme_vfork_fork, fork) 3558TRACEME_VFORK_FORK_TEST(traceme_vfork_vfork, vfork) 3559 3560/// ---------------------------------------------------------------------------- 3561 3562enum bytes_transfer_type { 3563 BYTES_TRANSFER_DATA, 3564 BYTES_TRANSFER_DATAIO, 3565 BYTES_TRANSFER_TEXT, 3566 BYTES_TRANSFER_TEXTIO, 3567 BYTES_TRANSFER_AUXV 3568}; 3569 3570static int __used 3571bytes_transfer_dummy(int a, int b, int c, int d) 3572{ 3573 int e, f, g, h; 3574 3575 a *= 4; 3576 b += 3; 3577 c -= 2; 3578 d /= 1; 3579 3580 e = strtol("10", NULL, 10); 3581 f = strtol("20", NULL, 10); 3582 g = strtol("30", NULL, 10); 3583 h = strtol("40", NULL, 10); 3584 3585 return (a + b * c - d) + (e * f - g / h); 3586} 3587 3588static void 3589bytes_transfer(int operation, size_t size, enum bytes_transfer_type type) 3590{ 3591 const int exitval = 5; 3592 const int sigval = SIGSTOP; 3593 pid_t child, wpid; 3594 bool skip = false; 3595 3596 int lookup_me = 0; 3597 uint8_t lookup_me8 = 0; 3598 uint16_t lookup_me16 = 0; 3599 uint32_t lookup_me32 = 0; 3600 uint64_t lookup_me64 = 0; 3601 3602 int magic = 0x13579246; 3603 uint8_t magic8 = 0xab; 3604 uint16_t magic16 = 0x1234; 3605 uint32_t magic32 = 0x98765432; 3606 uint64_t magic64 = 0xabcdef0123456789; 3607 3608 struct ptrace_io_desc io; 3609#if defined(TWAIT_HAVE_STATUS) 3610 int status; 3611#endif 3612 /* 513 is just enough, for the purposes of ATF it's good enough */ 3613 AuxInfo ai[513], *aip; 3614 3615 ATF_REQUIRE(size < sizeof(ai)); 3616 3617 /* Prepare variables for .TEXT transfers */ 3618 switch (type) { 3619 case BYTES_TRANSFER_TEXT: 3620 memcpy(&magic, bytes_transfer_dummy, sizeof(magic)); 3621 break; 3622 case BYTES_TRANSFER_TEXTIO: 3623 switch (size) { 3624 case 8: 3625 memcpy(&magic8, bytes_transfer_dummy, sizeof(magic8)); 3626 break; 3627 case 16: 3628 memcpy(&magic16, bytes_transfer_dummy, sizeof(magic16)); 3629 break; 3630 case 32: 3631 memcpy(&magic32, bytes_transfer_dummy, sizeof(magic32)); 3632 break; 3633 case 64: 3634 memcpy(&magic64, bytes_transfer_dummy, sizeof(magic64)); 3635 break; 3636 } 3637 break; 3638 default: 3639 break; 3640 } 3641 3642 /* Prepare variables for PIOD and AUXV transfers */ 3643 switch (type) { 3644 case BYTES_TRANSFER_TEXTIO: 3645 case BYTES_TRANSFER_DATAIO: 3646 io.piod_op = operation; 3647 switch (size) { 3648 case 8: 3649 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3650 (void *)bytes_transfer_dummy : 3651 &lookup_me8; 3652 io.piod_addr = &lookup_me8; 3653 io.piod_len = sizeof(lookup_me8); 3654 break; 3655 case 16: 3656 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3657 (void *)bytes_transfer_dummy : 3658 &lookup_me16; 3659 io.piod_addr = &lookup_me16; 3660 io.piod_len = sizeof(lookup_me16); 3661 break; 3662 case 32: 3663 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3664 (void *)bytes_transfer_dummy : 3665 &lookup_me32; 3666 io.piod_addr = &lookup_me32; 3667 io.piod_len = sizeof(lookup_me32); 3668 break; 3669 case 64: 3670 io.piod_offs = (type == BYTES_TRANSFER_TEXTIO) ? 3671 (void *)bytes_transfer_dummy : 3672 &lookup_me64; 3673 io.piod_addr = &lookup_me64; 3674 io.piod_len = sizeof(lookup_me64); 3675 break; 3676 default: 3677 break; 3678 } 3679 break; 3680 case BYTES_TRANSFER_AUXV: 3681 io.piod_op = operation; 3682 io.piod_offs = 0; 3683 io.piod_addr = ai; 3684 io.piod_len = size; 3685 break; 3686 default: 3687 break; 3688 } 3689 3690 DPRINTF("Before forking process PID=%d\n", getpid()); 3691 SYSCALL_REQUIRE((child = fork()) != -1); 3692 if (child == 0) { 3693 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3694 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3695 3696 switch (type) { 3697 case BYTES_TRANSFER_DATA: 3698 switch (operation) { 3699 case PT_READ_D: 3700 case PT_READ_I: 3701 lookup_me = magic; 3702 break; 3703 default: 3704 break; 3705 } 3706 break; 3707 case BYTES_TRANSFER_DATAIO: 3708 switch (operation) { 3709 case PIOD_READ_D: 3710 case PIOD_READ_I: 3711 switch (size) { 3712 case 8: 3713 lookup_me8 = magic8; 3714 break; 3715 case 16: 3716 lookup_me16 = magic16; 3717 break; 3718 case 32: 3719 lookup_me32 = magic32; 3720 break; 3721 case 64: 3722 lookup_me64 = magic64; 3723 break; 3724 default: 3725 break; 3726 } 3727 break; 3728 default: 3729 break; 3730 } 3731 default: 3732 break; 3733 } 3734 3735 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 3736 FORKEE_ASSERT(raise(sigval) == 0); 3737 3738 /* Handle PIOD and PT separately as operation values overlap */ 3739 switch (type) { 3740 case BYTES_TRANSFER_DATA: 3741 switch (operation) { 3742 case PT_WRITE_D: 3743 case PT_WRITE_I: 3744 FORKEE_ASSERT_EQ(lookup_me, magic); 3745 break; 3746 default: 3747 break; 3748 } 3749 break; 3750 case BYTES_TRANSFER_DATAIO: 3751 switch (operation) { 3752 case PIOD_WRITE_D: 3753 case PIOD_WRITE_I: 3754 switch (size) { 3755 case 8: 3756 FORKEE_ASSERT_EQ(lookup_me8, magic8); 3757 break; 3758 case 16: 3759 FORKEE_ASSERT_EQ(lookup_me16, magic16); 3760 break; 3761 case 32: 3762 FORKEE_ASSERT_EQ(lookup_me32, magic32); 3763 break; 3764 case 64: 3765 FORKEE_ASSERT_EQ(lookup_me64, magic64); 3766 break; 3767 default: 3768 break; 3769 } 3770 break; 3771 default: 3772 break; 3773 } 3774 break; 3775 case BYTES_TRANSFER_TEXT: 3776 FORKEE_ASSERT(memcmp(&magic, bytes_transfer_dummy, 3777 sizeof(magic)) == 0); 3778 break; 3779 case BYTES_TRANSFER_TEXTIO: 3780 switch (size) { 3781 case 8: 3782 FORKEE_ASSERT(memcmp(&magic8, 3783 bytes_transfer_dummy, 3784 sizeof(magic8)) == 0); 3785 break; 3786 case 16: 3787 FORKEE_ASSERT(memcmp(&magic16, 3788 bytes_transfer_dummy, 3789 sizeof(magic16)) == 0); 3790 break; 3791 case 32: 3792 FORKEE_ASSERT(memcmp(&magic32, 3793 bytes_transfer_dummy, 3794 sizeof(magic32)) == 0); 3795 break; 3796 case 64: 3797 FORKEE_ASSERT(memcmp(&magic64, 3798 bytes_transfer_dummy, 3799 sizeof(magic64)) == 0); 3800 break; 3801 } 3802 break; 3803 default: 3804 break; 3805 } 3806 3807 DPRINTF("Before exiting of the child process\n"); 3808 _exit(exitval); 3809 } 3810 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3811 3812 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3813 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3814 3815 validate_status_stopped(status, sigval); 3816 3817 /* Check PaX MPROTECT */ 3818 if (!can_we_write_to_text(child)) { 3819 switch (type) { 3820 case BYTES_TRANSFER_TEXTIO: 3821 switch (operation) { 3822 case PIOD_WRITE_D: 3823 case PIOD_WRITE_I: 3824 skip = true; 3825 break; 3826 default: 3827 break; 3828 } 3829 break; 3830 case BYTES_TRANSFER_TEXT: 3831 switch (operation) { 3832 case PT_WRITE_D: 3833 case PT_WRITE_I: 3834 skip = true; 3835 break; 3836 default: 3837 break; 3838 } 3839 break; 3840 default: 3841 break; 3842 } 3843 } 3844 3845 /* Bailout cleanly killing the child process */ 3846 if (skip) { 3847 SYSCALL_REQUIRE(ptrace(PT_KILL, child, (void *)1, 0) != -1); 3848 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3849 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 3850 child); 3851 3852 validate_status_signaled(status, SIGKILL, 0); 3853 3854 atf_tc_skip("PaX MPROTECT setup prevents writes to .text"); 3855 } 3856 3857 DPRINTF("Calling operation to transfer bytes between child=%d and " 3858 "parent=%d\n", child, getpid()); 3859 3860 switch (type) { 3861 case BYTES_TRANSFER_TEXTIO: 3862 case BYTES_TRANSFER_DATAIO: 3863 case BYTES_TRANSFER_AUXV: 3864 switch (operation) { 3865 case PIOD_WRITE_D: 3866 case PIOD_WRITE_I: 3867 switch (size) { 3868 case 8: 3869 lookup_me8 = magic8; 3870 break; 3871 case 16: 3872 lookup_me16 = magic16; 3873 break; 3874 case 32: 3875 lookup_me32 = magic32; 3876 break; 3877 case 64: 3878 lookup_me64 = magic64; 3879 break; 3880 default: 3881 break; 3882 } 3883 break; 3884 default: 3885 break; 3886 } 3887 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1); 3888 switch (operation) { 3889 case PIOD_READ_D: 3890 case PIOD_READ_I: 3891 switch (size) { 3892 case 8: 3893 ATF_REQUIRE_EQ(lookup_me8, magic8); 3894 break; 3895 case 16: 3896 ATF_REQUIRE_EQ(lookup_me16, magic16); 3897 break; 3898 case 32: 3899 ATF_REQUIRE_EQ(lookup_me32, magic32); 3900 break; 3901 case 64: 3902 ATF_REQUIRE_EQ(lookup_me64, magic64); 3903 break; 3904 default: 3905 break; 3906 } 3907 break; 3908 case PIOD_READ_AUXV: 3909 DPRINTF("Asserting that AUXV length (%zu) is > 0\n", 3910 io.piod_len); 3911 ATF_REQUIRE(io.piod_len > 0); 3912 for (aip = ai; aip->a_type != AT_NULL; aip++) 3913 DPRINTF("a_type=%#llx a_v=%#llx\n", 3914 (long long int)aip->a_type, 3915 (long long int)aip->a_v); 3916 break; 3917 default: 3918 break; 3919 } 3920 break; 3921 case BYTES_TRANSFER_TEXT: 3922 switch (operation) { 3923 case PT_READ_D: 3924 case PT_READ_I: 3925 errno = 0; 3926 lookup_me = ptrace(operation, child, 3927 bytes_transfer_dummy, 0); 3928 ATF_REQUIRE_EQ(lookup_me, magic); 3929 SYSCALL_REQUIRE_ERRNO(errno, 0); 3930 break; 3931 case PT_WRITE_D: 3932 case PT_WRITE_I: 3933 SYSCALL_REQUIRE(ptrace(operation, child, 3934 bytes_transfer_dummy, magic) 3935 != -1); 3936 break; 3937 default: 3938 break; 3939 } 3940 break; 3941 case BYTES_TRANSFER_DATA: 3942 switch (operation) { 3943 case PT_READ_D: 3944 case PT_READ_I: 3945 errno = 0; 3946 lookup_me = ptrace(operation, child, &lookup_me, 0); 3947 ATF_REQUIRE_EQ(lookup_me, magic); 3948 SYSCALL_REQUIRE_ERRNO(errno, 0); 3949 break; 3950 case PT_WRITE_D: 3951 case PT_WRITE_I: 3952 lookup_me = magic; 3953 SYSCALL_REQUIRE(ptrace(operation, child, &lookup_me, 3954 magic) != -1); 3955 break; 3956 default: 3957 break; 3958 } 3959 break; 3960 default: 3961 break; 3962 } 3963 3964 DPRINTF("Before resuming the child process where it left off and " 3965 "without signal to be sent\n"); 3966 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 3967 3968 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3969 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3970 3971 validate_status_exited(status, exitval); 3972 3973 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3974 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 3975} 3976 3977#define BYTES_TRANSFER(test, operation, size, type) \ 3978ATF_TC(test); \ 3979ATF_TC_HEAD(test, tc) \ 3980{ \ 3981 atf_tc_set_md_var(tc, "descr", \ 3982 "Verify bytes transfer operation" #operation " and size " #size \ 3983 " of type " #type); \ 3984} \ 3985 \ 3986ATF_TC_BODY(test, tc) \ 3987{ \ 3988 \ 3989 bytes_transfer(operation, size, BYTES_TRANSFER_##type); \ 3990} 3991 3992// DATA 3993 3994BYTES_TRANSFER(bytes_transfer_piod_read_d_8, PIOD_READ_D, 8, DATAIO) 3995BYTES_TRANSFER(bytes_transfer_piod_read_d_16, PIOD_READ_D, 16, DATAIO) 3996BYTES_TRANSFER(bytes_transfer_piod_read_d_32, PIOD_READ_D, 32, DATAIO) 3997BYTES_TRANSFER(bytes_transfer_piod_read_d_64, PIOD_READ_D, 64, DATAIO) 3998 3999BYTES_TRANSFER(bytes_transfer_piod_read_i_8, PIOD_READ_I, 8, DATAIO) 4000BYTES_TRANSFER(bytes_transfer_piod_read_i_16, PIOD_READ_I, 16, DATAIO) 4001BYTES_TRANSFER(bytes_transfer_piod_read_i_32, PIOD_READ_I, 32, DATAIO) 4002BYTES_TRANSFER(bytes_transfer_piod_read_i_64, PIOD_READ_I, 64, DATAIO) 4003 4004BYTES_TRANSFER(bytes_transfer_piod_write_d_8, PIOD_WRITE_D, 8, DATAIO) 4005BYTES_TRANSFER(bytes_transfer_piod_write_d_16, PIOD_WRITE_D, 16, DATAIO) 4006BYTES_TRANSFER(bytes_transfer_piod_write_d_32, PIOD_WRITE_D, 32, DATAIO) 4007BYTES_TRANSFER(bytes_transfer_piod_write_d_64, PIOD_WRITE_D, 64, DATAIO) 4008 4009BYTES_TRANSFER(bytes_transfer_piod_write_i_8, PIOD_WRITE_I, 8, DATAIO) 4010BYTES_TRANSFER(bytes_transfer_piod_write_i_16, PIOD_WRITE_I, 16, DATAIO) 4011BYTES_TRANSFER(bytes_transfer_piod_write_i_32, PIOD_WRITE_I, 32, DATAIO) 4012BYTES_TRANSFER(bytes_transfer_piod_write_i_64, PIOD_WRITE_I, 64, DATAIO) 4013 4014BYTES_TRANSFER(bytes_transfer_read_d, PT_READ_D, 32, DATA) 4015BYTES_TRANSFER(bytes_transfer_read_i, PT_READ_I, 32, DATA) 4016BYTES_TRANSFER(bytes_transfer_write_d, PT_WRITE_D, 32, DATA) 4017BYTES_TRANSFER(bytes_transfer_write_i, PT_WRITE_I, 32, DATA) 4018 4019// TEXT 4020 4021BYTES_TRANSFER(bytes_transfer_piod_read_d_8_text, PIOD_READ_D, 8, TEXTIO) 4022BYTES_TRANSFER(bytes_transfer_piod_read_d_16_text, PIOD_READ_D, 16, TEXTIO) 4023BYTES_TRANSFER(bytes_transfer_piod_read_d_32_text, PIOD_READ_D, 32, TEXTIO) 4024BYTES_TRANSFER(bytes_transfer_piod_read_d_64_text, PIOD_READ_D, 64, TEXTIO) 4025 4026BYTES_TRANSFER(bytes_transfer_piod_read_i_8_text, PIOD_READ_I, 8, TEXTIO) 4027BYTES_TRANSFER(bytes_transfer_piod_read_i_16_text, PIOD_READ_I, 16, TEXTIO) 4028BYTES_TRANSFER(bytes_transfer_piod_read_i_32_text, PIOD_READ_I, 32, TEXTIO) 4029BYTES_TRANSFER(bytes_transfer_piod_read_i_64_text, PIOD_READ_I, 64, TEXTIO) 4030 4031BYTES_TRANSFER(bytes_transfer_piod_write_d_8_text, PIOD_WRITE_D, 8, TEXTIO) 4032BYTES_TRANSFER(bytes_transfer_piod_write_d_16_text, PIOD_WRITE_D, 16, TEXTIO) 4033BYTES_TRANSFER(bytes_transfer_piod_write_d_32_text, PIOD_WRITE_D, 32, TEXTIO) 4034BYTES_TRANSFER(bytes_transfer_piod_write_d_64_text, PIOD_WRITE_D, 64, TEXTIO) 4035 4036BYTES_TRANSFER(bytes_transfer_piod_write_i_8_text, PIOD_WRITE_I, 8, TEXTIO) 4037BYTES_TRANSFER(bytes_transfer_piod_write_i_16_text, PIOD_WRITE_I, 16, TEXTIO) 4038BYTES_TRANSFER(bytes_transfer_piod_write_i_32_text, PIOD_WRITE_I, 32, TEXTIO) 4039BYTES_TRANSFER(bytes_transfer_piod_write_i_64_text, PIOD_WRITE_I, 64, TEXTIO) 4040 4041BYTES_TRANSFER(bytes_transfer_read_d_text, PT_READ_D, 32, TEXT) 4042BYTES_TRANSFER(bytes_transfer_read_i_text, PT_READ_I, 32, TEXT) 4043BYTES_TRANSFER(bytes_transfer_write_d_text, PT_WRITE_D, 32, TEXT) 4044BYTES_TRANSFER(bytes_transfer_write_i_text, PT_WRITE_I, 32, TEXT) 4045 4046// AUXV 4047 4048BYTES_TRANSFER(bytes_transfer_piod_read_auxv, PIOD_READ_AUXV, 4096, AUXV) 4049 4050/// ---------------------------------------------------------------------------- 4051 4052static void 4053bytes_transfer_alignment(const char *operation) 4054{ 4055 const int exitval = 5; 4056 const int sigval = SIGSTOP; 4057 pid_t child, wpid; 4058#if defined(TWAIT_HAVE_STATUS) 4059 int status; 4060#endif 4061 char *buffer; 4062 int vector; 4063 size_t len; 4064 size_t i; 4065 int op; 4066 4067 struct ptrace_io_desc io; 4068 struct ptrace_siginfo info; 4069 4070 memset(&io, 0, sizeof(io)); 4071 memset(&info, 0, sizeof(info)); 4072 4073 /* Testing misaligned byte transfer crossing page boundaries */ 4074 len = sysconf(_SC_PAGESIZE) * 2; 4075 buffer = malloc(len); 4076 ATF_REQUIRE(buffer != NULL); 4077 4078 /* Initialize the buffer with random data */ 4079 for (i = 0; i < len; i++) 4080 buffer[i] = i & 0xff; 4081 4082 DPRINTF("Before forking process PID=%d\n", getpid()); 4083 SYSCALL_REQUIRE((child = fork()) != -1); 4084 if (child == 0) { 4085 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4086 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4087 4088 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4089 FORKEE_ASSERT(raise(sigval) == 0); 4090 4091 DPRINTF("Before exiting of the child process\n"); 4092 _exit(exitval); 4093 } 4094 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4095 4096 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4097 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4098 4099 validate_status_stopped(status, sigval); 4100 4101 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4102 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) 4103 != -1); 4104 4105 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4106 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 4107 "si_errno=%#x\n", 4108 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4109 info.psi_siginfo.si_errno); 4110 4111 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4112 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4113 4114 if (strcmp(operation, "PT_READ_I") == 0 || 4115 strcmp(operation, "PT_READ_D") == 0) { 4116 if (strcmp(operation, "PT_READ_I")) 4117 op = PT_READ_I; 4118 else 4119 op = PT_READ_D; 4120 4121 for (i = 0; i <= (len - sizeof(int)); i++) { 4122 errno = 0; 4123 vector = ptrace(op, child, buffer + i, 0); 4124 ATF_REQUIRE_EQ(errno, 0); 4125 ATF_REQUIRE(!memcmp(&vector, buffer + i, sizeof(int))); 4126 } 4127 } else if (strcmp(operation, "PT_WRITE_I") == 0 || 4128 strcmp(operation, "PT_WRITE_D") == 0) { 4129 if (strcmp(operation, "PT_WRITE_I")) 4130 op = PT_WRITE_I; 4131 else 4132 op = PT_WRITE_D; 4133 4134 for (i = 0; i <= (len - sizeof(int)); i++) { 4135 memcpy(&vector, buffer + i, sizeof(int)); 4136 SYSCALL_REQUIRE(ptrace(op, child, buffer + 1, vector) 4137 != -1); 4138 } 4139 } else if (strcmp(operation, "PIOD_READ_I") == 0 || 4140 strcmp(operation, "PIOD_READ_D") == 0) { 4141 if (strcmp(operation, "PIOD_READ_I")) 4142 op = PIOD_READ_I; 4143 else 4144 op = PIOD_READ_D; 4145 4146 io.piod_op = op; 4147 io.piod_addr = &vector; 4148 io.piod_len = sizeof(int); 4149 4150 for (i = 0; i <= (len - sizeof(int)); i++) { 4151 io.piod_offs = buffer + i; 4152 4153 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4154 != -1); 4155 ATF_REQUIRE(!memcmp(&vector, buffer + i, sizeof(int))); 4156 } 4157 } else if (strcmp(operation, "PIOD_WRITE_I") == 0 || 4158 strcmp(operation, "PIOD_WRITE_D") == 0) { 4159 if (strcmp(operation, "PIOD_WRITE_I")) 4160 op = PIOD_WRITE_I; 4161 else 4162 op = PIOD_WRITE_D; 4163 4164 io.piod_op = op; 4165 io.piod_addr = &vector; 4166 io.piod_len = sizeof(int); 4167 4168 for (i = 0; i <= (len - sizeof(int)); i++) { 4169 io.piod_offs = buffer + i; 4170 4171 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4172 != -1); 4173 } 4174 } else if (strcmp(operation, "PIOD_READ_AUXV") == 0) { 4175 io.piod_op = PIOD_READ_AUXV; 4176 io.piod_addr = &vector; 4177 io.piod_len = sizeof(int); 4178 4179 errno = 0; 4180 i = 0; 4181 /* Read the whole AUXV vector, it has no clear length */ 4182 while (io.piod_len > 0) { 4183 io.piod_offs = (void *)(intptr_t)i; 4184 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) 4185 != -1 || (io.piod_len == 0 && i > 0)); 4186 ++i; 4187 } 4188 } 4189 4190 DPRINTF("Before resuming the child process where it left off " 4191 "and without signal to be sent\n"); 4192 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4193 4194 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4195 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4196 child); 4197 4198 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4199 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4200} 4201 4202#define BYTES_TRANSFER_ALIGNMENT(test, operation) \ 4203ATF_TC(test); \ 4204ATF_TC_HEAD(test, tc) \ 4205{ \ 4206 atf_tc_set_md_var(tc, "descr", \ 4207 "Verify bytes transfer for potentially misaligned " \ 4208 "operation " operation); \ 4209} \ 4210 \ 4211ATF_TC_BODY(test, tc) \ 4212{ \ 4213 \ 4214 bytes_transfer_alignment(operation); \ 4215} 4216 4217BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_read_i, "PT_READ_I") 4218BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_read_d, "PT_READ_D") 4219BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_write_i, "PT_WRITE_I") 4220BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_pt_write_d, "PT_WRITE_D") 4221 4222BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_i, "PIOD_READ_I") 4223BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_d, "PIOD_READ_D") 4224BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_write_i, "PIOD_WRITE_I") 4225BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_write_d, "PIOD_WRITE_D") 4226 4227BYTES_TRANSFER_ALIGNMENT(bytes_transfer_alignment_piod_read_auxv, "PIOD_READ_AUXV") 4228 4229/// ---------------------------------------------------------------------------- 4230 4231static void 4232bytes_transfer_eof(const char *operation) 4233{ 4234 const int exitval = 5; 4235 const int sigval = SIGSTOP; 4236 pid_t child, wpid; 4237#if defined(TWAIT_HAVE_STATUS) 4238 int status; 4239#endif 4240 FILE *fp; 4241 char *p; 4242 int vector; 4243 int op; 4244 4245 struct ptrace_io_desc io; 4246 struct ptrace_siginfo info; 4247 4248 memset(&io, 0, sizeof(io)); 4249 memset(&info, 0, sizeof(info)); 4250 4251 vector = 0; 4252 4253 fp = tmpfile(); 4254 ATF_REQUIRE(fp != NULL); 4255 4256 p = mmap(0, 1, PROT_READ|PROT_WRITE, MAP_PRIVATE, fileno(fp), 0); 4257 ATF_REQUIRE(p != MAP_FAILED); 4258 4259 DPRINTF("Before forking process PID=%d\n", getpid()); 4260 SYSCALL_REQUIRE((child = fork()) != -1); 4261 if (child == 0) { 4262 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4263 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4264 4265 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4266 FORKEE_ASSERT(raise(sigval) == 0); 4267 4268 DPRINTF("Before exiting of the child process\n"); 4269 _exit(exitval); 4270 } 4271 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4272 4273 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4274 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4275 4276 validate_status_stopped(status, sigval); 4277 4278 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4279 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) 4280 != -1); 4281 4282 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4283 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 4284 "si_errno=%#x\n", 4285 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4286 info.psi_siginfo.si_errno); 4287 4288 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4289 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4290 4291 if (strcmp(operation, "PT_READ_I") == 0 || 4292 strcmp(operation, "PT_READ_D") == 0) { 4293 if (strcmp(operation, "PT_READ_I")) 4294 op = PT_READ_I; 4295 else 4296 op = PT_READ_D; 4297 4298 errno = 0; 4299 SYSCALL_REQUIRE(ptrace(op, child, p, 0) == -1); 4300 ATF_REQUIRE_EQ(errno, EINVAL); 4301 } else if (strcmp(operation, "PT_WRITE_I") == 0 || 4302 strcmp(operation, "PT_WRITE_D") == 0) { 4303 if (strcmp(operation, "PT_WRITE_I")) 4304 op = PT_WRITE_I; 4305 else 4306 op = PT_WRITE_D; 4307 4308 errno = 0; 4309 SYSCALL_REQUIRE(ptrace(op, child, p, vector) == -1); 4310 ATF_REQUIRE_EQ(errno, EINVAL); 4311 } else if (strcmp(operation, "PIOD_READ_I") == 0 || 4312 strcmp(operation, "PIOD_READ_D") == 0) { 4313 if (strcmp(operation, "PIOD_READ_I")) 4314 op = PIOD_READ_I; 4315 else 4316 op = PIOD_READ_D; 4317 4318 io.piod_op = op; 4319 io.piod_addr = &vector; 4320 io.piod_len = sizeof(int); 4321 io.piod_offs = p; 4322 4323 errno = 0; 4324 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) == -1); 4325 ATF_REQUIRE_EQ(errno, EINVAL); 4326 } else if (strcmp(operation, "PIOD_WRITE_I") == 0 || 4327 strcmp(operation, "PIOD_WRITE_D") == 0) { 4328 if (strcmp(operation, "PIOD_WRITE_I")) 4329 op = PIOD_WRITE_I; 4330 else 4331 op = PIOD_WRITE_D; 4332 4333 io.piod_op = op; 4334 io.piod_addr = &vector; 4335 io.piod_len = sizeof(int); 4336 io.piod_offs = p; 4337 4338 errno = 0; 4339 SYSCALL_REQUIRE(ptrace(PT_IO, child, &io, sizeof(io)) == -1); 4340 ATF_REQUIRE_EQ(errno, EINVAL); 4341 } 4342 4343 DPRINTF("Before resuming the child process where it left off " 4344 "and without signal to be sent\n"); 4345 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4346 4347 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4348 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4349 child); 4350 4351 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4352 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4353} 4354 4355#define BYTES_TRANSFER_EOF(test, operation) \ 4356ATF_TC(test); \ 4357ATF_TC_HEAD(test, tc) \ 4358{ \ 4359 atf_tc_set_md_var(tc, "descr", \ 4360 "Verify bytes EOF byte transfer for the " operation \ 4361 " operation"); \ 4362} \ 4363 \ 4364ATF_TC_BODY(test, tc) \ 4365{ \ 4366 \ 4367 bytes_transfer_eof(operation); \ 4368} 4369 4370BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_read_i, "PT_READ_I") 4371BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_read_d, "PT_READ_D") 4372BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_write_i, "PT_WRITE_I") 4373BYTES_TRANSFER_EOF(bytes_transfer_eof_pt_write_d, "PT_WRITE_D") 4374 4375BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_read_i, "PIOD_READ_I") 4376BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_read_d, "PIOD_READ_D") 4377BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_write_i, "PIOD_WRITE_I") 4378BYTES_TRANSFER_EOF(bytes_transfer_eof_piod_write_d, "PIOD_WRITE_D") 4379 4380/// ---------------------------------------------------------------------------- 4381 4382#if defined(HAVE_GPREGS) || defined(HAVE_FPREGS) 4383static void 4384access_regs(const char *regset, const char *aux) 4385{ 4386 const int exitval = 5; 4387 const int sigval = SIGSTOP; 4388 pid_t child, wpid; 4389#if defined(TWAIT_HAVE_STATUS) 4390 int status; 4391#endif 4392#if defined(HAVE_GPREGS) 4393 struct reg gpr; 4394 register_t rgstr; 4395#endif 4396#if defined(HAVE_FPREGS) 4397 struct fpreg fpr; 4398#endif 4399 4400#if !defined(HAVE_GPREGS) 4401 if (strcmp(regset, "regs") == 0) 4402 atf_tc_fail("Impossible test scenario!"); 4403#endif 4404 4405#if !defined(HAVE_FPREGS) 4406 if (strcmp(regset, "fpregs") == 0) 4407 atf_tc_fail("Impossible test scenario!"); 4408#endif 4409 4410 DPRINTF("Before forking process PID=%d\n", getpid()); 4411 SYSCALL_REQUIRE((child = fork()) != -1); 4412 if (child == 0) { 4413 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4414 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4415 4416 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4417 FORKEE_ASSERT(raise(sigval) == 0); 4418 4419 DPRINTF("Before exiting of the child process\n"); 4420 _exit(exitval); 4421 } 4422 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4423 4424 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4425 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4426 4427 validate_status_stopped(status, sigval); 4428 4429#if defined(HAVE_GPREGS) 4430 if (strcmp(regset, "regs") == 0) { 4431 DPRINTF("Call GETREGS for the child process\n"); 4432 SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1); 4433 4434 if (strcmp(aux, "none") == 0) { 4435 DPRINTF("Retrieved registers\n"); 4436 } else if (strcmp(aux, "pc") == 0) { 4437 rgstr = PTRACE_REG_PC(&gpr); 4438 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4439 } else if (strcmp(aux, "set_pc") == 0) { 4440 rgstr = PTRACE_REG_PC(&gpr); 4441 PTRACE_REG_SET_PC(&gpr, rgstr); 4442 } else if (strcmp(aux, "sp") == 0) { 4443 rgstr = PTRACE_REG_SP(&gpr); 4444 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4445 } else if (strcmp(aux, "intrv") == 0) { 4446 rgstr = PTRACE_REG_INTRV(&gpr); 4447 DPRINTF("Retrieved %" PRIxREGISTER "\n", rgstr); 4448 } else if (strcmp(aux, "setregs") == 0) { 4449 DPRINTF("Call SETREGS for the child process\n"); 4450 SYSCALL_REQUIRE( 4451 ptrace(PT_GETREGS, child, &gpr, 0) != -1); 4452 } 4453 } 4454#endif 4455 4456#if defined(HAVE_FPREGS) 4457 if (strcmp(regset, "fpregs") == 0) { 4458 DPRINTF("Call GETFPREGS for the child process\n"); 4459 SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1); 4460 4461 if (strcmp(aux, "getfpregs") == 0) { 4462 DPRINTF("Retrieved FP registers\n"); 4463 } else if (strcmp(aux, "setfpregs") == 0) { 4464 DPRINTF("Call SETFPREGS for the child\n"); 4465 SYSCALL_REQUIRE( 4466 ptrace(PT_SETFPREGS, child, &fpr, 0) != -1); 4467 } 4468 } 4469#endif 4470 4471 DPRINTF("Before resuming the child process where it left off and " 4472 "without signal to be sent\n"); 4473 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4474 4475 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4476 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4477 4478 validate_status_exited(status, exitval); 4479 4480 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4481 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4482} 4483 4484#define ACCESS_REGS(test, regset, aux) \ 4485ATF_TC(test); \ 4486ATF_TC_HEAD(test, tc) \ 4487{ \ 4488 atf_tc_set_md_var(tc, "descr", \ 4489 "Verify " regset " with auxiliary operation: " aux); \ 4490} \ 4491 \ 4492ATF_TC_BODY(test, tc) \ 4493{ \ 4494 \ 4495 access_regs(regset, aux); \ 4496} 4497#endif 4498 4499#if defined(HAVE_GPREGS) 4500ACCESS_REGS(access_regs1, "regs", "none") 4501ACCESS_REGS(access_regs2, "regs", "pc") 4502ACCESS_REGS(access_regs3, "regs", "set_pc") 4503ACCESS_REGS(access_regs4, "regs", "sp") 4504ACCESS_REGS(access_regs5, "regs", "intrv") 4505ACCESS_REGS(access_regs6, "regs", "setregs") 4506#endif 4507#if defined(HAVE_FPREGS) 4508ACCESS_REGS(access_fpregs1, "fpregs", "getfpregs") 4509ACCESS_REGS(access_fpregs2, "fpregs", "setfpregs") 4510#endif 4511 4512/// ---------------------------------------------------------------------------- 4513 4514#if defined(PT_STEP) 4515static void 4516ptrace_step(int N, int setstep, bool masked, bool ignored) 4517{ 4518 const int exitval = 5; 4519 const int sigval = SIGSTOP; 4520 pid_t child, wpid; 4521#if defined(TWAIT_HAVE_STATUS) 4522 int status; 4523#endif 4524 int happy; 4525 struct sigaction sa; 4526 struct ptrace_siginfo info; 4527 sigset_t intmask; 4528 struct kinfo_proc2 kp; 4529 size_t len = sizeof(kp); 4530 4531 int name[6]; 4532 const size_t namelen = __arraycount(name); 4533 ki_sigset_t kp_sigmask; 4534 ki_sigset_t kp_sigignore; 4535 4536#if defined(__arm__) 4537 /* PT_STEP not supported on arm 32-bit */ 4538 atf_tc_expect_fail("PR kern/52119"); 4539#endif 4540 4541 DPRINTF("Before forking process PID=%d\n", getpid()); 4542 SYSCALL_REQUIRE((child = fork()) != -1); 4543 if (child == 0) { 4544 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4545 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4546 4547 if (masked) { 4548 sigemptyset(&intmask); 4549 sigaddset(&intmask, SIGTRAP); 4550 sigprocmask(SIG_BLOCK, &intmask, NULL); 4551 } 4552 4553 if (ignored) { 4554 memset(&sa, 0, sizeof(sa)); 4555 sa.sa_handler = SIG_IGN; 4556 sigemptyset(&sa.sa_mask); 4557 FORKEE_ASSERT(sigaction(SIGTRAP, &sa, NULL) != -1); 4558 } 4559 4560 happy = check_happy(999); 4561 4562 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4563 FORKEE_ASSERT(raise(sigval) == 0); 4564 4565 FORKEE_ASSERT_EQ(happy, check_happy(999)); 4566 4567 DPRINTF("Before exiting of the child process\n"); 4568 _exit(exitval); 4569 } 4570 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4571 4572 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4573 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4574 4575 validate_status_stopped(status, sigval); 4576 4577 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4578 SYSCALL_REQUIRE( 4579 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4580 4581 DPRINTF("Before checking siginfo_t\n"); 4582 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4583 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4584 4585 name[0] = CTL_KERN, 4586 name[1] = KERN_PROC2, 4587 name[2] = KERN_PROC_PID; 4588 name[3] = child; 4589 name[4] = sizeof(kp); 4590 name[5] = 1; 4591 4592 FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 4593 4594 if (masked) 4595 kp_sigmask = kp.p_sigmask; 4596 4597 if (ignored) 4598 kp_sigignore = kp.p_sigignore; 4599 4600 while (N --> 0) { 4601 if (setstep) { 4602 DPRINTF("Before resuming the child process where it " 4603 "left off and without signal to be sent (use " 4604 "PT_SETSTEP and PT_CONTINUE)\n"); 4605 SYSCALL_REQUIRE(ptrace(PT_SETSTEP, child, 0, 0) != -1); 4606 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) 4607 != -1); 4608 } else { 4609 DPRINTF("Before resuming the child process where it " 4610 "left off and without signal to be sent (use " 4611 "PT_STEP)\n"); 4612 SYSCALL_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) 4613 != -1); 4614 } 4615 4616 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4617 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 4618 child); 4619 4620 validate_status_stopped(status, SIGTRAP); 4621 4622 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 4623 SYSCALL_REQUIRE( 4624 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4625 4626 DPRINTF("Before checking siginfo_t\n"); 4627 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 4628 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_TRACE); 4629 4630 if (setstep) { 4631 SYSCALL_REQUIRE(ptrace(PT_CLEARSTEP, child, 0, 0) != -1); 4632 } 4633 4634 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 4635 4636 if (masked) { 4637 DPRINTF("kp_sigmask=" 4638 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4639 PRIx32 "\n", 4640 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 4641 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 4642 4643 DPRINTF("kp.p_sigmask=" 4644 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4645 PRIx32 "\n", 4646 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 4647 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 4648 4649 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 4650 sizeof(kp_sigmask))); 4651 } 4652 4653 if (ignored) { 4654 DPRINTF("kp_sigignore=" 4655 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4656 PRIx32 "\n", 4657 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 4658 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 4659 4660 DPRINTF("kp.p_sigignore=" 4661 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" 4662 PRIx32 "\n", 4663 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 4664 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 4665 4666 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 4667 sizeof(kp_sigignore))); 4668 } 4669 } 4670 4671 DPRINTF("Before resuming the child process where it left off and " 4672 "without signal to be sent\n"); 4673 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4674 4675 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4676 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4677 4678 validate_status_exited(status, exitval); 4679 4680 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4681 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4682} 4683 4684#define PTRACE_STEP(test, N, setstep) \ 4685ATF_TC(test); \ 4686ATF_TC_HEAD(test, tc) \ 4687{ \ 4688 atf_tc_set_md_var(tc, "descr", \ 4689 "Verify " #N " (PT_SETSTEP set to: " #setstep ")"); \ 4690} \ 4691 \ 4692ATF_TC_BODY(test, tc) \ 4693{ \ 4694 \ 4695 ptrace_step(N, setstep, false, false); \ 4696} 4697 4698PTRACE_STEP(step1, 1, 0) 4699PTRACE_STEP(step2, 2, 0) 4700PTRACE_STEP(step3, 3, 0) 4701PTRACE_STEP(step4, 4, 0) 4702PTRACE_STEP(setstep1, 1, 1) 4703PTRACE_STEP(setstep2, 2, 1) 4704PTRACE_STEP(setstep3, 3, 1) 4705PTRACE_STEP(setstep4, 4, 1) 4706 4707ATF_TC(step_signalmasked); 4708ATF_TC_HEAD(step_signalmasked, tc) 4709{ 4710 atf_tc_set_md_var(tc, "descr", "Verify PT_STEP with masked SIGTRAP"); 4711} 4712 4713ATF_TC_BODY(step_signalmasked, tc) 4714{ 4715 4716 ptrace_step(1, 0, true, false); 4717} 4718 4719ATF_TC(step_signalignored); 4720ATF_TC_HEAD(step_signalignored, tc) 4721{ 4722 atf_tc_set_md_var(tc, "descr", "Verify PT_STEP with ignored SIGTRAP"); 4723} 4724 4725ATF_TC_BODY(step_signalignored, tc) 4726{ 4727 4728 ptrace_step(1, 0, false, true); 4729} 4730#endif 4731 4732/// ---------------------------------------------------------------------------- 4733 4734static void 4735ptrace_kill(const char *type) 4736{ 4737 const int sigval = SIGSTOP; 4738 pid_t child, wpid; 4739#if defined(TWAIT_HAVE_STATUS) 4740 int status; 4741#endif 4742 4743 DPRINTF("Before forking process PID=%d\n", getpid()); 4744 SYSCALL_REQUIRE((child = fork()) != -1); 4745 if (child == 0) { 4746 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4747 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4748 4749 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4750 FORKEE_ASSERT(raise(sigval) == 0); 4751 4752 /* NOTREACHED */ 4753 FORKEE_ASSERTX(0 && 4754 "Child should be terminated by a signal from its parent"); 4755 } 4756 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4757 4758 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4759 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4760 4761 validate_status_stopped(status, sigval); 4762 4763 DPRINTF("Before killing the child process with %s\n", type); 4764 if (strcmp(type, "ptrace(PT_KILL)") == 0) { 4765 SYSCALL_REQUIRE(ptrace(PT_KILL, child, (void*)1, 0) != -1); 4766 } else if (strcmp(type, "kill(SIGKILL)") == 0) { 4767 kill(child, SIGKILL); 4768 } else if (strcmp(type, "killpg(SIGKILL)") == 0) { 4769 setpgid(child, 0); 4770 killpg(getpgid(child), SIGKILL); 4771 } 4772 4773 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4774 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4775 4776 validate_status_signaled(status, SIGKILL, 0); 4777 4778 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4779 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4780} 4781 4782#define PTRACE_KILL(test, type) \ 4783ATF_TC(test); \ 4784ATF_TC_HEAD(test, tc) \ 4785{ \ 4786 atf_tc_set_md_var(tc, "descr", \ 4787 "Verify killing the child with " type); \ 4788} \ 4789 \ 4790ATF_TC_BODY(test, tc) \ 4791{ \ 4792 \ 4793 ptrace_kill(type); \ 4794} 4795 4796// PT_CONTINUE with SIGKILL is covered by traceme_sendsignal_simple1 4797PTRACE_KILL(kill1, "ptrace(PT_KILL)") 4798PTRACE_KILL(kill2, "kill(SIGKILL)") 4799PTRACE_KILL(kill3, "killpg(SIGKILL)") 4800 4801/// ---------------------------------------------------------------------------- 4802 4803static void 4804traceme_lwpinfo(const int threads) 4805{ 4806 const int sigval = SIGSTOP; 4807 const int sigval2 = SIGINT; 4808 pid_t child, wpid; 4809#if defined(TWAIT_HAVE_STATUS) 4810 int status; 4811#endif 4812 struct ptrace_lwpinfo lwp = {0, 0}; 4813 struct ptrace_siginfo info; 4814 4815 /* Maximum number of supported threads in this test */ 4816 pthread_t t[3]; 4817 int n, rv; 4818 4819 ATF_REQUIRE((int)__arraycount(t) >= threads); 4820 4821 DPRINTF("Before forking process PID=%d\n", getpid()); 4822 SYSCALL_REQUIRE((child = fork()) != -1); 4823 if (child == 0) { 4824 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 4825 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 4826 4827 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4828 FORKEE_ASSERT(raise(sigval) == 0); 4829 4830 for (n = 0; n < threads; n++) { 4831 rv = pthread_create(&t[n], NULL, infinite_thread, NULL); 4832 FORKEE_ASSERT(rv == 0); 4833 } 4834 4835 DPRINTF("Before raising %s from child\n", strsignal(sigval2)); 4836 FORKEE_ASSERT(raise(sigval2) == 0); 4837 4838 /* NOTREACHED */ 4839 FORKEE_ASSERTX(0 && "Not reached"); 4840 } 4841 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 4842 4843 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4844 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4845 4846 validate_status_stopped(status, sigval); 4847 4848 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 4849 SYSCALL_REQUIRE( 4850 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4851 4852 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4853 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 4854 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4855 info.psi_siginfo.si_errno); 4856 4857 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 4858 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4859 4860 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4861 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4862 4863 DPRINTF("Assert that there exists a single thread only\n"); 4864 ATF_REQUIRE(lwp.pl_lwpid > 0); 4865 4866 DPRINTF("Assert that lwp thread %d received event PL_EVENT_SIGNAL\n", 4867 lwp.pl_lwpid); 4868 FORKEE_ASSERT_EQ(lwp.pl_event, PL_EVENT_SIGNAL); 4869 4870 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4871 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4872 4873 DPRINTF("Assert that there exists a single thread only\n"); 4874 ATF_REQUIRE_EQ(lwp.pl_lwpid, 0); 4875 4876 DPRINTF("Before resuming the child process where it left off and " 4877 "without signal to be sent\n"); 4878 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 4879 4880 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4881 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4882 4883 validate_status_stopped(status, sigval2); 4884 4885 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child"); 4886 SYSCALL_REQUIRE( 4887 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 4888 4889 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 4890 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 4891 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 4892 info.psi_siginfo.si_errno); 4893 4894 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval2); 4895 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 4896 4897 memset(&lwp, 0, sizeof(lwp)); 4898 4899 for (n = 0; n <= threads; n++) { 4900 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4901 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4902 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4903 4904 DPRINTF("Assert that the thread exists\n"); 4905 ATF_REQUIRE(lwp.pl_lwpid > 0); 4906 4907 DPRINTF("Assert that lwp thread %d received expected event\n", 4908 lwp.pl_lwpid); 4909 FORKEE_ASSERT_EQ(lwp.pl_event, info.psi_lwpid == lwp.pl_lwpid ? 4910 PL_EVENT_SIGNAL : PL_EVENT_NONE); 4911 } 4912 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 4913 SYSCALL_REQUIRE(ptrace(PT_LWPINFO, child, &lwp, sizeof(lwp)) != -1); 4914 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 4915 4916 DPRINTF("Assert that there are no more threads\n"); 4917 ATF_REQUIRE_EQ(lwp.pl_lwpid, 0); 4918 4919 DPRINTF("Before resuming the child process where it left off and " 4920 "without signal to be sent\n"); 4921 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, SIGKILL) != -1); 4922 4923 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4924 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 4925 4926 validate_status_signaled(status, SIGKILL, 0); 4927 4928 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 4929 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 4930} 4931 4932#define TRACEME_LWPINFO(test, threads) \ 4933ATF_TC(test); \ 4934ATF_TC_HEAD(test, tc) \ 4935{ \ 4936 atf_tc_set_md_var(tc, "descr", \ 4937 "Verify LWPINFO with the child with " #threads \ 4938 " spawned extra threads"); \ 4939} \ 4940 \ 4941ATF_TC_BODY(test, tc) \ 4942{ \ 4943 \ 4944 traceme_lwpinfo(threads); \ 4945} 4946 4947TRACEME_LWPINFO(traceme_lwpinfo0, 0) 4948TRACEME_LWPINFO(traceme_lwpinfo1, 1) 4949TRACEME_LWPINFO(traceme_lwpinfo2, 2) 4950TRACEME_LWPINFO(traceme_lwpinfo3, 3) 4951 4952/// ---------------------------------------------------------------------------- 4953 4954#if defined(TWAIT_HAVE_PID) 4955static void 4956attach_lwpinfo(const int threads) 4957{ 4958 const int sigval = SIGINT; 4959 struct msg_fds parent_tracee, parent_tracer; 4960 const int exitval_tracer = 10; 4961 pid_t tracee, tracer, wpid; 4962 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */ 4963#if defined(TWAIT_HAVE_STATUS) 4964 int status; 4965#endif 4966 struct ptrace_lwpinfo lwp = {0, 0}; 4967 struct ptrace_siginfo info; 4968 4969 /* Maximum number of supported threads in this test */ 4970 pthread_t t[3]; 4971 int n, rv; 4972 4973 DPRINTF("Spawn tracee\n"); 4974 SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0); 4975 SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0); 4976 tracee = atf_utils_fork(); 4977 if (tracee == 0) { 4978 /* Wait for message from the parent */ 4979 CHILD_TO_PARENT("tracee ready", parent_tracee, msg); 4980 4981 CHILD_FROM_PARENT("spawn threads", parent_tracee, msg); 4982 4983 for (n = 0; n < threads; n++) { 4984 rv = pthread_create(&t[n], NULL, infinite_thread, NULL); 4985 FORKEE_ASSERT(rv == 0); 4986 } 4987 4988 CHILD_TO_PARENT("tracee exit", parent_tracee, msg); 4989 4990 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 4991 FORKEE_ASSERT(raise(sigval) == 0); 4992 4993 /* NOTREACHED */ 4994 FORKEE_ASSERTX(0 && "Not reached"); 4995 } 4996 PARENT_FROM_CHILD("tracee ready", parent_tracee, msg); 4997 4998 DPRINTF("Spawn debugger\n"); 4999 tracer = atf_utils_fork(); 5000 if (tracer == 0) { 5001 /* No IPC to communicate with the child */ 5002 DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid()); 5003 FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1); 5004 5005 /* Wait for tracee and assert that it was stopped w/ SIGSTOP */ 5006 FORKEE_REQUIRE_SUCCESS( 5007 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 5008 5009 forkee_status_stopped(status, SIGSTOP); 5010 5011 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5012 "tracee"); 5013 FORKEE_ASSERT( 5014 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 5015 5016 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5017 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5018 "si_errno=%#x\n", 5019 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5020 info.psi_siginfo.si_errno); 5021 5022 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, SIGSTOP); 5023 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_USER); 5024 5025 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for child\n"); 5026 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 5027 != -1); 5028 5029 DPRINTF("Assert that there exists a thread\n"); 5030 FORKEE_ASSERTX(lwp.pl_lwpid > 0); 5031 5032 DPRINTF("Assert that lwp thread %d received event " 5033 "PL_EVENT_SIGNAL\n", lwp.pl_lwpid); 5034 FORKEE_ASSERT_EQ(lwp.pl_event, PL_EVENT_SIGNAL); 5035 5036 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 5037 "tracee\n"); 5038 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 5039 != -1); 5040 5041 DPRINTF("Assert that there are no more lwp threads in " 5042 "tracee\n"); 5043 FORKEE_ASSERT_EQ(lwp.pl_lwpid, 0); 5044 5045 /* Resume tracee with PT_CONTINUE */ 5046 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1); 5047 5048 /* Inform parent that tracer has attached to tracee */ 5049 CHILD_TO_PARENT("tracer ready", parent_tracer, msg); 5050 5051 /* Wait for parent */ 5052 CHILD_FROM_PARENT("tracer wait", parent_tracer, msg); 5053 5054 /* Wait for tracee and assert that it raised a signal */ 5055 FORKEE_REQUIRE_SUCCESS( 5056 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 5057 5058 forkee_status_stopped(status, SIGINT); 5059 5060 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5061 "child"); 5062 FORKEE_ASSERT( 5063 ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1); 5064 5065 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5066 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5067 "si_errno=%#x\n", 5068 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5069 info.psi_siginfo.si_errno); 5070 5071 FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sigval); 5072 FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_LWP); 5073 5074 memset(&lwp, 0, sizeof(lwp)); 5075 5076 for (n = 0; n <= threads; n++) { 5077 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 5078 "child\n"); 5079 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, 5080 sizeof(lwp)) != -1); 5081 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 5082 5083 DPRINTF("Assert that the thread exists\n"); 5084 FORKEE_ASSERT(lwp.pl_lwpid > 0); 5085 5086 DPRINTF("Assert that lwp thread %d received expected " 5087 "event\n", lwp.pl_lwpid); 5088 FORKEE_ASSERT_EQ(lwp.pl_event, 5089 info.psi_lwpid == lwp.pl_lwpid ? 5090 PL_EVENT_SIGNAL : PL_EVENT_NONE); 5091 } 5092 DPRINTF("Before calling ptrace(2) with PT_LWPINFO for " 5093 "tracee\n"); 5094 FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &lwp, sizeof(lwp)) 5095 != -1); 5096 DPRINTF("LWP=%d\n", lwp.pl_lwpid); 5097 5098 DPRINTF("Assert that there are no more threads\n"); 5099 FORKEE_ASSERT_EQ(lwp.pl_lwpid, 0); 5100 5101 DPRINTF("Before resuming the child process where it left off " 5102 "and without signal to be sent\n"); 5103 FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, SIGKILL) 5104 != -1); 5105 5106 /* Wait for tracee and assert that it exited */ 5107 FORKEE_REQUIRE_SUCCESS( 5108 wpid = TWAIT_GENERIC(tracee, &status, 0), tracee); 5109 5110 forkee_status_signaled(status, SIGKILL, 0); 5111 5112 DPRINTF("Before exiting of the tracer process\n"); 5113 _exit(exitval_tracer); 5114 } 5115 5116 DPRINTF("Wait for the tracer to attach to the tracee\n"); 5117 PARENT_FROM_CHILD("tracer ready", parent_tracer, msg); 5118 5119 DPRINTF("Resume the tracee and spawn threads\n"); 5120 PARENT_TO_CHILD("spawn threads", parent_tracee, msg); 5121 5122 DPRINTF("Resume the tracee and let it exit\n"); 5123 PARENT_FROM_CHILD("tracee exit", parent_tracee, msg); 5124 5125 DPRINTF("Resume the tracer and let it detect multiple threads\n"); 5126 PARENT_TO_CHILD("tracer wait", parent_tracer, msg); 5127 5128 DPRINTF("Wait for tracer to finish its job and exit - calling %s()\n", 5129 TWAIT_FNAME); 5130 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0), 5131 tracer); 5132 5133 validate_status_exited(status, exitval_tracer); 5134 5135 DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n", 5136 TWAIT_FNAME); 5137 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 5138 tracee); 5139 5140 validate_status_signaled(status, SIGKILL, 0); 5141 5142 msg_close(&parent_tracer); 5143 msg_close(&parent_tracee); 5144} 5145 5146#define ATTACH_LWPINFO(test, threads) \ 5147ATF_TC(test); \ 5148ATF_TC_HEAD(test, tc) \ 5149{ \ 5150 atf_tc_set_md_var(tc, "descr", \ 5151 "Verify LWPINFO with the child with " #threads \ 5152 " spawned extra threads (tracer is not the original " \ 5153 "parent)"); \ 5154} \ 5155 \ 5156ATF_TC_BODY(test, tc) \ 5157{ \ 5158 \ 5159 attach_lwpinfo(threads); \ 5160} 5161 5162ATTACH_LWPINFO(attach_lwpinfo0, 0) 5163ATTACH_LWPINFO(attach_lwpinfo1, 1) 5164ATTACH_LWPINFO(attach_lwpinfo2, 2) 5165ATTACH_LWPINFO(attach_lwpinfo3, 3) 5166#endif 5167 5168/// ---------------------------------------------------------------------------- 5169 5170static void 5171ptrace_siginfo(bool faked, void (*sah)(int a, siginfo_t *b, void *c), int *signal_caught) 5172{ 5173 const int exitval = 5; 5174 const int sigval = SIGINT; 5175 const int sigfaked = SIGTRAP; 5176 const int sicodefaked = TRAP_BRKPT; 5177 pid_t child, wpid; 5178 struct sigaction sa; 5179#if defined(TWAIT_HAVE_STATUS) 5180 int status; 5181#endif 5182 struct ptrace_siginfo info; 5183 memset(&info, 0, sizeof(info)); 5184 5185 DPRINTF("Before forking process PID=%d\n", getpid()); 5186 SYSCALL_REQUIRE((child = fork()) != -1); 5187 if (child == 0) { 5188 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5189 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5190 5191 sa.sa_sigaction = sah; 5192 sa.sa_flags = SA_SIGINFO; 5193 sigemptyset(&sa.sa_mask); 5194 5195 FORKEE_ASSERT(sigaction(faked ? sigfaked : sigval, &sa, NULL) 5196 != -1); 5197 5198 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5199 FORKEE_ASSERT(raise(sigval) == 0); 5200 5201 FORKEE_ASSERT_EQ(*signal_caught, 1); 5202 5203 DPRINTF("Before exiting of the child process\n"); 5204 _exit(exitval); 5205 } 5206 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5207 5208 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5209 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5210 5211 validate_status_stopped(status, sigval); 5212 5213 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5214 SYSCALL_REQUIRE( 5215 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5216 5217 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5218 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5219 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5220 info.psi_siginfo.si_errno); 5221 5222 if (faked) { 5223 DPRINTF("Before setting new faked signal to signo=%d " 5224 "si_code=%d\n", sigfaked, sicodefaked); 5225 info.psi_siginfo.si_signo = sigfaked; 5226 info.psi_siginfo.si_code = sicodefaked; 5227 } 5228 5229 DPRINTF("Before calling ptrace(2) with PT_SET_SIGINFO for child\n"); 5230 SYSCALL_REQUIRE( 5231 ptrace(PT_SET_SIGINFO, child, &info, sizeof(info)) != -1); 5232 5233 if (faked) { 5234 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5235 "child\n"); 5236 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 5237 sizeof(info)) != -1); 5238 5239 DPRINTF("Before checking siginfo_t\n"); 5240 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigfaked); 5241 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, sicodefaked); 5242 } 5243 5244 DPRINTF("Before resuming the child process where it left off and " 5245 "without signal to be sent\n"); 5246 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 5247 faked ? sigfaked : sigval) != -1); 5248 5249 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5250 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5251 5252 validate_status_exited(status, exitval); 5253 5254 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5255 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5256} 5257 5258#define PTRACE_SIGINFO(test, faked) \ 5259ATF_TC(test); \ 5260ATF_TC_HEAD(test, tc) \ 5261{ \ 5262 atf_tc_set_md_var(tc, "descr", \ 5263 "Verify basic PT_GET_SIGINFO and PT_SET_SIGINFO calls" \ 5264 "with%s setting signal to new value", faked ? "" : "out"); \ 5265} \ 5266 \ 5267static int test##_caught = 0; \ 5268 \ 5269static void \ 5270test##_sighandler(int sig, siginfo_t *info, void *ctx) \ 5271{ \ 5272 if (faked) { \ 5273 FORKEE_ASSERT_EQ(sig, SIGTRAP); \ 5274 FORKEE_ASSERT_EQ(info->si_signo, SIGTRAP); \ 5275 FORKEE_ASSERT_EQ(info->si_code, TRAP_BRKPT); \ 5276 } else { \ 5277 FORKEE_ASSERT_EQ(sig, SIGINT); \ 5278 FORKEE_ASSERT_EQ(info->si_signo, SIGINT); \ 5279 FORKEE_ASSERT_EQ(info->si_code, SI_LWP); \ 5280 } \ 5281 \ 5282 ++ test##_caught; \ 5283} \ 5284 \ 5285ATF_TC_BODY(test, tc) \ 5286{ \ 5287 \ 5288 ptrace_siginfo(faked, test##_sighandler, & test##_caught); \ 5289} 5290 5291PTRACE_SIGINFO(siginfo_set_unmodified, false) 5292PTRACE_SIGINFO(siginfo_set_faked, true) 5293 5294/// ---------------------------------------------------------------------------- 5295 5296static void 5297traceme_exec(bool masked, bool ignored) 5298{ 5299 const int sigval = SIGTRAP; 5300 pid_t child, wpid; 5301#if defined(TWAIT_HAVE_STATUS) 5302 int status; 5303#endif 5304 struct sigaction sa; 5305 struct ptrace_siginfo info; 5306 sigset_t intmask; 5307 struct kinfo_proc2 kp; 5308 size_t len = sizeof(kp); 5309 5310 int name[6]; 5311 const size_t namelen = __arraycount(name); 5312 ki_sigset_t kp_sigmask; 5313 ki_sigset_t kp_sigignore; 5314 5315 memset(&info, 0, sizeof(info)); 5316 5317 DPRINTF("Before forking process PID=%d\n", getpid()); 5318 SYSCALL_REQUIRE((child = fork()) != -1); 5319 if (child == 0) { 5320 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5321 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5322 5323 if (masked) { 5324 sigemptyset(&intmask); 5325 sigaddset(&intmask, sigval); 5326 sigprocmask(SIG_BLOCK, &intmask, NULL); 5327 } 5328 5329 if (ignored) { 5330 memset(&sa, 0, sizeof(sa)); 5331 sa.sa_handler = SIG_IGN; 5332 sigemptyset(&sa.sa_mask); 5333 FORKEE_ASSERT(sigaction(sigval, &sa, NULL) != -1); 5334 } 5335 5336 DPRINTF("Before calling execve(2) from child\n"); 5337 execlp("/bin/echo", "/bin/echo", NULL); 5338 5339 FORKEE_ASSERT(0 && "Not reached"); 5340 } 5341 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5342 5343 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5344 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5345 5346 validate_status_stopped(status, sigval); 5347 5348 name[0] = CTL_KERN, 5349 name[1] = KERN_PROC2, 5350 name[2] = KERN_PROC_PID; 5351 name[3] = getpid(); 5352 name[4] = sizeof(kp); 5353 name[5] = 1; 5354 5355 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5356 5357 if (masked) 5358 kp_sigmask = kp.p_sigmask; 5359 5360 if (ignored) 5361 kp_sigignore = kp.p_sigignore; 5362 5363 name[3] = getpid(); 5364 5365 ATF_REQUIRE_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0); 5366 5367 if (masked) { 5368 DPRINTF("kp_sigmask=" 5369 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5370 kp_sigmask.__bits[0], kp_sigmask.__bits[1], 5371 kp_sigmask.__bits[2], kp_sigmask.__bits[3]); 5372 5373 DPRINTF("kp.p_sigmask=" 5374 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5375 kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1], 5376 kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]); 5377 5378 ATF_REQUIRE(!memcmp(&kp_sigmask, &kp.p_sigmask, 5379 sizeof(kp_sigmask))); 5380 } 5381 5382 if (ignored) { 5383 DPRINTF("kp_sigignore=" 5384 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5385 kp_sigignore.__bits[0], kp_sigignore.__bits[1], 5386 kp_sigignore.__bits[2], kp_sigignore.__bits[3]); 5387 5388 DPRINTF("kp.p_sigignore=" 5389 "%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n", 5390 kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1], 5391 kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]); 5392 5393 ATF_REQUIRE(!memcmp(&kp_sigignore, &kp.p_sigignore, 5394 sizeof(kp_sigignore))); 5395 } 5396 5397 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5398 SYSCALL_REQUIRE( 5399 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5400 5401 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5402 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5403 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5404 info.psi_siginfo.si_errno); 5405 5406 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5407 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_EXEC); 5408 5409 DPRINTF("Before resuming the child process where it left off and " 5410 "without signal to be sent\n"); 5411 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5412 5413 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5414 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5415 5416 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5417 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 5418} 5419 5420#define TRACEME_EXEC(test, masked, ignored) \ 5421ATF_TC(test); \ 5422ATF_TC_HEAD(test, tc) \ 5423{ \ 5424 atf_tc_set_md_var(tc, "descr", \ 5425 "Detect SIGTRAP TRAP_EXEC from " \ 5426 "child%s%s", masked ? " with masked signal" : "", \ 5427 masked ? " with ignored signal" : ""); \ 5428} \ 5429 \ 5430ATF_TC_BODY(test, tc) \ 5431{ \ 5432 \ 5433 traceme_exec(masked, ignored); \ 5434} 5435 5436TRACEME_EXEC(traceme_exec, false, false) 5437TRACEME_EXEC(traceme_signalmasked_exec, true, false) 5438TRACEME_EXEC(traceme_signalignored_exec, false, true) 5439 5440/// ---------------------------------------------------------------------------- 5441 5442#define TRACE_THREADS_NUM 100 5443 5444static volatile int done; 5445pthread_mutex_t trace_threads_mtx = PTHREAD_MUTEX_INITIALIZER; 5446 5447static void * 5448trace_threads_cb(void *arg __unused) 5449{ 5450 5451 pthread_mutex_lock(&trace_threads_mtx); 5452 done++; 5453 pthread_mutex_unlock(&trace_threads_mtx); 5454 5455 while (done < TRACE_THREADS_NUM) 5456 sched_yield(); 5457 5458 return NULL; 5459} 5460 5461static void 5462trace_threads(bool trace_create, bool trace_exit) 5463{ 5464 const int sigval = SIGSTOP; 5465 pid_t child, wpid; 5466#if defined(TWAIT_HAVE_STATUS) 5467 int status; 5468#endif 5469 ptrace_state_t state; 5470 const int slen = sizeof(state); 5471 ptrace_event_t event; 5472 const int elen = sizeof(event); 5473 struct ptrace_siginfo info; 5474 5475 pthread_t t[TRACE_THREADS_NUM]; 5476 int rv; 5477 size_t n; 5478 lwpid_t lid; 5479 5480 /* Track created and exited threads */ 5481 bool traced_lwps[__arraycount(t)]; 5482 5483 DPRINTF("Before forking process PID=%d\n", getpid()); 5484 SYSCALL_REQUIRE((child = fork()) != -1); 5485 if (child == 0) { 5486 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 5487 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 5488 5489 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 5490 FORKEE_ASSERT(raise(sigval) == 0); 5491 5492 for (n = 0; n < __arraycount(t); n++) { 5493 rv = pthread_create(&t[n], NULL, trace_threads_cb, 5494 NULL); 5495 FORKEE_ASSERT(rv == 0); 5496 } 5497 5498 for (n = 0; n < __arraycount(t); n++) { 5499 rv = pthread_join(t[n], NULL); 5500 FORKEE_ASSERT(rv == 0); 5501 } 5502 5503 /* 5504 * There is race between _exit() and pthread_join() detaching 5505 * a thread. For simplicity kill the process after detecting 5506 * LWP events. 5507 */ 5508 while (true) 5509 continue; 5510 5511 FORKEE_ASSERT(0 && "Not reached"); 5512 } 5513 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 5514 5515 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 5516 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 5517 5518 validate_status_stopped(status, sigval); 5519 5520 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n"); 5521 SYSCALL_REQUIRE( 5522 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5523 5524 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5525 DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n", 5526 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5527 info.psi_siginfo.si_errno); 5528 5529 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval); 5530 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP); 5531 5532 DPRINTF("Set LWP event mask for the child %d\n", child); 5533 memset(&event, 0, sizeof(event)); 5534 if (trace_create) 5535 event.pe_set_event |= PTRACE_LWP_CREATE; 5536 if (trace_exit) 5537 event.pe_set_event |= PTRACE_LWP_EXIT; 5538 SYSCALL_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1); 5539 5540 DPRINTF("Before resuming the child process where it left off and " 5541 "without signal to be sent\n"); 5542 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5543 5544 memset(traced_lwps, 0, sizeof(traced_lwps)); 5545 5546 for (n = 0; n < (trace_create ? __arraycount(t) : 0); n++) { 5547 DPRINTF("Before calling %s() for the child - expected stopped " 5548 "SIGTRAP\n", TWAIT_FNAME); 5549 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5550 child); 5551 5552 validate_status_stopped(status, SIGTRAP); 5553 5554 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5555 "child\n"); 5556 SYSCALL_REQUIRE( 5557 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5558 5559 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5560 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5561 "si_errno=%#x\n", 5562 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5563 info.psi_siginfo.si_errno); 5564 5565 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5566 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5567 5568 SYSCALL_REQUIRE( 5569 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5570 5571 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_CREATE, 5572 "%d != %d", state.pe_report_event, PTRACE_LWP_CREATE); 5573 5574 lid = state.pe_lwp; 5575 DPRINTF("Reported PTRACE_LWP_CREATE event with lid %d\n", lid); 5576 5577 traced_lwps[lid - 1] = true; 5578 5579 DPRINTF("Before resuming the child process where it left off " 5580 "and without signal to be sent\n"); 5581 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 5582 } 5583 5584 for (n = 0; n < (trace_exit ? __arraycount(t) : 0); n++) { 5585 DPRINTF("Before calling %s() for the child - expected stopped " 5586 "SIGTRAP\n", TWAIT_FNAME); 5587 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 5588 child); 5589 5590 validate_status_stopped(status, SIGTRAP); 5591 5592 DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for " 5593 "child\n"); 5594 SYSCALL_REQUIRE( 5595 ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1); 5596 5597 DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid); 5598 DPRINTF("Signal properties: si_signo=%#x si_code=%#x " 5599 "si_errno=%#x\n", 5600 info.psi_siginfo.si_signo, info.psi_siginfo.si_code, 5601 info.psi_siginfo.si_errno); 5602 5603 ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP); 5604 ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_LWP); 5605 5606 SYSCALL_REQUIRE( 5607 ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1); 5608 5609 ATF_REQUIRE_EQ_MSG(state.pe_report_event, PTRACE_LWP_EXIT, 5610 "%d != %d", state.pe_report_event, PTRACE_LWP_EXIT); 5611 5612 lid = state.pe_lwp; 5613 DPRINTF("Reported PTRACE_LWP_EXIT event with lid %d\n", lid); 5614 5615 if (trace_create) { 5616 ATF_REQUIRE(traced_lwps[lid - 1] == true); 5617 traced_lwps[lid - 1] = false; 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 int signal_counts[THREAD_CONCURRENT_SIGNALS_NUM] = {0}; 7742 unsigned int i; 7743 7744 DPRINTF("Before forking process PID=%d\n", getpid()); 7745 SYSCALL_REQUIRE((child = fork()) != -1); 7746 if (child == 0) { 7747 pthread_t threads[THREAD_CONCURRENT_SIGNALS_NUM]; 7748 7749 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 7750 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 7751 7752 DPRINTF("Before raising %s from child\n", strsignal(sigval)); 7753 FORKEE_ASSERT(raise(sigval) == 0); 7754 7755 DPRINTF("Before starting threads from the child\n"); 7756 FORKEE_ASSERT(pthread_barrier_init( 7757 &thread_concurrent_signals_barrier, NULL, 7758 __arraycount(threads)) == 0); 7759 7760 for (i = 0; i < __arraycount(threads); i++) { 7761 FORKEE_ASSERT(pthread_create(&threads[i], NULL, 7762 thread_concurrent_signals_thread, NULL) == 0); 7763 } 7764 7765 DPRINTF("Before joining threads from the child\n"); 7766 for (i = 0; i < __arraycount(threads); i++) { 7767 FORKEE_ASSERT(pthread_join(threads[i], NULL) == 0); 7768 } 7769 7770 FORKEE_ASSERT(pthread_barrier_destroy( 7771 &thread_concurrent_signals_barrier) == 0); 7772 7773 DPRINTF("Before exiting of the child process\n"); 7774 _exit(exitval); 7775 } 7776 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 7777 7778 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 7779 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 7780 7781 validate_status_stopped(status, sigval); 7782 7783 DPRINTF("Before resuming the child process where it left off\n"); 7784 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7785 7786 DPRINTF("Before entering signal collection loop\n"); 7787 while (1) { 7788 ptrace_siginfo_t info; 7789 int expected_sig; 7790 7791 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 7792 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), 7793 child); 7794 if (WIFEXITED(status)) 7795 break; 7796 /* Note: we use validate_status_stopped() to get nice error 7797 * message. Signal is irrelevant since it won't be reached. 7798 */ 7799 else if (!WIFSTOPPED(status)) 7800 validate_status_stopped(status, 0); 7801 7802 DPRINTF("Before calling PT_GET_SIGINFO\n"); 7803 SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, 7804 sizeof(info)) != -1); 7805 7806 DPRINTF("Received signal %d from LWP %d (wait: %d)\n", 7807 info.psi_siginfo.si_signo, info.psi_lwpid, 7808 WSTOPSIG(status)); 7809 7810 expected_sig = thread_concurrent_signals_list[info.psi_lwpid % 7811 __arraycount(thread_concurrent_signals_list)]; 7812 ATF_CHECK_EQ_MSG(info.psi_siginfo.si_signo, expected_sig, 7813 "lwp=%d, expected %d, got %d", info.psi_lwpid, 7814 expected_sig, info.psi_siginfo.si_signo); 7815 ATF_CHECK_EQ_MSG(WSTOPSIG(status), expected_sig, 7816 "lwp=%d, expected %d, got %d", info.psi_lwpid, 7817 expected_sig, WSTOPSIG(status)); 7818 7819 /* We assume that LWPs will be given successive numbers starting 7820 * from 2. 7821 */ 7822 ATF_REQUIRE(info.psi_lwpid >= 2); 7823 ATF_REQUIRE((unsigned int)info.psi_lwpid < 7824 __arraycount(signal_counts)+2); 7825 signal_counts[info.psi_lwpid-2]++; 7826 7827 DPRINTF("Before resuming the child process\n"); 7828 SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1); 7829 } 7830 7831 for (i = 0; i < __arraycount(signal_counts); i++) 7832 ATF_CHECK_EQ_MSG(signal_counts[i], 1, "signal_counts[%d]=%d", 7833 i, signal_counts[i]); 7834 7835 validate_status_exited(status, exitval); 7836} 7837 7838#endif /*defined(TWAIT_HAVE_STATUS)*/ 7839 7840/// ---------------------------------------------------------------------------- 7841 7842#include "t_ptrace_amd64_wait.h" 7843#include "t_ptrace_i386_wait.h" 7844#include "t_ptrace_x86_wait.h" 7845 7846ATF_TP_ADD_TCS(tp) 7847{ 7848 setvbuf(stdout, NULL, _IONBF, 0); 7849 setvbuf(stderr, NULL, _IONBF, 0); 7850 7851 ATF_TP_ADD_TC(tp, traceme_raise1); 7852 ATF_TP_ADD_TC(tp, traceme_raise2); 7853 ATF_TP_ADD_TC(tp, traceme_raise3); 7854 ATF_TP_ADD_TC(tp, traceme_raise4); 7855 ATF_TP_ADD_TC(tp, traceme_raise5); 7856 ATF_TP_ADD_TC(tp, traceme_raise6); 7857 ATF_TP_ADD_TC(tp, traceme_raise7); 7858 ATF_TP_ADD_TC(tp, traceme_raise8); 7859 ATF_TP_ADD_TC(tp, traceme_raise9); 7860 ATF_TP_ADD_TC(tp, traceme_raise10); 7861 7862 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored1); 7863 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored2); 7864 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored3); 7865 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored4); 7866 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored5); 7867 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored6); 7868 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored7); 7869 ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored8); 7870 7871 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked1); 7872 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked2); 7873 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked3); 7874 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked4); 7875 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked5); 7876 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked6); 7877 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked7); 7878 ATF_TP_ADD_TC(tp, traceme_raisesignal_masked8); 7879 7880 ATF_TP_ADD_TC(tp, traceme_crash_trap); 7881 ATF_TP_ADD_TC(tp, traceme_crash_segv); 7882 ATF_TP_ADD_TC(tp, traceme_crash_ill); 7883 ATF_TP_ADD_TC(tp, traceme_crash_fpe); 7884 ATF_TP_ADD_TC(tp, traceme_crash_bus); 7885 7886 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_trap); 7887 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_segv); 7888 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_ill); 7889 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_fpe); 7890 ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_bus); 7891 7892 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_trap); 7893 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_segv); 7894 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_ill); 7895 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_fpe); 7896 ATF_TP_ADD_TC(tp, traceme_signalignored_crash_bus); 7897 7898 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle1); 7899 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle2); 7900 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle3); 7901 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle4); 7902 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle5); 7903 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle6); 7904 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle7); 7905 ATF_TP_ADD_TC(tp, traceme_sendsignal_handle8); 7906 7907 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked1); 7908 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked2); 7909 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked3); 7910 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked4); 7911 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked5); 7912 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked6); 7913 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked7); 7914 ATF_TP_ADD_TC(tp, traceme_sendsignal_masked8); 7915 7916 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored1); 7917 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored2); 7918 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored3); 7919 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored4); 7920 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored5); 7921 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored6); 7922 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored7); 7923 ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored8); 7924 7925 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple1); 7926 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple2); 7927 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple3); 7928 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple4); 7929 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple5); 7930 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple6); 7931 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple7); 7932 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple8); 7933 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple9); 7934 ATF_TP_ADD_TC(tp, traceme_sendsignal_simple10); 7935 7936 ATF_TP_ADD_TC(tp, traceme_pid1_parent); 7937 7938 ATF_TP_ADD_TC(tp, traceme_vfork_raise1); 7939 ATF_TP_ADD_TC(tp, traceme_vfork_raise2); 7940 ATF_TP_ADD_TC(tp, traceme_vfork_raise3); 7941 ATF_TP_ADD_TC(tp, traceme_vfork_raise4); 7942 ATF_TP_ADD_TC(tp, traceme_vfork_raise5); 7943 ATF_TP_ADD_TC(tp, traceme_vfork_raise6); 7944 ATF_TP_ADD_TC(tp, traceme_vfork_raise7); 7945 ATF_TP_ADD_TC(tp, traceme_vfork_raise8); 7946 ATF_TP_ADD_TC(tp, traceme_vfork_raise9); 7947 ATF_TP_ADD_TC(tp, traceme_vfork_raise10); 7948 ATF_TP_ADD_TC(tp, traceme_vfork_raise11); 7949 ATF_TP_ADD_TC(tp, traceme_vfork_raise12); 7950 ATF_TP_ADD_TC(tp, traceme_vfork_raise13); 7951 7952 ATF_TP_ADD_TC(tp, traceme_vfork_crash_trap); 7953 ATF_TP_ADD_TC(tp, traceme_vfork_crash_segv); 7954 ATF_TP_ADD_TC(tp, traceme_vfork_crash_ill); 7955 ATF_TP_ADD_TC(tp, traceme_vfork_crash_fpe); 7956 ATF_TP_ADD_TC(tp, traceme_vfork_crash_bus); 7957 7958 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_trap); 7959 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_segv); 7960 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_ill); 7961 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_fpe); 7962 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_bus); 7963 7964 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_trap); 7965 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_segv); 7966 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_ill); 7967 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_fpe); 7968 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_bus); 7969 7970 ATF_TP_ADD_TC(tp, traceme_vfork_exec); 7971 ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_exec); 7972 ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_exec); 7973 7974 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_trap); 7975 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_segv); 7976 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_ill); 7977 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_fpe); 7978 ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_bus); 7979 7980 ATF_TP_ADD_TC_HAVE_PID(tp, 7981 unrelated_tracer_sees_signalmasked_crash_trap); 7982 ATF_TP_ADD_TC_HAVE_PID(tp, 7983 unrelated_tracer_sees_signalmasked_crash_segv); 7984 ATF_TP_ADD_TC_HAVE_PID(tp, 7985 unrelated_tracer_sees_signalmasked_crash_ill); 7986 ATF_TP_ADD_TC_HAVE_PID(tp, 7987 unrelated_tracer_sees_signalmasked_crash_fpe); 7988 ATF_TP_ADD_TC_HAVE_PID(tp, 7989 unrelated_tracer_sees_signalmasked_crash_bus); 7990 7991 ATF_TP_ADD_TC_HAVE_PID(tp, 7992 unrelated_tracer_sees_signalignored_crash_trap); 7993 ATF_TP_ADD_TC_HAVE_PID(tp, 7994 unrelated_tracer_sees_signalignored_crash_segv); 7995 ATF_TP_ADD_TC_HAVE_PID(tp, 7996 unrelated_tracer_sees_signalignored_crash_ill); 7997 ATF_TP_ADD_TC_HAVE_PID(tp, 7998 unrelated_tracer_sees_signalignored_crash_fpe); 7999 ATF_TP_ADD_TC_HAVE_PID(tp, 8000 unrelated_tracer_sees_signalignored_crash_bus); 8001 8002 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sees_terminaton_before_the_parent); 8003 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_sysctl_lookup_without_duplicates); 8004 ATF_TP_ADD_TC_HAVE_PID(tp, 8005 unrelated_tracer_sees_terminaton_before_the_parent); 8006 ATF_TP_ADD_TC_HAVE_PID(tp, tracer_attach_to_unrelated_stopped_process); 8007 8008 ATF_TP_ADD_TC(tp, parent_attach_to_its_child); 8009 ATF_TP_ADD_TC(tp, parent_attach_to_its_stopped_child); 8010 8011 ATF_TP_ADD_TC(tp, child_attach_to_its_parent); 8012 ATF_TP_ADD_TC(tp, child_attach_to_its_stopped_parent); 8013 8014 ATF_TP_ADD_TC_HAVE_PID(tp, 8015 tracee_sees_its_original_parent_getppid); 8016 ATF_TP_ADD_TC_HAVE_PID(tp, 8017 tracee_sees_its_original_parent_sysctl_kinfo_proc2); 8018 ATF_TP_ADD_TC_HAVE_PID(tp, 8019 tracee_sees_its_original_parent_procfs_status); 8020 8021 ATF_TP_ADD_TC(tp, eventmask_preserved_empty); 8022 ATF_TP_ADD_TC(tp, eventmask_preserved_fork); 8023 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork); 8024 ATF_TP_ADD_TC(tp, eventmask_preserved_vfork_done); 8025 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_create); 8026 ATF_TP_ADD_TC(tp, eventmask_preserved_lwp_exit); 8027 ATF_TP_ADD_TC(tp, eventmask_preserved_posix_spawn); 8028 8029 ATF_TP_ADD_TC(tp, fork1); 8030 ATF_TP_ADD_TC_HAVE_PID(tp, fork2); 8031 ATF_TP_ADD_TC_HAVE_PID(tp, fork3); 8032 ATF_TP_ADD_TC_HAVE_PID(tp, fork4); 8033 ATF_TP_ADD_TC(tp, fork5); 8034 ATF_TP_ADD_TC_HAVE_PID(tp, fork6); 8035 ATF_TP_ADD_TC_HAVE_PID(tp, fork7); 8036 ATF_TP_ADD_TC_HAVE_PID(tp, fork8); 8037 ATF_TP_ADD_TC(tp, fork9); 8038 ATF_TP_ADD_TC_HAVE_PID(tp, fork10); 8039 ATF_TP_ADD_TC_HAVE_PID(tp, fork11); 8040 ATF_TP_ADD_TC_HAVE_PID(tp, fork12); 8041 ATF_TP_ADD_TC(tp, fork13); 8042 ATF_TP_ADD_TC_HAVE_PID(tp, fork14); 8043 ATF_TP_ADD_TC_HAVE_PID(tp, fork15); 8044 ATF_TP_ADD_TC_HAVE_PID(tp, fork16); 8045 8046 ATF_TP_ADD_TC(tp, vfork1); 8047 ATF_TP_ADD_TC_HAVE_PID(tp, vfork2); 8048 ATF_TP_ADD_TC_HAVE_PID(tp, vfork3); 8049 ATF_TP_ADD_TC_HAVE_PID(tp, vfork4); 8050 ATF_TP_ADD_TC(tp, vfork5); 8051 ATF_TP_ADD_TC_HAVE_PID(tp, vfork6); 8052 ATF_TP_ADD_TC_HAVE_PID(tp, vfork7); 8053 ATF_TP_ADD_TC_HAVE_PID(tp, vfork8); 8054 ATF_TP_ADD_TC(tp, vfork9); 8055 ATF_TP_ADD_TC_HAVE_PID(tp, vfork10); 8056 ATF_TP_ADD_TC_HAVE_PID(tp, vfork11); 8057 ATF_TP_ADD_TC_HAVE_PID(tp, vfork12); 8058 ATF_TP_ADD_TC(tp, vfork13); 8059 ATF_TP_ADD_TC_HAVE_PID(tp, vfork14); 8060 ATF_TP_ADD_TC_HAVE_PID(tp, vfork15); 8061 ATF_TP_ADD_TC_HAVE_PID(tp, vfork16); 8062 8063 ATF_TP_ADD_TC(tp, posix_spawn1); 8064 ATF_TP_ADD_TC(tp, posix_spawn2); 8065 ATF_TP_ADD_TC(tp, posix_spawn3); 8066 ATF_TP_ADD_TC(tp, posix_spawn4); 8067 ATF_TP_ADD_TC(tp, posix_spawn5); 8068 ATF_TP_ADD_TC(tp, posix_spawn6); 8069 ATF_TP_ADD_TC(tp, posix_spawn7); 8070 ATF_TP_ADD_TC(tp, posix_spawn8); 8071 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn9); 8072 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn10); 8073 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn11); 8074 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn12); 8075 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn13); 8076 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn14); 8077 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn15); 8078 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn16); 8079 8080 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn_detach_spawner); 8081 ATF_TP_ADD_TC_HAVE_PID(tp, fork_detach_forker); 8082 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforker); 8083 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_detach_vforkerdone); 8084 8085 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn_kill_spawner); 8086 ATF_TP_ADD_TC_HAVE_PID(tp, fork_kill_forker); 8087 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforker); 8088 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_kill_vforkerdone); 8089 8090 ATF_TP_ADD_TC(tp, traceme_vfork_fork); 8091 ATF_TP_ADD_TC(tp, traceme_vfork_vfork); 8092 8093 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8); 8094 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16); 8095 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32); 8096 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64); 8097 8098 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8); 8099 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16); 8100 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32); 8101 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64); 8102 8103 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8); 8104 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16); 8105 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32); 8106 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64); 8107 8108 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8); 8109 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16); 8110 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32); 8111 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64); 8112 8113 ATF_TP_ADD_TC(tp, bytes_transfer_read_d); 8114 ATF_TP_ADD_TC(tp, bytes_transfer_read_i); 8115 ATF_TP_ADD_TC(tp, bytes_transfer_write_d); 8116 ATF_TP_ADD_TC(tp, bytes_transfer_write_i); 8117 8118 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_8_text); 8119 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_16_text); 8120 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_32_text); 8121 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_d_64_text); 8122 8123 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_8_text); 8124 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_16_text); 8125 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_32_text); 8126 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_i_64_text); 8127 8128 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_8_text); 8129 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_16_text); 8130 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_32_text); 8131 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_d_64_text); 8132 8133 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_8_text); 8134 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_16_text); 8135 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_32_text); 8136 ATF_TP_ADD_TC(tp, bytes_transfer_piod_write_i_64_text); 8137 8138 ATF_TP_ADD_TC(tp, bytes_transfer_read_d_text); 8139 ATF_TP_ADD_TC(tp, bytes_transfer_read_i_text); 8140 ATF_TP_ADD_TC(tp, bytes_transfer_write_d_text); 8141 ATF_TP_ADD_TC(tp, bytes_transfer_write_i_text); 8142 8143 ATF_TP_ADD_TC(tp, bytes_transfer_piod_read_auxv); 8144 8145 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_i); 8146 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_read_d); 8147 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_i); 8148 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_pt_write_d); 8149 8150 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_i); 8151 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_d); 8152 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_i); 8153 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_write_d); 8154 8155 ATF_TP_ADD_TC(tp, bytes_transfer_alignment_piod_read_auxv); 8156 8157 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_i); 8158 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_read_d); 8159 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_i); 8160 ATF_TP_ADD_TC(tp, bytes_transfer_eof_pt_write_d); 8161 8162 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_i); 8163 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_read_d); 8164 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_i); 8165 ATF_TP_ADD_TC(tp, bytes_transfer_eof_piod_write_d); 8166 8167 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs1); 8168 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs2); 8169 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs3); 8170 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs4); 8171 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs5); 8172 ATF_TP_ADD_TC_HAVE_GPREGS(tp, access_regs6); 8173 8174 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs1); 8175 ATF_TP_ADD_TC_HAVE_FPREGS(tp, access_fpregs2); 8176 8177 ATF_TP_ADD_TC_PT_STEP(tp, step1); 8178 ATF_TP_ADD_TC_PT_STEP(tp, step2); 8179 ATF_TP_ADD_TC_PT_STEP(tp, step3); 8180 ATF_TP_ADD_TC_PT_STEP(tp, step4); 8181 8182 ATF_TP_ADD_TC_PT_STEP(tp, setstep1); 8183 ATF_TP_ADD_TC_PT_STEP(tp, setstep2); 8184 ATF_TP_ADD_TC_PT_STEP(tp, setstep3); 8185 ATF_TP_ADD_TC_PT_STEP(tp, setstep4); 8186 8187 ATF_TP_ADD_TC_PT_STEP(tp, step_signalmasked); 8188 ATF_TP_ADD_TC_PT_STEP(tp, step_signalignored); 8189 8190 ATF_TP_ADD_TC(tp, kill1); 8191 ATF_TP_ADD_TC(tp, kill2); 8192 ATF_TP_ADD_TC(tp, kill3); 8193 8194 ATF_TP_ADD_TC(tp, traceme_lwpinfo0); 8195 ATF_TP_ADD_TC(tp, traceme_lwpinfo1); 8196 ATF_TP_ADD_TC(tp, traceme_lwpinfo2); 8197 ATF_TP_ADD_TC(tp, traceme_lwpinfo3); 8198 8199 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo0); 8200 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo1); 8201 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo2); 8202 ATF_TP_ADD_TC_HAVE_PID(tp, attach_lwpinfo3); 8203 8204 ATF_TP_ADD_TC(tp, siginfo_set_unmodified); 8205 ATF_TP_ADD_TC(tp, siginfo_set_faked); 8206 8207 ATF_TP_ADD_TC(tp, traceme_exec); 8208 ATF_TP_ADD_TC(tp, traceme_signalmasked_exec); 8209 ATF_TP_ADD_TC(tp, traceme_signalignored_exec); 8210 8211 ATF_TP_ADD_TC(tp, trace_thread_nolwpevents); 8212 ATF_TP_ADD_TC(tp, trace_thread_lwpexit); 8213 ATF_TP_ADD_TC(tp, trace_thread_lwpcreate); 8214 ATF_TP_ADD_TC(tp, trace_thread_lwpcreate_and_exit); 8215 8216 ATF_TP_ADD_TC(tp, signal_mask_unrelated); 8217 8218 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn_singalmasked); 8219 ATF_TP_ADD_TC_HAVE_PID(tp, posix_spawn_singalignored); 8220 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalmasked); 8221 ATF_TP_ADD_TC_HAVE_PID(tp, fork_singalignored); 8222 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalmasked); 8223 ATF_TP_ADD_TC_HAVE_PID(tp, vfork_singalignored); 8224 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalmasked); 8225 ATF_TP_ADD_TC_HAVE_PID(tp, vforkdone_singalignored); 8226 8227 ATF_TP_ADD_TC(tp, signal9); 8228 ATF_TP_ADD_TC(tp, signal10); 8229 8230 ATF_TP_ADD_TC(tp, suspend2); 8231 8232 ATF_TP_ADD_TC(tp, resume1); 8233 8234 ATF_TP_ADD_TC(tp, syscall1); 8235 8236 ATF_TP_ADD_TC(tp, syscallemu1); 8237 8238 ATF_TP_ADD_TC(tp, clone1); 8239 ATF_TP_ADD_TC_HAVE_PID(tp, clone2); 8240 ATF_TP_ADD_TC_HAVE_PID(tp, clone3); 8241 ATF_TP_ADD_TC_HAVE_PID(tp, clone4); 8242 ATF_TP_ADD_TC(tp, clone5); 8243 ATF_TP_ADD_TC_HAVE_PID(tp, clone6); 8244 ATF_TP_ADD_TC_HAVE_PID(tp, clone7); 8245 ATF_TP_ADD_TC_HAVE_PID(tp, clone8); 8246 8247 ATF_TP_ADD_TC(tp, clone_vm1); 8248 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm2); 8249 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm3); 8250 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm4); 8251 ATF_TP_ADD_TC(tp, clone_vm5); 8252 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm6); 8253 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm7); 8254 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm8); 8255 8256 ATF_TP_ADD_TC(tp, clone_fs1); 8257 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs2); 8258 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs3); 8259 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs4); 8260 ATF_TP_ADD_TC(tp, clone_fs5); 8261 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs6); 8262 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs7); 8263 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs8); 8264 8265 ATF_TP_ADD_TC(tp, clone_files1); 8266 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files2); 8267 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files3); 8268 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files4); 8269 ATF_TP_ADD_TC(tp, clone_files5); 8270 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files6); 8271 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files7); 8272 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files8); 8273 8274// ATF_TP_ADD_TC(tp, clone_sighand1); // XXX 8275// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand2); // XXX 8276// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand3); // XXX 8277// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand4); // XXX 8278// ATF_TP_ADD_TC(tp, clone_sighand5); // XXX 8279// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand6); // XXX 8280// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand7); // XXX 8281// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand8); // XXX 8282 8283 ATF_TP_ADD_TC(tp, clone_vfork1); 8284 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork2); 8285 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork3); 8286 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork4); 8287 ATF_TP_ADD_TC(tp, clone_vfork5); 8288 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork6); 8289 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork7); 8290 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork8); 8291 8292 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalignored); 8293 ATF_TP_ADD_TC_HAVE_PID(tp, clone_signalmasked); 8294 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalignored); 8295 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vm_signalmasked); 8296 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalignored); 8297 ATF_TP_ADD_TC_HAVE_PID(tp, clone_fs_signalmasked); 8298 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalignored); 8299 ATF_TP_ADD_TC_HAVE_PID(tp, clone_files_signalmasked); 8300// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalignored); // XXX 8301// ATF_TP_ADD_TC_HAVE_PID(tp, clone_sighand_signalmasked); // XXX 8302 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalignored); 8303 ATF_TP_ADD_TC_HAVE_PID(tp, clone_vfork_signalmasked); 8304 8305 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone); 8306 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vm); 8307 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_fs); 8308 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_files); 8309// ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_sighand); // XXX 8310 ATF_TP_ADD_TC_HAVE_PID(tp, traceme_vfork_clone_vfork); 8311 8312 ATF_TP_ADD_TC(tp, user_va0_disable_pt_continue); 8313 ATF_TP_ADD_TC(tp, user_va0_disable_pt_syscall); 8314 ATF_TP_ADD_TC(tp, user_va0_disable_pt_detach); 8315 8316 ATF_TP_ADD_TC(tp, core_dump_procinfo); 8317 8318#if defined(TWAIT_HAVE_STATUS) 8319 ATF_TP_ADD_TC(tp, thread_concurrent_signals); 8320#endif 8321 8322 ATF_TP_ADD_TCS_PTRACE_WAIT_AMD64(); 8323 ATF_TP_ADD_TCS_PTRACE_WAIT_I386(); 8324 ATF_TP_ADD_TCS_PTRACE_WAIT_X86(); 8325 8326 return atf_no_error(); 8327} 8328