projects/linux·blob master · refs

275 lines · 7.0 KiB

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