/* $NetBSD: t_ptrace_wait.h,v 1.42 2025/05/09 01:32:25 riastradh Exp $ */ /*- * Copyright (c) 2016, 2017, 2018, 2019 The NetBSD Foundation, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* Detect plain wait(2) use-case */ #if !defined(TWAIT_WAITPID) && \ !defined(TWAIT_WAITID) && \ !defined(TWAIT_WAIT3) && \ !defined(TWAIT_WAIT4) && \ !defined(TWAIT_WAIT6) #define TWAIT_WAIT #endif /* * There are two classes of wait(2)-like functions: * - wait4(2)-like accepting pid_t, optional options parameter, struct rusage* * - wait6(2)-like accepting idtype_t, id_t, struct wrusage, mandatory options * * The TWAIT_FNAME value is to be used for convenience in debug messages. * * The TWAIT_GENERIC() macro is designed to reuse the same unmodified * code with as many wait(2)-like functions as possible. * * In a common use-case wait4(2) and wait6(2)-like function can work the almost * the same way, however there are few important differences: * wait6(2) must specify P_PID for idtype to match wpid from wait4(2). * To behave like wait4(2), wait6(2) the 'options' to wait must include * WEXITED|WTRUNCATED. * * There are two helper macros (they purpose it to mach more than one * wait(2)-like function): * The TWAIT_HAVE_STATUS - specifies whether a function can retrieve * status (as integer value). * The TWAIT_HAVE_PID - specifies whether a function can request * exact process identifier * The TWAIT_HAVE_RUSAGE - specifies whether a function can request * the struct rusage value * */ #if defined(TWAIT_WAIT) # define TWAIT_FNAME "wait" # define TWAIT_WAIT4TYPE(a,b,c,d) wait((b)) # define TWAIT_GENERIC(a,b,c) wait((b)) # define TWAIT_HAVE_STATUS 1 #elif defined(TWAIT_WAITPID) # define TWAIT_FNAME "waitpid" # define TWAIT_WAIT4TYPE(a,b,c,d) waitpid((a),(b),(c)) # define TWAIT_GENERIC(a,b,c) waitpid((a),(b),(c)) # define TWAIT_HAVE_PID 1 # define TWAIT_HAVE_STATUS 1 # define TWAIT_HAVE_OPTIONS 1 #elif defined(TWAIT_WAITID) # define TWAIT_FNAME "waitid" # define TWAIT_GENERIC(a,b,c) \ waitid(P_PID,(a),NULL,(c)|WEXITED|WTRAPPED) # define TWAIT_WAIT6TYPE(a,b,c,d,e,f) waitid((a),(b),(f),(d)) # define TWAIT_HAVE_PID 1 # define TWAIT_HAVE_OPTIONS 1 #elif defined(TWAIT_WAIT3) # define TWAIT_FNAME "wait3" # define TWAIT_WAIT4TYPE(a,b,c,d) wait3((b),(c),(d)) # define TWAIT_GENERIC(a,b,c) wait3((b),(c),NULL) # define TWAIT_HAVE_STATUS 1 # define TWAIT_HAVE_RUSAGE 1 # define TWAIT_HAVE_OPTIONS 1 #elif defined(TWAIT_WAIT4) # define TWAIT_FNAME "wait4" # define TWAIT_WAIT4TYPE(a,b,c,d) wait4((a),(b),(c),(d)) # define TWAIT_GENERIC(a,b,c) wait4((a),(b),(c),NULL) # define TWAIT_HAVE_PID 1 # define TWAIT_HAVE_STATUS 1 # define TWAIT_HAVE_RUSAGE 1 # define TWAIT_HAVE_OPTIONS 1 #elif defined(TWAIT_WAIT6) # define TWAIT_FNAME "wait6" # define TWAIT_WAIT6TYPE(a,b,c,d,e,f) wait6((a),(b),(c),(d),(e),(f)) # define TWAIT_GENERIC(a,b,c) \ wait6(P_PID,(a),(b),(c)|WEXITED|WTRAPPED,NULL,NULL) # define TWAIT_HAVE_PID 1 # define TWAIT_HAVE_STATUS 1 # define TWAIT_HAVE_OPTIONS 1 #endif /* * There are 3 groups of tests: * - TWAIT_GENERIC() (wait, wait2, waitpid, wait3, wait4, wait6) * - TWAIT_WAIT4TYPE() (wait2, waitpid, wait3, wait4) * - TWAIT_WAIT6TYPE() (waitid, wait6) * * Tests only in the above categories are allowed. However some tests are not * possible in the context requested functionality to be verified, therefore * there are helper macros: * - TWAIT_HAVE_PID (wait2, waitpid, waitid, wait4, wait6) * - TWAIT_HAVE_STATUS (wait, wait2, waitpid, wait3, wait4, wait6) * - TWAIT_HAVE_RUSAGE (wait3, wait4) * - TWAIT_HAVE_RETPID (wait, wait2, waitpid, wait3, wait4, wait6) * * If there is an intention to test e.g. wait6(2) specific features in the * ptrace(2) context, find the most matching group and with #ifdefs reduce * functionality of less featured than wait6(2) interface (TWAIT_WAIT6TYPE). * * For clarity never use negative preprocessor checks, like: * #if !defined(TWAIT_WAIT4) * always refer to checks for positive values. */ #define TEST_REQUIRE_EQ(x, y) \ do { \ uintmax_t vx = (x); \ uintmax_t vy = (y); \ int ret = vx == vy; \ if (!ret) \ ATF_REQUIRE_EQ_MSG(vx, vy, \ "%s(%ju=0x%jx) == %s(%ju=0x%jx)", \ #x, vx, vx, #y, vy, vy); \ } while (/*CONSTCOND*/0) #define TEST_CHECK_EQ(x, y) \ do { \ uintmax_t vx = (x); \ uintmax_t vy = (y); \ int ret = vx == vy; \ if (!ret) \ ATF_CHECK_EQ_MSG(vx, vy, \ "%s(%ju=0x%jx) == %s(%ju=0x%jx)", \ #x, vx, vx, #y, vy, vy); \ } while (/*CONSTCOND*/0) #define TEST_CHECK_MEMEQ(x, y, n) \ do { \ const void *vx = (x); \ const void *vy = (y); \ const size_t vn = (n); \ if (__predict_true(memcmp(vx, vy, vn) == 0)) \ break; \ hexdump(#x, vx, vn); \ hexdump(#y, vy, vn); \ atf_tc_fail_nonfatal("%s != %s (%s = %zu bytes)", \ #x, #y, #n, vn); \ } while (/*CONSTCOND*/0) /* * A child process cannot call atf functions and expect them to magically * work like in the parent. * The printf(3) messaging from a child will not work out of the box as well * without establishing a communication protocol with its parent. To not * overcomplicate the tests - do not log from a child and use err(3)/errx(3) * wrapped with FORKEE_ASSERT()/FORKEE_ASSERTX() as that is guaranteed to work. */ #define FORKEE_ASSERT_EQ(x, y) \ do { \ uintmax_t vx = (x); \ uintmax_t vy = (y); \ int ret = vx == vy; \ if (!ret) \ errx(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: " \ "%s(%jd=0x%jx) == %s(%jd=0x%jx)", \ __FILE__, __LINE__, __func__, \ #x, vx, vx, #y, vy, vy); \ } while (/*CONSTCOND*/0) #define FORKEE_ASSERT_NEQ(x, y) \ do { \ uintmax_t vx = (x); \ uintmax_t vy = (y); \ int ret = vx != vy; \ if (!ret) \ errx(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: " \ "%s(%ju=0x%jx) != %s(%ju=0x%jx)", \ __FILE__, __LINE__, __func__, \ #x, vx, vx, #y, vy, vy); \ } while (/*CONSTCOND*/0) __unused /* used by FORKEE_ASSERT_MEMEQ, otherwise not used */ static void hexdump(const char *title, const void *buf, size_t len) { const unsigned char *p = buf; size_t i; fprintf(stderr, "%s (%zu bytes)\n", title, len); for (i = 0; i < len; i++) { if ((i % 8) == 0) fprintf(stderr, " "); fprintf(stderr, " %02hhx", p[i]); if ((i % 16) == 15) fprintf(stderr, "\n"); } if (i % 16) fprintf(stderr, "\n"); } #define FORKEE_ASSERT_MEMEQ(x, y, n) \ do { \ const void *const vx = (x); \ const void *const vy = (y); \ const size_t vn = (n); \ \ if (__predict_true(memcmp(vx, vy, vn) == 0)) \ break; \ fprintf(stderr, "%s != %s (%s = %zu bytes)\n", #x, #y, #n, vn); \ hexdump(#x, vx, vn); \ hexdump(#y, vy, vn); \ errx(EXIT_FAILURE, "%s:%d %s(): failed", \ __FILE__, __LINE__, __func__); \ } while (/*CONSTCOND*/0) #define FORKEE_ASSERTX(x) \ do { \ int ret = (x); \ if (!ret) \ errx(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: %s",\ __FILE__, __LINE__, __func__, #x); \ } while (/*CONSTCOND*/0) #define FORKEE_ASSERT(x) \ do { \ int ret = (x); \ if (!ret) \ err(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: %s",\ __FILE__, __LINE__, __func__, #x); \ } while (/*CONSTCOND*/0) #define FORKEE_PTHREAD(x) \ do { \ int _forkee_pthread_error = (x); \ if (_forkee_pthread_error) { \ errno = _forkee_pthread_error; \ err(EXIT_FAILURE, "%s:%d %s(): %s", __FILE__, __LINE__, \ __func__, #x); \ } \ } while (/*CONSTCOND*/0) /* * Simplify logic for functions using general purpose registers add HAVE_GPREGS * * For platforms that do not implement all needed calls for simplicity assume * that they are unsupported at all. */ #if defined(PT_GETREGS) \ && defined(PT_SETREGS) \ && defined(PTRACE_REG_PC) \ && defined(PTRACE_REG_SET_PC) \ && defined(PTRACE_REG_SP) \ && defined(PTRACE_REG_INTRV) #define HAVE_GPREGS #endif /* Add guards for floating point registers */ #if defined(PT_GETFPREGS) \ && defined(PT_SETFPREGS) #define HAVE_FPREGS #endif /* Add guards for cpu debug registers */ #if defined(PT_GETDBREGS) \ && defined(PT_SETDBREGS) #define HAVE_DBREGS #endif /* * If waitid(2) returns because one or more processes have a state change to * report, 0 is returned. If an error is detected, a value of -1 is returned * and errno is set to indicate the error. If WNOHANG is specified and there * are no stopped, continued or exited children, 0 is returned. */ #if defined(TWAIT_WAITID) #define TWAIT_REQUIRE_SUCCESS(a,b) TEST_REQUIRE_EQ((a), 0) #define TWAIT_REQUIRE_FAILURE(a,b) ATF_REQUIRE_ERRNO((a),(b) == -1) #define FORKEE_REQUIRE_SUCCESS(a,b) FORKEE_ASSERT_EQ(a, 0) #define FORKEE_REQUIRE_FAILURE(a,b) \ FORKEE_ASSERTX(((a) == errno) && ((b) == -1)) #else #define TWAIT_REQUIRE_SUCCESS(a,b) TEST_REQUIRE_EQ((a), (b)) #define TWAIT_REQUIRE_FAILURE(a,b) ATF_REQUIRE_ERRNO((a),(b) == -1) #define FORKEE_REQUIRE_SUCCESS(a,b) FORKEE_ASSERT_EQ(a, b) #define FORKEE_REQUIRE_FAILURE(a,b) \ FORKEE_ASSERTX(((a) == errno) && ((b) == -1)) #endif /* * Helper tools to verify whether status reports exited value */ #if TWAIT_HAVE_STATUS static void __used validate_status_exited(int status, int expected) { ATF_REQUIRE_MSG(WIFEXITED(status), "Reported !exited process"); ATF_REQUIRE_MSG(!WIFCONTINUED(status), "Reported continued process"); ATF_REQUIRE_MSG(!WIFSIGNALED(status), "Reported signaled process"); ATF_REQUIRE_MSG(!WIFSTOPPED(status), "Reported stopped process"); ATF_REQUIRE_EQ_MSG(WEXITSTATUS(status), expected, "The process has exited with invalid value %d != %d", WEXITSTATUS(status), expected); } static void __used forkee_status_exited(int status, int expected) { FORKEE_ASSERTX(WIFEXITED(status)); FORKEE_ASSERTX(!WIFCONTINUED(status)); FORKEE_ASSERTX(!WIFSIGNALED(status)); FORKEE_ASSERTX(!WIFSTOPPED(status)); FORKEE_ASSERT_EQ(WEXITSTATUS(status), expected); } static void __used validate_status_continued(int status) { ATF_REQUIRE_MSG(!WIFEXITED(status), "Reported exited process"); ATF_REQUIRE_MSG(WIFCONTINUED(status), "Reported !continued process"); ATF_REQUIRE_MSG(!WIFSIGNALED(status), "Reported signaled process"); ATF_REQUIRE_MSG(!WIFSTOPPED(status), "Reported stopped process"); } static void __used forkee_status_continued(int status) { FORKEE_ASSERTX(!WIFEXITED(status)); FORKEE_ASSERTX(WIFCONTINUED(status)); FORKEE_ASSERTX(!WIFSIGNALED(status)); FORKEE_ASSERTX(!WIFSTOPPED(status)); } static void __used validate_status_signaled(int status, int expected_termsig, int expected_core) { ATF_REQUIRE_MSG(!WIFEXITED(status), "Reported exited process"); ATF_REQUIRE_MSG(!WIFCONTINUED(status), "Reported continued process"); ATF_REQUIRE_MSG(WIFSIGNALED(status), "Reported !signaled process"); ATF_REQUIRE_MSG(!WIFSTOPPED(status), "Reported stopped process"); ATF_REQUIRE_EQ_MSG(WTERMSIG(status), expected_termsig, "Unexpected signal received"); ATF_REQUIRE_EQ_MSG(!!WCOREDUMP(status), expected_core, "Unexpectedly core file %s generated", expected_core ? "not" : ""); } static void __used forkee_status_signaled(int status, int expected_termsig, int expected_core) { FORKEE_ASSERTX(!WIFEXITED(status)); FORKEE_ASSERTX(!WIFCONTINUED(status)); FORKEE_ASSERTX(WIFSIGNALED(status)); FORKEE_ASSERTX(!WIFSTOPPED(status)); FORKEE_ASSERT_EQ(WTERMSIG(status), expected_termsig); FORKEE_ASSERT_EQ(!!WCOREDUMP(status), expected_core); } static void __used validate_status_stopped(int status, int expected) { ATF_REQUIRE_MSG(!WIFEXITED(status), "Reported exited process"); ATF_REQUIRE_MSG(!WIFCONTINUED(status), "Reported continued process"); ATF_REQUIRE_MSG(!WIFSIGNALED(status), "Reported signaled process"); ATF_REQUIRE_MSG(WIFSTOPPED(status), "Reported !stopped process"); char st[128], ex[128]; strlcpy(st, strsignal(WSTOPSIG(status)), sizeof(st)); strlcpy(ex, strsignal(expected), sizeof(ex)); ATF_REQUIRE_EQ_MSG(WSTOPSIG(status), expected, "Unexpected stop signal received [%s] != [%s]", st, ex); } static void __used forkee_status_stopped(int status, int expected) { FORKEE_ASSERTX(!WIFEXITED(status)); FORKEE_ASSERTX(!WIFCONTINUED(status)); FORKEE_ASSERTX(!WIFSIGNALED(status)); FORKEE_ASSERTX(WIFSTOPPED(status)); FORKEE_ASSERT_EQ(WSTOPSIG(status), expected); } #else #define validate_status_exited(a,b) #define forkee_status_exited(a,b) #define validate_status_continued(a,b) #define forkee_status_continued(a,b) #define validate_status_signaled(a,b,c) #define forkee_status_signaled(a,b,c) #define validate_status_stopped(a,b) #define forkee_status_stopped(a,b) #endif /* This function is currently designed to be run in the main/parent process */ static void __used await_zombie_raw(pid_t process, useconds_t ms) { struct kinfo_proc2 p; size_t len = sizeof(p); const int name[] = { [0] = CTL_KERN, [1] = KERN_PROC2, [2] = KERN_PROC_PID, [3] = process, [4] = sizeof(p), [5] = 1 }; const size_t namelen = __arraycount(name); /* Await the process becoming a zombie */ while(1) { ATF_REQUIRE(sysctl(name, namelen, &p, &len, NULL, 0) == 0); if (p.p_stat == LSZOMB) break; if (ms > 0) { ATF_REQUIRE(usleep(ms) == 0); } } } static void __used await_zombie(pid_t process) { await_zombie_raw(process, 1000); } static void __used await_stopped(pid_t process) { struct kinfo_proc2 p; size_t len = sizeof(p); const int name[] = { [0] = CTL_KERN, [1] = KERN_PROC2, [2] = KERN_PROC_PID, [3] = process, [4] = sizeof(p), [5] = 1 }; const size_t namelen = __arraycount(name); /* Await the process becoming a zombie */ while(1) { ATF_REQUIRE(sysctl(name, namelen, &p, &len, NULL, 0) == 0); if (p.p_stat == LSSTOP) break; ATF_REQUIRE(usleep(1000) == 0); } } static pid_t __used await_stopped_child(pid_t process) { struct kinfo_proc2 *p = NULL; size_t i, len; pid_t child = -1; int name[] = { [0] = CTL_KERN, [1] = KERN_PROC2, [2] = KERN_PROC_ALL, [3] = 0, [4] = sizeof(struct kinfo_proc2), [5] = 0 }; const size_t namelen = __arraycount(name); /* Await the process becoming a zombie */ while(1) { name[5] = 0; FORKEE_ASSERT_EQ(sysctl(name, namelen, 0, &len, NULL, 0), 0); FORKEE_ASSERT_EQ(reallocarr(&p, len, sizeof(struct kinfo_proc2)), 0); name[5] = len; FORKEE_ASSERT_EQ(sysctl(name, namelen, p, &len, NULL, 0), 0); for (i = 0; i < len/sizeof(struct kinfo_proc2); i++) { if (p[i].p_pid == getpid()) continue; if (p[i].p_ppid != process) continue; if (p[i].p_stat != LSSTOP) continue; child = p[i].p_pid; break; } if (child != -1) break; FORKEE_ASSERT_EQ(usleep(1000), 0); } /* Free the buffer */ FORKEE_ASSERT_EQ(reallocarr(&p, 0, sizeof(struct kinfo_proc2)), 0); return child; } static void __used await_collected(pid_t process) { struct kinfo_proc2 p; size_t len = sizeof(p); const int name[] = { [0] = CTL_KERN, [1] = KERN_PROC2, [2] = KERN_PROC_PID, [3] = process, [4] = sizeof(p), [5] = 1 }; const size_t namelen = __arraycount(name); /* Await the process to disappear */ while(1) { FORKEE_ASSERT_EQ(sysctl(name, namelen, &p, &len, NULL, 0), 0); if (len == 0) break; ATF_REQUIRE(usleep(1000) == 0); } } /* Happy number sequence -- this function is used to just consume cpu cycles */ #define HAPPY_NUMBER 1 /* If n is not happy then its sequence ends in the cycle: * 4, 16, 37, 58, 89, 145, 42, 20, 4, ... */ #define SAD_NUMBER 4 /* Calculate the sum of the squares of the digits of n */ static unsigned __used dsum(unsigned n) { unsigned sum, x; for (sum = 0; n; n /= 10) { x = n % 10; sum += x * x; } return sum; } /* * XXX: Disabled optimization is required to make tests for hardware assisted * traps in .text functional * * Tested with GCC 5.4 on NetBSD 7.99.47 amd64 */ static int __used #ifdef __clang__ __attribute__((__optnone__)) #else __attribute__((__optimize__("O0"))) #endif check_happy(unsigned n) { for (;;) { unsigned total = dsum(n); if (total == HAPPY_NUMBER) return 1; if (total == SAD_NUMBER) return 0; n = total; } } static void * __used infinite_thread(void *arg __unused) { while (true) continue; __unreachable(); } static int __used clone_func(void *arg) { int ret; ret = (int)(intptr_t)arg; return ret; } #if defined(HAVE_DBREGS) static bool __used can_we_set_dbregs(void) { static long euid = -1; static int user_set_dbregs = -1; size_t user_set_dbregs_len = sizeof(user_set_dbregs); if (euid == -1) euid = geteuid(); if (euid == 0) return true; if (user_set_dbregs == -1) { if (sysctlbyname("security.models.extensions.user_set_dbregs", &user_set_dbregs, &user_set_dbregs_len, NULL, 0) == -1) { return false; } } if (user_set_dbregs > 0) return true; else return false; } #endif static bool __used get_user_va0_disable(void) { static int user_va0_disable = -1; size_t user_va0_disable_len = sizeof(user_va0_disable); if (user_va0_disable == -1) { if (sysctlbyname("vm.user_va0_disable", &user_va0_disable, &user_va0_disable_len, NULL, 0) == -1) { return true; } } if (user_va0_disable > 0) return true; else return false; } static bool __used can_we_write_to_text(pid_t pid) { int mib[3]; int paxflags; size_t len = sizeof(int); mib[0] = CTL_PROC; mib[1] = pid; mib[2] = PROC_PID_PAXFLAGS; if (sysctl(mib, 3, &paxflags, &len, NULL, 0) == -1) return false; return !(paxflags & CTL_PROC_PAXFLAGS_MPROTECT); } static void __used trigger_trap(void) { /* Software breakpoint causes CPU trap, translated to SIGTRAP */ #ifdef PTRACE_BREAKPOINT_ASM PTRACE_BREAKPOINT_ASM; #else /* port me */ #endif } static void __used trigger_segv(void) { static volatile char *ptr = NULL; /* Access to unmapped memory causes CPU trap, translated to SIGSEGV */ *ptr = 1; } static void __used trigger_ill(void) { /* Illegal instruction causes CPU trap, translated to SIGILL */ #ifdef PTRACE_ILLEGAL_ASM #ifndef __mips__ /* To avoid GXemul crash */ PTRACE_ILLEGAL_ASM; #endif #else /* port me */ #endif } #include #if (__arm__ && !__SOFTFP__) || __aarch64__ #include /* only need for ARM Cortex/Neon hack */ static bool __used are_fpu_exceptions_supported(void) { /* * Some NEON fpus do not trap on IEEE 754 FP exceptions. * Skip these tests if running on them and compiled for * hard float. */ if (0 == fpsetmask(fpsetmask(FP_X_INV))) return false; return true; } #elif defined __riscv__ #define are_fpu_exceptions_supported() 0 #else #define are_fpu_exceptions_supported() 1 #endif volatile double ignore_result; static void __used trigger_fpe(void) { #if __i386__ || __x86_64__ /* * XXX * Hack for QEMU bug #1668041, by which floating-point division by * zero is not trapped correctly. Also, assertions for si_code in * ptrace_signal_wait.h are commented out. Clean them up after the * bug is fixed. */ volatile int a, b; #else volatile double a, b; #endif a = getpid(); b = atoi("0"); #ifdef __HAVE_FENV feenableexcept(FE_ALL_EXCEPT); #endif /* Division by zero causes CPU trap, translated to SIGFPE */ ignore_result = (int)(a / b); } static void __used trigger_bus(void) { FILE *fp; char *p; /* Open an empty file for writing. */ fp = tmpfile(); FORKEE_ASSERT_NEQ((uintptr_t)fp, (uintptr_t)NULL); /* * Map an empty file with mmap(2) to a pointer. * * PROT_READ handles read-modify-write sequences emitted for * certain combinations of CPUs and compilers (e.g. Alpha AXP). */ p = mmap(0, 1, PROT_READ|PROT_WRITE, MAP_PRIVATE, fileno(fp), 0); FORKEE_ASSERT_NEQ((uintptr_t)p, (uintptr_t)MAP_FAILED); /* Invalid memory access causes CPU trap, translated to SIGBUS */ *p = 'a'; } struct lwp_event_count { lwpid_t lec_lwp; int lec_count; }; static int * __used find_event_count(struct lwp_event_count list[], lwpid_t lwp, size_t max_lwps) { size_t i; for (i = 0; i < max_lwps; i++) { if (list[i].lec_lwp == 0) list[i].lec_lwp = lwp; if (list[i].lec_lwp == lwp) return &list[i].lec_count; } atf_tc_fail("More LWPs reported than expected"); } #define FIND_EVENT_COUNT(list, lwp) \ find_event_count(list, lwp, __arraycount(list)) #if defined(TWAIT_HAVE_PID) #define ATF_TP_ADD_TC_HAVE_PID(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_PID(a,b) #endif #if defined(TWAIT_HAVE_STATUS) #define ATF_TP_ADD_TC_HAVE_STATUS(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_STATUS(a,b) #endif #if defined(TWAIT_HAVE_STATUS) && (defined(__i386__) || defined(__x86_64__)) #define ATF_TP_ADD_TC_HAVE_STATUS_X86(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_STATUS_X86(a,b) #endif #if defined(HAVE_GPREGS) #define ATF_TP_ADD_TC_HAVE_GPREGS(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_GPREGS(a,b) #endif #if defined(HAVE_FPREGS) #define ATF_TP_ADD_TC_HAVE_FPREGS(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_FPREGS(a,b) #endif #if defined(HAVE_DBREGS) #define ATF_TP_ADD_TC_HAVE_DBREGS(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_HAVE_DBREGS(a,b) #endif #if defined(PT_STEP) #define ATF_TP_ADD_TC_PT_STEP(a,b) ATF_TP_ADD_TC(a,b) #else #define ATF_TP_ADD_TC_PT_STEP(a,b) #endif