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 #define NUM_THREADS 5 26 27 static struct { 28 int tids_want_signal; /* Which threads still want a signal. */ 29 int signal_count; /* Sanity check number of signals received. */ 30 volatile int iterate_on; /* Variable to set breakpoint on. */ 31 siginfo_t first_siginfo; /* First observed siginfo_t. */ 32 } ctx; 33 34 #define TEST_SIG_DATA (~(unsigned long)(&ctx.iterate_on)) 35 36 static struct perf_event_attr make_event_attr(void) 37 { 38 struct perf_event_attr attr = { 39 .type = PERF_TYPE_BREAKPOINT, 40 .size = sizeof(attr), 41 .sample_period = 1, 42 .disabled = 1, 43 .bp_addr = (unsigned long)&ctx.iterate_on, 44 .bp_type = HW_BREAKPOINT_RW, 45 .bp_len = HW_BREAKPOINT_LEN_1, 46 .inherit = 1, /* Children inherit events ... */ 47 .inherit_thread = 1, /* ... but only cloned with CLONE_THREAD. */ 48 .remove_on_exec = 1, /* Required by sigtrap. */ 49 .sigtrap = 1, /* Request synchronous SIGTRAP on event. */ 50 .sig_data = TEST_SIG_DATA, 51 .exclude_kernel = 1, /* To allow */ 52 .exclude_hv = 1, /* running as !root */ 53 }; 54 return attr; 55 } 56 57 #ifdef HAVE_BPF_SKEL 58 #include <bpf/btf.h> 59 60 static struct btf *btf; 61 62 static bool btf__available(void) 63 { 64 if (btf == NULL) 65 btf = btf__load_vmlinux_btf(); 66 67 return btf != NULL; 68 } 69 70 static void btf__exit(void) 71 { 72 btf__free(btf); 73 btf = NULL; 74 } 75 76 static const struct btf_member *__btf_type__find_member_by_name(int type_id, const char *member_name) 77 { 78 const struct btf_type *t = btf__type_by_id(btf, type_id); 79 const struct btf_member *m; 80 int i; 81 82 for (i = 0, m = btf_members(t); i < btf_vlen(t); i++, m++) { 83 const char *current_member_name = btf__name_by_offset(btf, m->name_off); 84 if (!strcmp(current_member_name, member_name)) 85 return m; 86 } 87 88 return NULL; 89 } 90 91 static bool attr_has_sigtrap(void) 92 { 93 int id; 94 95 if (!btf__available()) { 96 /* should be an old kernel */ 97 return false; 98 } 99 100 id = btf__find_by_name_kind(btf, "perf_event_attr", BTF_KIND_STRUCT); 101 if (id < 0) 102 return false; 103 104 return __btf_type__find_member_by_name(id, "sigtrap") != NULL; 105 } 106 107 static bool kernel_with_sleepable_spinlocks(void) 108 { 109 const struct btf_member *member; 110 const struct btf_type *type; 111 const char *type_name; 112 int id; 113 114 if (!btf__available()) 115 return false; 116 117 id = btf__find_by_name_kind(btf, "spinlock", BTF_KIND_STRUCT); 118 if (id < 0) 119 return false; 120 121 // Only RT has a "lock" member for "struct spinlock" 122 member = __btf_type__find_member_by_name(id, "lock"); 123 if (member == NULL) 124 return false; 125 126 // But check its type as well 127 type = btf__type_by_id(btf, member->type); 128 if (!type || !btf_is_struct(type)) 129 return false; 130 131 type_name = btf__name_by_offset(btf, type->name_off); 132 return type_name && !strcmp(type_name, "rt_mutex_base"); 133 } 134 #else /* !HAVE_BPF_SKEL */ 135 static bool attr_has_sigtrap(void) 136 { 137 struct perf_event_attr attr = { 138 .type = PERF_TYPE_SOFTWARE, 139 .config = PERF_COUNT_SW_DUMMY, 140 .size = sizeof(attr), 141 .remove_on_exec = 1, /* Required by sigtrap. */ 142 .sigtrap = 1, /* Request synchronous SIGTRAP on event. */ 143 }; 144 int fd; 145 bool ret = false; 146 147 fd = sys_perf_event_open(&attr, 0, -1, -1, perf_event_open_cloexec_flag()); 148 if (fd >= 0) { 149 ret = true; 150 close(fd); 151 } 152 153 return ret; 154 } 155 156 static bool kernel_with_sleepable_spinlocks(void) 157 { 158 return false; 159 } 160 161 static void btf__exit(void) 162 { 163 } 164 #endif /* HAVE_BPF_SKEL */ 165 166 static void 167 sigtrap_handler(int signum __maybe_unused, siginfo_t *info, void *ucontext __maybe_unused) 168 { 169 if (!__atomic_fetch_add(&ctx.signal_count, 1, __ATOMIC_RELAXED)) 170 ctx.first_siginfo = *info; 171 __atomic_fetch_sub(&ctx.tids_want_signal, syscall(SYS_gettid), __ATOMIC_RELAXED); 172 } 173 174 static void *test_thread(void *arg) 175 { 176 pthread_barrier_t *barrier = (pthread_barrier_t *)arg; 177 pid_t tid = syscall(SYS_gettid); 178 int i; 179 180 pthread_barrier_wait(barrier); 181 182 __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED); 183 for (i = 0; i < ctx.iterate_on - 1; i++) 184 __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED); 185 186 return NULL; 187 } 188 189 static int run_test_threads(pthread_t *threads, pthread_barrier_t *barrier) 190 { 191 int i; 192 193 pthread_barrier_wait(barrier); 194 for (i = 0; i < NUM_THREADS; i++) 195 TEST_ASSERT_EQUAL("pthread_join() failed", pthread_join(threads[i], NULL), 0); 196 197 return TEST_OK; 198 } 199 200 static int run_stress_test(int fd, pthread_t *threads, pthread_barrier_t *barrier) 201 { 202 int ret, expected_sigtraps; 203 204 ctx.iterate_on = 3000; 205 206 TEST_ASSERT_EQUAL("misfired signal?", ctx.signal_count, 0); 207 TEST_ASSERT_EQUAL("enable failed", ioctl(fd, PERF_EVENT_IOC_ENABLE, 0), 0); 208 ret = run_test_threads(threads, barrier); 209 TEST_ASSERT_EQUAL("disable failed", ioctl(fd, PERF_EVENT_IOC_DISABLE, 0), 0); 210 211 expected_sigtraps = NUM_THREADS * ctx.iterate_on; 212 213 if (ctx.signal_count < expected_sigtraps && kernel_with_sleepable_spinlocks()) { 214 pr_debug("Expected %d sigtraps, got %d, running on a kernel with sleepable spinlocks.\n", 215 expected_sigtraps, ctx.signal_count); 216 pr_debug("See https://lore.kernel.org/all/e368f2c848d77fbc8d259f44e2055fe469c219cf.camel@gmx.de/\n"); 217 return TEST_SKIP; 218 } else 219 TEST_ASSERT_EQUAL("unexpected sigtraps", ctx.signal_count, expected_sigtraps); 220 221 TEST_ASSERT_EQUAL("missing signals or incorrectly delivered", ctx.tids_want_signal, 0); 222 TEST_ASSERT_VAL("unexpected si_addr", ctx.first_siginfo.si_addr == &ctx.iterate_on); 223 #if 0 /* FIXME: enable when libc's signal.h has si_perf_{type,data} */ 224 TEST_ASSERT_EQUAL("unexpected si_perf_type", ctx.first_siginfo.si_perf_type, 225 PERF_TYPE_BREAKPOINT); 226 TEST_ASSERT_EQUAL("unexpected si_perf_data", ctx.first_siginfo.si_perf_data, 227 TEST_SIG_DATA); 228 #endif 229 230 return ret; 231 } 232 233 static int test__sigtrap(struct test_suite *test __maybe_unused, int subtest __maybe_unused) 234 { 235 struct perf_event_attr attr = make_event_attr(); 236 struct sigaction action = {}; 237 struct sigaction oldact; 238 pthread_t threads[NUM_THREADS]; 239 pthread_barrier_t barrier; 240 char sbuf[STRERR_BUFSIZE]; 241 int i, fd, ret = TEST_FAIL; 242 243 if (!BP_SIGNAL_IS_SUPPORTED) { 244 pr_debug("Test not supported on this architecture"); 245 return TEST_SKIP; 246 } 247 248 pthread_barrier_init(&barrier, NULL, NUM_THREADS + 1); 249 250 action.sa_flags = SA_SIGINFO | SA_NODEFER; 251 action.sa_sigaction = sigtrap_handler; 252 sigemptyset(&action.sa_mask); 253 if (sigaction(SIGTRAP, &action, &oldact)) { 254 pr_debug("FAILED sigaction(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); 255 goto out; 256 } 257 258 fd = sys_perf_event_open(&attr, 0, -1, -1, perf_event_open_cloexec_flag()); 259 if (fd < 0) { 260 if (attr_has_sigtrap()) { 261 pr_debug("FAILED sys_perf_event_open(): %s\n", 262 str_error_r(errno, sbuf, sizeof(sbuf))); 263 } else { 264 pr_debug("perf_event_attr doesn't have sigtrap\n"); 265 ret = TEST_SKIP; 266 } 267 goto out_restore_sigaction; 268 } 269 270 for (i = 0; i < NUM_THREADS; i++) { 271 if (pthread_create(&threads[i], NULL, test_thread, &barrier)) { 272 pr_debug("FAILED pthread_create(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf))); 273 goto out_close_perf_event; 274 } 275 } 276 277 ret = run_stress_test(fd, threads, &barrier); 278 279 out_close_perf_event: 280 close(fd); 281 out_restore_sigaction: 282 sigaction(SIGTRAP, &oldact, NULL); 283 out: 284 pthread_barrier_destroy(&barrier); 285 btf__exit(); 286 return ret; 287 } 288 289 DEFINE_SUITE("Sigtrap", sigtrap); 290