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
60static struct btf *btf;
61
62static bool btf__available(void)
63{
64	if (btf == NULL)
65		btf = btf__load_vmlinux_btf();
66
67	return btf != NULL;
68}
69
70static void btf__exit(void)
71{
72	btf__free(btf);
73	btf = NULL;
74}
75
76static 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
91static 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
107static 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 */
135static 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
156static bool kernel_with_sleepable_spinlocks(void)
157{
158	return false;
159}
160
161static void btf__exit(void)
162{
163}
164#endif  /* HAVE_BPF_SKEL */
165
166static void
167sigtrap_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
174static 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
189static 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
200static 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
233static 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
279out_close_perf_event:
280	close(fd);
281out_restore_sigaction:
282	sigaction(SIGTRAP, &oldact, NULL);
283out:
284	pthread_barrier_destroy(&barrier);
285	btf__exit();
286	return ret;
287}
288
289DEFINE_SUITE("Sigtrap", sigtrap);
290