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: &attr, pid: 0, cpu: -1, group_fd: -1, flags: 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(set: &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: &attr, pid: 0, cpu: -1, group_fd: -1, flags: 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 | |