#if \
(defined(__arm__) && defined(__SOFTFP__)) || \
(defined(__m68k__) && !defined(__HAVE_68881__)) || \
defined(__mips_soft_float) || \
(defined(__powerpc__) && defined(_SOFT_FLOAT)) || \
(defined(__sh__) && !defined(__SH_FPU_ANY__)) || \
0
#define SOFTFLOAT
#endif
#ifdef SOFTFLOAT
static void
softfloat_fudge_sigs(const ki_sigset_t *kbefore, ki_sigset_t *kafter)
{
sigset_t before, after;
__CTASSERT(sizeof(before) == sizeof(*kbefore));
__CTASSERT(sizeof(after) == sizeof(*kafter));
memcpy(&before, kbefore, sizeof(before));
memcpy(&after, kafter, sizeof(after));
if (sigismember(&before, SIGFPE)) {
fprintf(stderr, "%s: add SIGFPE\n", __func__);
sigaddset(&after, SIGFPE);
} else {
fprintf(stderr, "%s: del SIGFPE\n", __func__);
sigdelset(&after, SIGFPE);
}
memcpy(kafter, &after, sizeof(after));
}
#endif
static void
traceme_raise(int sigval)
{
const int exitval = 5;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
ptrace_state_t state, zero_state;
const int slen = sizeof(state);
struct ptrace_siginfo info;
memset(&zero_state, 0, sizeof(zero_state));
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
switch (sigval) {
case SIGKILL:
FORKEE_ASSERTX(0 && "This shall not be reached");
__unreachable();
default:
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
switch (sigval) {
case SIGKILL:
validate_status_signaled(status, sigval, 0);
SYSCALL_REQUIRE(
ptrace(PT_GET_PROCESS_STATE, child, &state, slen) == -1);
break;
default:
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for "
"child\n");
SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info,
sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x "
"si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Assert that PT_GET_PROCESS_STATE returns non-error\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
TEST_CHECK_MEMEQ(&state, &zero_state, slen);
DPRINTF("Before resuming the child process where it left off "
"and without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0),
child);
break;
}
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_RAISE(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify " #sig " followed by _exit(2) in a child"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_raise(sig); \
}
TRACEME_RAISE(traceme_raise1, SIGKILL)
TRACEME_RAISE(traceme_raise2, SIGSTOP)
TRACEME_RAISE(traceme_raise3, SIGABRT)
TRACEME_RAISE(traceme_raise4, SIGHUP)
TRACEME_RAISE(traceme_raise5, SIGCONT)
TRACEME_RAISE(traceme_raise6, SIGTRAP)
TRACEME_RAISE(traceme_raise7, SIGBUS)
TRACEME_RAISE(traceme_raise8, SIGILL)
TRACEME_RAISE(traceme_raise9, SIGFPE)
TRACEME_RAISE(traceme_raise10, SIGSEGV)
static void
traceme_raisesignal_ignored(int sigignored)
{
const int exitval = 5;
const int sigval = SIGSTOP;
pid_t child, wpid;
struct sigaction sa;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sigignored, &sa, NULL) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before raising %s from child\n",
strsignal(sigignored));
FORKEE_ASSERT(raise(sigignored) == 0);
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigignored);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigignored);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_RAISESIGNAL_IGNORED(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that ignoring (with SIG_IGN) " #sig " in tracee " \
"does not stop tracer from catching this raised signal"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_raisesignal_ignored(sig); \
}
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored1, SIGABRT)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored2, SIGHUP)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored3, SIGCONT)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored4, SIGTRAP)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored5, SIGBUS)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored6, SIGILL)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored7, SIGFPE)
TRACEME_RAISESIGNAL_IGNORED(traceme_raisesignal_ignored8, SIGSEGV)
static void
traceme_raisesignal_masked(int sigmasked)
{
const int exitval = 5;
const int sigval = SIGSTOP;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
sigset_t intmask;
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sigemptyset(&intmask);
sigaddset(&intmask, sigmasked);
sigprocmask(SIG_BLOCK, &intmask, NULL);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before raising %s breakpoint from child\n",
strsignal(sigmasked));
FORKEE_ASSERT(raise(sigmasked) == 0);
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_RAISESIGNAL_MASKED(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that masking (with SIG_BLOCK) " #sig " in tracee " \
"stops tracer from catching this raised signal"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_raisesignal_masked(sig); \
}
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked1, SIGABRT)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked2, SIGHUP)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked3, SIGCONT)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked4, SIGTRAP)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked5, SIGBUS)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked6, SIGILL)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked7, SIGFPE)
TRACEME_RAISESIGNAL_MASKED(traceme_raisesignal_masked8, SIGSEGV)
static void
traceme_crash(int sig)
{
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sig);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sig);
switch (sig) {
case SIGTRAP:
TEST_CHECK_EQ(info.psi_siginfo.si_code, TRAP_BRKPT);
break;
case SIGSEGV:
TEST_CHECK_EQ(info.psi_siginfo.si_code, SEGV_MAPERR);
break;
case SIGILL:
ATF_CHECK_MSG((info.psi_siginfo.si_code >= ILL_ILLOPC &&
info.psi_siginfo.si_code <= ILL_BADSTK),
"info.psi_siginfo.si_code=%d ILL_ILLOPC=%d ILL_BADSTK=%d",
info.psi_siginfo.si_code, ILL_ILLOPC, ILL_BADSTK);
break;
case SIGFPE:
break;
case SIGBUS:
TEST_CHECK_EQ(info.psi_siginfo.si_code, BUS_ADRERR);
break;
}
SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, SIGKILL, 0);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify crash signal " #sig " in a child after PT_TRACE_ME"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_crash(sig); \
}
TRACEME_CRASH(traceme_crash_trap, SIGTRAP)
TRACEME_CRASH(traceme_crash_segv, SIGSEGV)
TRACEME_CRASH(traceme_crash_ill, SIGILL)
TRACEME_CRASH(traceme_crash_fpe, SIGFPE)
TRACEME_CRASH(traceme_crash_bus, SIGBUS)
static void
traceme_signalmasked_crash(int sig)
{
const int sigval = SIGSTOP;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
sigset_t intmask;
struct kinfo_proc2 kp;
size_t len = sizeof(kp);
int name[6];
const size_t namelen = __arraycount(name);
ki_sigset_t kp_sigmask;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
#ifdef SOFTFLOAT
if (sig == SIGFPE)
debug = 1;
#endif
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sigemptyset(&intmask);
sigaddset(&intmask, sig);
sigprocmask(SIG_BLOCK, &intmask, NULL);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
name[0] = CTL_KERN,
name[1] = KERN_PROC2,
name[2] = KERN_PROC_PID;
name[3] = child;
name[4] = sizeof(kp);
name[5] = 1;
RL(sysctl(name, namelen, &kp, &len, NULL, 0));
kp_sigmask = kp.p_sigmask;
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sig);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
RL(sysctl(name, namelen, &kp, &len, NULL, 0));
DPRINTF("kp_sigmask="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n",
kp_sigmask.__bits[0], kp_sigmask.__bits[1], kp_sigmask.__bits[2],
kp_sigmask.__bits[3]);
DPRINTF("kp.p_sigmask="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n",
kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1],
kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]);
#ifdef SOFTFLOAT
if (sig == SIGFPE)
softfloat_fudge_sigs(&kp_sigmask, &kp.p_sigmask);
#endif
TEST_CHECK_MEMEQ(&kp_sigmask, &kp.p_sigmask, sizeof(kp_sigmask));
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sig);
switch (sig) {
case SIGTRAP:
TEST_CHECK_EQ(info.psi_siginfo.si_code, TRAP_BRKPT);
break;
case SIGSEGV:
TEST_CHECK_EQ(info.psi_siginfo.si_code, SEGV_MAPERR);
break;
case SIGILL:
ATF_CHECK_MSG((info.psi_siginfo.si_code >= ILL_ILLOPC &&
info.psi_siginfo.si_code <= ILL_BADSTK),
"info.psi_siginfo.si_code=%d ILL_ILLOPC=%d ILL_BADSTK=%d",
info.psi_siginfo.si_code, ILL_ILLOPC, ILL_BADSTK);
break;
case SIGFPE:
break;
case SIGBUS:
TEST_CHECK_EQ(info.psi_siginfo.si_code, BUS_ADRERR);
break;
}
SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, SIGKILL, 0);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SIGNALMASKED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify masked crash signal " #sig " in a child after " \
"PT_TRACE_ME is delivered to its tracer"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_signalmasked_crash(sig); \
}
TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_trap, SIGTRAP)
TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_segv, SIGSEGV)
TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_ill, SIGILL)
TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_fpe, SIGFPE)
TRACEME_SIGNALMASKED_CRASH(traceme_signalmasked_crash_bus, SIGBUS)
static void
traceme_signalignored_crash(int sig)
{
const int sigval = SIGSTOP;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct sigaction sa;
struct ptrace_siginfo info;
struct kinfo_proc2 kp;
size_t len = sizeof(kp);
int name[6];
const size_t namelen = __arraycount(name);
ki_sigset_t kp_sigignore;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
#ifdef SOFTFLOAT
if (sig == SIGFPE)
debug = 1;
#endif
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
name[0] = CTL_KERN,
name[1] = KERN_PROC2,
name[2] = KERN_PROC_PID;
name[3] = child;
name[4] = sizeof(kp);
name[5] = 1;
RL(sysctl(name, namelen, &kp, &len, NULL, 0));
kp_sigignore = kp.p_sigignore;
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sig);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
RL(sysctl(name, namelen, &kp, &len, NULL, 0));
DPRINTF("kp_sigignore="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n",
kp_sigignore.__bits[0], kp_sigignore.__bits[1],
kp_sigignore.__bits[2], kp_sigignore.__bits[3]);
DPRINTF("kp.p_sigignore="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02" PRIx32"\n",
kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1],
kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]);
#ifdef SOFTFLOAT
if (sig == SIGFPE)
softfloat_fudge_sigs(&kp_sigignore, &kp.p_sigignore);
#endif
TEST_CHECK_MEMEQ(&kp_sigignore, &kp.p_sigignore, sizeof(kp_sigignore));
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sig);
switch (sig) {
case SIGTRAP:
TEST_CHECK_EQ(info.psi_siginfo.si_code, TRAP_BRKPT);
break;
case SIGSEGV:
TEST_CHECK_EQ(info.psi_siginfo.si_code, SEGV_MAPERR);
break;
case SIGILL:
ATF_CHECK_MSG((info.psi_siginfo.si_code >= ILL_ILLOPC &&
info.psi_siginfo.si_code <= ILL_BADSTK),
"info.psi_siginfo.si_code=%d ILL_ILLOPC=%d ILL_BADSTK=%d",
info.psi_siginfo.si_code, ILL_ILLOPC, ILL_BADSTK);
break;
case SIGFPE:
break;
case SIGBUS:
TEST_CHECK_EQ(info.psi_siginfo.si_code, BUS_ADRERR);
break;
}
SYSCALL_REQUIRE(ptrace(PT_KILL, child, NULL, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, SIGKILL, 0);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SIGNALIGNORED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify ignored crash signal " #sig " in a child after " \
"PT_TRACE_ME is delivered to its tracer"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_signalignored_crash(sig); \
}
TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_trap, SIGTRAP)
TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_segv, SIGSEGV)
TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_ill, SIGILL)
TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_fpe, SIGFPE)
TRACEME_SIGNALIGNORED_CRASH(traceme_signalignored_crash_bus, SIGBUS)
static void
traceme_sendsignal_handle(int sigsent, void (*sah)(int a), int *traceme_caught)
{
const int exitval = 5;
const int sigval = SIGSTOP;
pid_t child, wpid;
struct sigaction sa;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sa.sa_handler = sah;
sa.sa_flags = SA_SIGINFO;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
FORKEE_ASSERT_EQ(*traceme_caught, 1);
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and with "
"signal %s to be sent\n", strsignal(sigsent));
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SENDSIGNAL_HANDLE(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that a signal " #sig " emitted by a tracer to a child is " \
"handled correctly and caught by a signal handler"); \
} \
\
static int test##_caught = 0; \
\
static void \
test##_sighandler(int arg) \
{ \
FORKEE_ASSERT_EQ(arg, sig); \
\
++ test##_caught; \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_sendsignal_handle(sig, test##_sighandler, & test##_caught); \
}
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle1, SIGABRT)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle2, SIGHUP)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle3, SIGCONT)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle4, SIGTRAP)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle5, SIGBUS)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle6, SIGILL)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle7, SIGFPE)
TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle8, SIGSEGV)
static void
traceme_sendsignal_masked(int sigsent)
{
const int exitval = 5;
const int sigval = SIGSTOP;
pid_t child, wpid;
sigset_t set;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sigemptyset(&set);
sigaddset(&set, sigsent);
FORKEE_ASSERT(sigprocmask(SIG_BLOCK, &set, NULL) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and with "
"signal %s to be sent\n", strsignal(sigsent));
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SENDSIGNAL_MASKED(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that a signal " #sig " emitted by a tracer to a child is " \
"handled correctly and the signal is masked by SIG_BLOCK"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_sendsignal_masked(sig); \
}
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked1, SIGABRT)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked2, SIGHUP)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked3, SIGCONT)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked4, SIGTRAP)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked5, SIGBUS)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked6, SIGILL)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked7, SIGFPE)
TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked8, SIGSEGV)
static void
traceme_sendsignal_ignored(int sigsent)
{
const int exitval = 5;
const int sigval = SIGSTOP;
pid_t child, wpid;
struct sigaction sa;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and with "
"signal %s to be sent\n", strsignal(sigsent));
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SENDSIGNAL_IGNORED(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that a signal " #sig " emitted by a tracer to a child is " \
"handled correctly and the signal is masked by SIG_IGN"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_sendsignal_ignored(sig); \
}
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored1, SIGABRT)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored2, SIGHUP)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored3, SIGCONT)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored4, SIGTRAP)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored5, SIGBUS)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored6, SIGILL)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored7, SIGFPE)
TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored8, SIGSEGV)
static void
traceme_sendsignal_simple(int sigsent)
{
const int sigval = SIGSTOP;
int exitval = 0;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
int expect_core;
switch (sigsent) {
case SIGABRT:
case SIGTRAP:
case SIGBUS:
case SIGILL:
case SIGFPE:
case SIGSEGV:
expect_core = 1;
break;
default:
expect_core = 0;
break;
}
#endif
struct ptrace_siginfo info;
memset(&info, 0, sizeof(info));
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
switch (sigsent) {
case SIGCONT:
case SIGSTOP:
_exit(exitval);
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off and with "
"signal %s to be sent\n", strsignal(sigsent));
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
switch (sigsent) {
case SIGSTOP:
validate_status_stopped(status, sigsent);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for "
"child\n");
SYSCALL_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info,
sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x "
"si_errno=%#x\n",
info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
info.psi_siginfo.si_errno);
TEST_CHECK_EQ(info.psi_siginfo.si_signo, sigval);
TEST_CHECK_EQ(info.psi_siginfo.si_code, SI_LWP);
DPRINTF("Before resuming the child process where it left off "
"and with signal %s to be sent\n", strsignal(sigsent));
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0),
child);
case SIGCONT:
validate_status_exited(status, exitval);
break;
default:
validate_status_signaled(status, sigsent, expect_core);
break;
}
DPRINTF("Before calling %s() for the exited child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_SENDSIGNAL_SIMPLE(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify that a signal " #sig " emitted by a tracer to a child is " \
"handled correctly in a child without a signal handler"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_sendsignal_simple(sig); \
}
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple1, SIGKILL)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple2, SIGSTOP)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple3, SIGABRT)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple4, SIGHUP)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple5, SIGCONT)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple6, SIGTRAP)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple7, SIGBUS)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple8, SIGILL)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple9, SIGFPE)
TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple10, SIGSEGV)
static void
traceme_vfork_raise(int sigval)
{
const int exitval = 5, exitval_watcher = 10;
pid_t child, parent, watcher, wpid;
int rv;
#if defined(TWAIT_HAVE_STATUS)
int status;
volatile int expect_core;
switch (sigval) {
case SIGABRT:
case SIGTRAP:
case SIGBUS:
case SIGILL:
case SIGFPE:
case SIGSEGV:
expect_core = 1;
break;
default:
expect_core = 0;
break;
}
#endif
if (sigval == SIGSTOP) {
parent = getpid();
RL(watcher = fork());
ATF_REQUIRE(watcher != 1);
if (watcher == 0) {
watcher = fork();
FORKEE_ASSERT_NEQ(watcher, -1);
if (watcher != 0)
_exit(exitval_watcher);
child = await_stopped_child(parent);
errno = 0;
rv = kill(child, SIGKILL);
FORKEE_ASSERT_EQ(rv, 0);
FORKEE_ASSERT_EQ(errno, 0);
_exit(0);
}
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(watcher, &status, 0),
watcher);
validate_status_exited(status, exitval_watcher);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD,
wpid = TWAIT_GENERIC(watcher, &status, 0));
}
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = vfork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
switch (sigval) {
case SIGSTOP:
case SIGKILL:
case SIGABRT:
case SIGHUP:
case SIGTRAP:
case SIGBUS:
case SIGILL:
case SIGFPE:
case SIGSEGV:
FORKEE_ASSERTX(0 && "This shall not be reached");
__unreachable();
default:
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
switch (sigval) {
case SIGKILL:
case SIGABRT:
case SIGHUP:
case SIGTRAP:
case SIGBUS:
case SIGILL:
case SIGFPE:
case SIGSEGV:
validate_status_signaled(status, sigval, expect_core);
break;
case SIGSTOP:
validate_status_signaled(status, SIGKILL, 0);
break;
case SIGCONT:
case SIGTSTP:
case SIGTTIN:
case SIGTTOU:
validate_status_exited(status, exitval);
break;
default:
ATF_REQUIRE(0 && "NOT IMPLEMENTED");
break;
}
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_VFORK_RAISE(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify PT_TRACE_ME followed by raise of " #sig " in a " \
"vfork(2)ed child"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_vfork_raise(sig); \
}
TRACEME_VFORK_RAISE(traceme_vfork_raise1, SIGKILL)
TRACEME_VFORK_RAISE(traceme_vfork_raise2, SIGSTOP)
TRACEME_VFORK_RAISE(traceme_vfork_raise3, SIGTSTP)
TRACEME_VFORK_RAISE(traceme_vfork_raise4, SIGTTIN)
TRACEME_VFORK_RAISE(traceme_vfork_raise5, SIGTTOU)
TRACEME_VFORK_RAISE(traceme_vfork_raise6, SIGABRT)
TRACEME_VFORK_RAISE(traceme_vfork_raise7, SIGHUP)
TRACEME_VFORK_RAISE(traceme_vfork_raise8, SIGCONT)
TRACEME_VFORK_RAISE(traceme_vfork_raise9, SIGTRAP)
TRACEME_VFORK_RAISE(traceme_vfork_raise10, SIGBUS)
TRACEME_VFORK_RAISE(traceme_vfork_raise11, SIGILL)
TRACEME_VFORK_RAISE(traceme_vfork_raise12, SIGFPE)
TRACEME_VFORK_RAISE(traceme_vfork_raise13, SIGSEGV)
static void
traceme_vfork_crash(int sig)
{
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = vfork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, sig, 1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_VFORK_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \
"vfork(2)ed child"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_vfork_crash(sig); \
}
TRACEME_VFORK_CRASH(traceme_vfork_crash_trap, SIGTRAP)
TRACEME_VFORK_CRASH(traceme_vfork_crash_segv, SIGSEGV)
TRACEME_VFORK_CRASH(traceme_vfork_crash_ill, SIGILL)
TRACEME_VFORK_CRASH(traceme_vfork_crash_fpe, SIGFPE)
TRACEME_VFORK_CRASH(traceme_vfork_crash_bus, SIGBUS)
static void
traceme_vfork_signalmasked_crash(int sig)
{
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
sigset_t intmask;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = vfork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sigemptyset(&intmask);
sigaddset(&intmask, sig);
sigprocmask(SIG_BLOCK, &intmask, NULL);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, sig, 1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_VFORK_SIGNALMASKED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \
"vfork(2)ed child with a masked signal"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_vfork_signalmasked_crash(sig); \
}
TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_trap, SIGTRAP)
TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_segv, SIGSEGV)
TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_ill, SIGILL)
TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_fpe, SIGFPE)
TRACEME_VFORK_SIGNALMASKED_CRASH(traceme_vfork_signalmasked_crash_bus, SIGBUS)
static void
traceme_vfork_signalignored_crash(int sig)
{
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct sigaction sa;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = vfork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_signaled(status, sig, 1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define TRACEME_VFORK_SIGNALIGNORED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Verify PT_TRACE_ME followed by a crash signal " #sig " in a " \
"vfork(2)ed child with ignored signal"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
traceme_vfork_signalignored_crash(sig); \
}
TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_trap,
SIGTRAP)
TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_segv,
SIGSEGV)
TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_ill,
SIGILL)
TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_fpe,
SIGFPE)
TRACEME_VFORK_SIGNALIGNORED_CRASH(traceme_vfork_signalignored_crash_bus,
SIGBUS)
#if defined(TWAIT_HAVE_PID)
static void
unrelated_tracer_sees_crash(int sig, bool masked, bool ignored)
{
const int sigval = SIGSTOP;
struct msg_fds parent_tracee, parent_tracer;
const int exitval = 10;
pid_t tracee, tracer, wpid;
uint8_t msg = 0xde;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
struct sigaction sa;
struct ptrace_siginfo info;
sigset_t intmask;
struct kinfo_proc2 kp;
size_t len = sizeof(kp);
int name[6];
const size_t namelen = __arraycount(name);
ki_sigset_t kp_sigmask;
ki_sigset_t kp_sigignore;
#ifndef PTRACE_ILLEGAL_ASM
if (sig == SIGILL)
atf_tc_skip("PTRACE_ILLEGAL_ASM not defined");
#endif
if (sig == SIGFPE && !are_fpu_exceptions_supported())
atf_tc_skip("FP exceptions are not supported");
memset(&info, 0, sizeof(info));
DPRINTF("Spawn tracee\n");
SYSCALL_REQUIRE(msg_open(&parent_tracee) == 0);
tracee = atf_utils_fork();
if (tracee == 0) {
CHILD_FROM_PARENT("exit tracee", parent_tracee, msg);
if (masked) {
sigemptyset(&intmask);
sigaddset(&intmask, sig);
sigprocmask(SIG_BLOCK, &intmask, NULL);
}
if (ignored) {
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
FORKEE_ASSERT(sigaction(sig, &sa, NULL) != -1);
}
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before executing a trap\n");
switch (sig) {
case SIGTRAP:
trigger_trap();
break;
case SIGSEGV:
trigger_segv();
break;
case SIGILL:
trigger_ill();
break;
case SIGFPE:
trigger_fpe();
break;
case SIGBUS:
trigger_bus();
break;
default:
FORKEE_ASSERTX(0 && "This shall not be reached");
}
FORKEE_ASSERTX(0 && "This shall not be reached");
}
DPRINTF("Spawn debugger\n");
SYSCALL_REQUIRE(msg_open(&parent_tracer) == 0);
tracer = atf_utils_fork();
if (tracer == 0) {
tracer = atf_utils_fork();
if (tracer != 0)
_exit(exitval);
DPRINTF("Before calling PT_ATTACH from tracee %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
FORKEE_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
forkee_status_stopped(status, SIGSTOP);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the "
"traced process\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x "
"si_errno=%#x\n", info.psi_siginfo.si_signo,
info.psi_siginfo.si_code, info.psi_siginfo.si_errno);
FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, SIGSTOP);
FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_USER);
FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
CHILD_TO_PARENT("tracer ready", parent_tracer, msg);
CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg);
FORKEE_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
forkee_status_stopped(status, sigval);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the "
"traced process\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x "
"si_errno=%#x\n", info.psi_siginfo.si_signo,
info.psi_siginfo.si_code, info.psi_siginfo.si_errno);
FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sigval);
FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SI_LWP);
name[0] = CTL_KERN,
name[1] = KERN_PROC2,
name[2] = KERN_PROC_PID;
name[3] = tracee;
name[4] = sizeof(kp);
name[5] = 1;
FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0);
if (masked)
kp_sigmask = kp.p_sigmask;
if (ignored)
kp_sigignore = kp.p_sigignore;
FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
FORKEE_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
forkee_status_stopped(status, sig);
DPRINTF("Before calling ptrace(2) with PT_GET_SIGINFO for the "
"traced process\n");
SYSCALL_REQUIRE(
ptrace(PT_GET_SIGINFO, tracee, &info, sizeof(info)) != -1);
DPRINTF("Signal traced to lwpid=%d\n", info.psi_lwpid);
DPRINTF("Signal properties: si_signo=%#x si_code=%#x "
"si_errno=%#x\n", info.psi_siginfo.si_signo,
info.psi_siginfo.si_code, info.psi_siginfo.si_errno);
FORKEE_ASSERT_EQ(info.psi_siginfo.si_signo, sig);
FORKEE_ASSERT_EQ(sysctl(name, namelen, &kp, &len, NULL, 0), 0);
if (masked) {
DPRINTF("kp_sigmask="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02"
PRIx32 "\n",
kp_sigmask.__bits[0], kp_sigmask.__bits[1],
kp_sigmask.__bits[2], kp_sigmask.__bits[3]);
DPRINTF("kp.p_sigmask="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02"
PRIx32 "\n",
kp.p_sigmask.__bits[0], kp.p_sigmask.__bits[1],
kp.p_sigmask.__bits[2], kp.p_sigmask.__bits[3]);
#ifdef SOFTFLOAT
if (sig == SIGFPE) {
softfloat_fudge_sigs(&kp_sigmask,
&kp.p_sigmask);
}
#endif
FORKEE_ASSERT_MEMEQ(&kp_sigmask, &kp.p_sigmask,
sizeof(kp_sigmask));
}
if (ignored) {
DPRINTF("kp_sigignore="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02"
PRIx32 "\n",
kp_sigignore.__bits[0], kp_sigignore.__bits[1],
kp_sigignore.__bits[2], kp_sigignore.__bits[3]);
DPRINTF("kp.p_sigignore="
"%#02" PRIx32 "%02" PRIx32 "%02" PRIx32 "%02"
PRIx32 "\n",
kp.p_sigignore.__bits[0], kp.p_sigignore.__bits[1],
kp.p_sigignore.__bits[2], kp.p_sigignore.__bits[3]);
#ifdef SOFTFLOAT
if (sig == SIGFPE) {
softfloat_fudge_sigs(&kp_sigignore,
&kp.p_sigignore);
}
#endif
FORKEE_ASSERT_MEMEQ(&kp_sigignore, &kp.p_sigignore,
sizeof(kp_sigignore));
}
switch (sig) {
case SIGTRAP:
FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, TRAP_BRKPT);
break;
case SIGSEGV:
FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, SEGV_MAPERR);
break;
case SIGILL:
FORKEE_ASSERT(info.psi_siginfo.si_code >= ILL_ILLOPC &&
info.psi_siginfo.si_code <= ILL_BADSTK);
break;
case SIGFPE:
break;
case SIGBUS:
FORKEE_ASSERT_EQ(info.psi_siginfo.si_code, BUS_ADRERR);
break;
}
FORKEE_ASSERT(ptrace(PT_KILL, tracee, NULL, 0) != -1);
DPRINTF("Before calling %s() for the tracee\n", TWAIT_FNAME);
FORKEE_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
forkee_status_signaled(status, SIGKILL, 0);
CHILD_TO_PARENT("tracer done", parent_tracer, msg);
DPRINTF("Before exiting of the tracer process\n");
_exit(0 );
}
DPRINTF("Wait for the tracer process (direct child) to exit "
"calling %s()\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracer, &status, 0), tracer);
validate_status_exited(status, exitval);
DPRINTF("Wait for the non-exited tracee process with %s()\n",
TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(
wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0);
DPRINTF("Wait for the tracer to attach to the tracee\n");
PARENT_FROM_CHILD("tracer ready", parent_tracer, msg);
DPRINTF("Resume the tracee and let it crash\n");
PARENT_TO_CHILD("exit tracee", parent_tracee, msg);
DPRINTF("Resume the tracer and let it detect crashed tracee\n");
PARENT_TO_CHILD("Message 2", parent_tracer, msg);
DPRINTF("Wait for tracee to finish its job and exit - calling %s()\n",
TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
validate_status_signaled(status, SIGKILL, 0);
DPRINTF("Await normal exit of tracer\n");
PARENT_FROM_CHILD("tracer done", parent_tracer, msg);
msg_close(&parent_tracer);
msg_close(&parent_tracee);
}
#define UNRELATED_TRACER_SEES_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Assert that an unrelated tracer sees crash signal from " \
"the debuggee"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
unrelated_tracer_sees_crash(sig, false, false); \
}
UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_trap, SIGTRAP)
UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_segv, SIGSEGV)
UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_ill, SIGILL)
UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_fpe, SIGFPE)
UNRELATED_TRACER_SEES_CRASH(unrelated_tracer_sees_crash_bus, SIGBUS)
#define UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Assert that an unrelated tracer sees crash signal from " \
"the debuggee with masked signal"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
unrelated_tracer_sees_crash(sig, true, false); \
}
UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(
unrelated_tracer_sees_signalmasked_crash_trap, SIGTRAP)
UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(
unrelated_tracer_sees_signalmasked_crash_segv, SIGSEGV)
UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(
unrelated_tracer_sees_signalmasked_crash_ill, SIGILL)
UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(
unrelated_tracer_sees_signalmasked_crash_fpe, SIGFPE)
UNRELATED_TRACER_SEES_SIGNALMASKED_CRASH(
unrelated_tracer_sees_signalmasked_crash_bus, SIGBUS)
#define UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(test, sig) \
ATF_TC(test); \
ATF_TC_HEAD(test, tc) \
{ \
atf_tc_set_md_var(tc, "descr", \
"Assert that an unrelated tracer sees crash signal from " \
"the debuggee with signal ignored"); \
} \
\
ATF_TC_BODY(test, tc) \
{ \
\
unrelated_tracer_sees_crash(sig, false, true); \
}
UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(
unrelated_tracer_sees_signalignored_crash_trap, SIGTRAP)
UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(
unrelated_tracer_sees_signalignored_crash_segv, SIGSEGV)
UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(
unrelated_tracer_sees_signalignored_crash_ill, SIGILL)
UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(
unrelated_tracer_sees_signalignored_crash_fpe, SIGFPE)
UNRELATED_TRACER_SEES_SIGNALIGNORED_CRASH(
unrelated_tracer_sees_signalignored_crash_bus, SIGBUS)
#endif
ATF_TC(signal_mask_unrelated);
ATF_TC_HEAD(signal_mask_unrelated, tc)
{
atf_tc_set_md_var(tc, "descr",
"Verify that masking single unrelated signal does not stop tracer "
"from catching other signals");
}
ATF_TC_BODY(signal_mask_unrelated, tc)
{
const int exitval = 5;
const int sigval = SIGSTOP;
const int sigmasked = SIGTRAP;
const int signotmasked = SIGINT;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
int status;
#endif
sigset_t intmask;
DPRINTF("Before forking process PID=%d\n", getpid());
RL(child = fork());
if (child == 0) {
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
sigemptyset(&intmask);
sigaddset(&intmask, sigmasked);
sigprocmask(SIG_BLOCK, &intmask, NULL);
DPRINTF("Before raising %s from child\n", strsignal(sigval));
FORKEE_ASSERT(raise(sigval) == 0);
DPRINTF("Before raising %s from child\n",
strsignal(signotmasked));
FORKEE_ASSERT(raise(signotmasked) == 0);
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
}
DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, sigval);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_stopped(status, signotmasked);
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
validate_status_exited(status, exitval);
DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
#define ATF_TP_ADD_TCS_PTRACE_WAIT_SIGNAL() \
ATF_TP_ADD_TC(tp, traceme_raise1); \
ATF_TP_ADD_TC(tp, traceme_raise2); \
ATF_TP_ADD_TC(tp, traceme_raise3); \
ATF_TP_ADD_TC(tp, traceme_raise4); \
ATF_TP_ADD_TC(tp, traceme_raise5); \
ATF_TP_ADD_TC(tp, traceme_raise6); \
ATF_TP_ADD_TC(tp, traceme_raise7); \
ATF_TP_ADD_TC(tp, traceme_raise8); \
ATF_TP_ADD_TC(tp, traceme_raise9); \
ATF_TP_ADD_TC(tp, traceme_raise10); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored1); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored2); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored3); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored4); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored5); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored6); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored7); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_ignored8); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked1); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked2); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked3); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked4); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked5); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked6); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked7); \
ATF_TP_ADD_TC(tp, traceme_raisesignal_masked8); \
ATF_TP_ADD_TC(tp, traceme_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_crash_bus); \
ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_signalmasked_crash_bus); \
ATF_TP_ADD_TC(tp, traceme_signalignored_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_signalignored_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_signalignored_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_signalignored_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_signalignored_crash_bus); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle1); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle2); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle3); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle4); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle5); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle6); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle7); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_handle8); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked1); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked2); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked3); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked4); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked5); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked6); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked7); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_masked8); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored1); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored2); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored3); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored4); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored5); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored6); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored7); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored8); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple1); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple2); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple3); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple4); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple5); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple6); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple7); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple8); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple9); \
ATF_TP_ADD_TC(tp, traceme_sendsignal_simple10); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise1); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise2); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise3); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise4); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise5); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise6); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise7); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise8); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise9); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise10); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise11); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise12); \
ATF_TP_ADD_TC(tp, traceme_vfork_raise13); \
ATF_TP_ADD_TC(tp, traceme_vfork_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_vfork_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_vfork_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_vfork_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_vfork_crash_bus); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalmasked_crash_bus); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_trap); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_segv); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_ill); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_fpe); \
ATF_TP_ADD_TC(tp, traceme_vfork_signalignored_crash_bus); \
ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_trap); \
ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_segv); \
ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_ill); \
ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_fpe); \
ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_bus); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalmasked_crash_trap); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalmasked_crash_segv); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalmasked_crash_ill); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalmasked_crash_fpe); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalmasked_crash_bus); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalignored_crash_trap); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalignored_crash_segv); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalignored_crash_ill); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalignored_crash_fpe); \
ATF_TP_ADD_TC_HAVE_PID(tp, \
unrelated_tracer_sees_signalignored_crash_bus); \
ATF_TP_ADD_TC(tp, signal_mask_unrelated);
