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