1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Basic test for sigtrap support. 4 * 5 * Copyright (C) 2021, Google LLC. 6 */ 7 8 #include <errno.h> 9 #include <stdint.h> 10 #include <stdlib.h> 11 #include <linux/hw_breakpoint.h> 12 #include <linux/string.h> 13 #include <pthread.h> 14 #include <signal.h> 15 #include <sys/ioctl.h> 16 #include <sys/syscall.h> 17 #include <unistd.h> 18 19 #include "cloexec.h" 20 #include "debug.h" 21 #include "event.h" 22 #include "tests.h" 23 #include "../perf-sys.h" 24 25 /* 26 * PowerPC and S390 do not support creation of instruction breakpoints using the 27 * perf_event interface. 28 * 29 * Just disable the test for these architectures until these issues are 30 * resolved. 31 */ 32 #if defined(__powerpc__) || defined(__s390x__) 33 #define BP_ACCOUNT_IS_SUPPORTED 0 34 #else 35 #define BP_ACCOUNT_IS_SUPPORTED 1 36 #endif 37 38 #define NUM_THREADS 5 39 40 static struct { 41 int tids_want_signal; /* Which threads still want a signal. */ 42 int signal_count; /* Sanity check number of signals received. */ 43 volatile int iterate_on; /* Variable to set breakpoint on. */ 44 siginfo_t first_siginfo; /* First observed siginfo_t. */ 45 } ctx; 46 47 #define TEST_SIG_DATA (~(unsigned long)(&ctx.iterate_on)) 48 49 static struct perf_event_attr make_event_attr(void) 50 { 51 struct perf_event_attr attr = { 52 .type = PERF_TYPE_BREAKPOINT, 53 .size = sizeof(attr), 54 .sample_period = 1, 55 .disabled = 1, 56 .bp_addr = (unsigned long)&ctx.iterate_on, 57 .bp_type = HW_BREAKPOINT_RW, 58 .bp_len = HW_BREAKPOINT_LEN_1, 59 .inherit = 1, /* Children inherit events ... */ 60 .inherit_thread = 1, /* ... but only cloned with CLONE_THREAD. */ 61 .remove_on_exec = 1, /* Required by sigtrap. */ 62 .sigtrap = 1, /* Request synchronous SIGTRAP on event. */ 63 .sig_data = TEST_SIG_DATA, 64 .exclude_kernel = 1, /* To allow */ 65 .exclude_hv = 1, /* running as !root */ 66 }; 67 return attr; 68 } 69 70 static void 71 sigtrap_handler(int signum __maybe_unused, siginfo_t *info, void *ucontext __maybe_unused) 72 { 73 if (!__atomic_fetch_add(&ctx.signal_count, 1, __ATOMIC_RELAXED)) 74 ctx.first_siginfo = *info; 75 __atomic_fetch_sub(&ctx.tids_want_signal, syscall(SYS_gettid), __ATOMIC_RELAXED); 76 } 77 78 static void *test_thread(void *arg) 79 { 80 pthread_barrier_t *barrier = (pthread_barrier_t *)arg; 81 pid_t tid = syscall(SYS_gettid); 82 int i; 83 84 pthread_barrier_wait(barrier); 85 86 __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED); 87 for (i = 0; i < ctx.iterate_on - 1; i++) 88 __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED); 89 90 return NULL; 91 } 92 93 static int run_test_threads(pthread_t *threads, pthread_barrier_t *barrier) 94 { 95 int i; 96 97 pthread_barrier_wait(barrier); 98 for (i = 0; i < NUM_THREADS; i++) 99 TEST_ASSERT_EQUAL("pthread_join() failed", pthread_join(threads[i], NULL), 0); 100 101 return TEST_OK; 102 } 103 104 static int run_stress_test(int fd, pthread_t *threads, pthread_barrier_t *barrier) 105 { 106 int ret; 107 108 ctx.iterate_on = 3000; 109 110 TEST_ASSERT_EQUAL("misfired signal?", ctx.signal_count, 0); 111 TEST_ASSERT_EQUAL("enable failed", ioctl(fd, PERF_EVENT_IOC_ENABLE, 0), 0); 112 ret = run_test_threads(threads, barrier); 113 TEST_ASSERT_EQUAL("disable failed", ioctl(fd, PERF_EVENT_IOC_DISABLE, 0), 0); 114 115 TEST_ASSERT_EQUAL("unexpected sigtraps", ctx.signal_count, NUM_THREADS * ctx.iterate_on); 116 TEST_ASSERT_EQUAL("missing signals or incorrectly delivered", ctx.tids_want_signal, 0); 117 TEST_ASSERT_VAL("unexpected si_addr", ctx.first_siginfo.si_addr == &ctx.iterate_on); 118 #if 0 /* FIXME: enable when libc's signal.h has si_perf_{type,data} */ 119 TEST_ASSERT_EQUAL("unexpected si_perf_type", ctx.first_siginfo.si_perf_type, 120 PERF_TYPE_BREAKPOINT); 121 TEST_ASSERT_EQUAL("unexpected si_perf_data", ctx.first_siginfo.si_perf_data, 122 TEST_SIG_DATA); 123 #endif 124 125 return ret; 126 } 127 128 static int test__sigtrap(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 129 { 130 struct perf_event_attr attr = make_event_attr(); 131 struct sigaction action = {}; 132 struct sigaction oldact; 133 pthread_t threads[NUM_THREADS]; 134 pthread_barrier_t barrier; 135 char sbuf[STRERR_BUFSIZE]; 136 int i, fd, ret = TEST_FAIL; 137 138 if (!BP_ACCOUNT_IS_SUPPORTED) { 139 pr_debug("Test not supported on this architecture"); 140 return TEST_SKIP; 141 } 142 143 pthread_barrier_init(&barrier, NULL, NUM_THREADS + 1); 144 145 action.sa_flags = SA_SIGINFO | SA_NODEFER; 146 action.sa_sigaction = sigtrap_handler; 147 sigemptyset(&action.sa_mask); 148 if (sigaction(SIGTRAP, &action, &oldact)) { 149 pr_debug("FAILED sigaction(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); 150 goto out; 151 } 152 153 fd = sys_perf_event_open(&attr, 0, -1, -1, perf_event_open_cloexec_flag()); 154 if (fd < 0) { 155 pr_debug("FAILED sys_perf_event_open(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); 156 goto out_restore_sigaction; 157 } 158 159 for (i = 0; i < NUM_THREADS; i++) { 160 if (pthread_create(&threads[i], NULL, test_thread, &barrier)) { 161 pr_debug("FAILED pthread_create(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); 162 goto out_close_perf_event; 163 } 164 } 165 166 ret = run_stress_test(fd, threads, &barrier); 167 168 out_close_perf_event: 169 close(fd); 170 out_restore_sigaction: 171 sigaction(SIGTRAP, &oldact, NULL); 172 out: 173 pthread_barrier_destroy(&barrier); 174 return ret; 175 } 176 177 DEFINE_SUITE("Sigtrap", sigtrap); 178