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 bool attr_has_sigtrap(void)
61{
62	bool ret = false;
63	struct btf *btf;
64	const struct btf_type *t;
65	const struct btf_member *m;
66	const char *name;
67	int i, id;
68
69	btf = btf__load_vmlinux_btf();
70	if (btf == NULL) {
71		/* should be an old kernel */
72		return false;
73	}
74
75	id = btf__find_by_name_kind(btf, "perf_event_attr", BTF_KIND_STRUCT);
76	if (id < 0)
77		goto out;
78
79	t = btf__type_by_id(btf, id);
80	for (i = 0, m = btf_members(t); i < btf_vlen(t); i++, m++) {
81		name = btf__name_by_offset(btf, m->name_off);
82		if (!strcmp(name, "sigtrap")) {
83			ret = true;
84			break;
85		}
86	}
87out:
88	btf__free(btf);
89	return ret;
90}
91#else  /* !HAVE_BPF_SKEL */
92static bool attr_has_sigtrap(void)
93{
94	struct perf_event_attr attr = {
95		.type		= PERF_TYPE_SOFTWARE,
96		.config		= PERF_COUNT_SW_DUMMY,
97		.size		= sizeof(attr),
98		.remove_on_exec = 1, /* Required by sigtrap. */
99		.sigtrap	= 1, /* Request synchronous SIGTRAP on event. */
100	};
101	int fd;
102	bool ret = false;
103
104	fd = sys_perf_event_open(&attr, 0, -1, -1, perf_event_open_cloexec_flag());
105	if (fd >= 0) {
106		ret = true;
107		close(fd);
108	}
109
110	return ret;
111}
112#endif  /* HAVE_BPF_SKEL */
113
114static void
115sigtrap_handler(int signum __maybe_unused, siginfo_t *info, void *ucontext __maybe_unused)
116{
117	if (!__atomic_fetch_add(&ctx.signal_count, 1, __ATOMIC_RELAXED))
118		ctx.first_siginfo = *info;
119	__atomic_fetch_sub(&ctx.tids_want_signal, syscall(SYS_gettid), __ATOMIC_RELAXED);
120}
121
122static void *test_thread(void *arg)
123{
124	pthread_barrier_t *barrier = (pthread_barrier_t *)arg;
125	pid_t tid = syscall(SYS_gettid);
126	int i;
127
128	pthread_barrier_wait(barrier);
129
130	__atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED);
131	for (i = 0; i < ctx.iterate_on - 1; i++)
132		__atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED);
133
134	return NULL;
135}
136
137static int run_test_threads(pthread_t *threads, pthread_barrier_t *barrier)
138{
139	int i;
140
141	pthread_barrier_wait(barrier);
142	for (i = 0; i < NUM_THREADS; i++)
143		TEST_ASSERT_EQUAL("pthread_join() failed", pthread_join(threads[i], NULL), 0);
144
145	return TEST_OK;
146}
147
148static int run_stress_test(int fd, pthread_t *threads, pthread_barrier_t *barrier)
149{
150	int ret;
151
152	ctx.iterate_on = 3000;
153
154	TEST_ASSERT_EQUAL("misfired signal?", ctx.signal_count, 0);
155	TEST_ASSERT_EQUAL("enable failed", ioctl(fd, PERF_EVENT_IOC_ENABLE, 0), 0);
156	ret = run_test_threads(threads, barrier);
157	TEST_ASSERT_EQUAL("disable failed", ioctl(fd, PERF_EVENT_IOC_DISABLE, 0), 0);
158
159	TEST_ASSERT_EQUAL("unexpected sigtraps", ctx.signal_count, NUM_THREADS * ctx.iterate_on);
160	TEST_ASSERT_EQUAL("missing signals or incorrectly delivered", ctx.tids_want_signal, 0);
161	TEST_ASSERT_VAL("unexpected si_addr", ctx.first_siginfo.si_addr == &ctx.iterate_on);
162#if 0 /* FIXME: enable when libc's signal.h has si_perf_{type,data} */
163	TEST_ASSERT_EQUAL("unexpected si_perf_type", ctx.first_siginfo.si_perf_type,
164			  PERF_TYPE_BREAKPOINT);
165	TEST_ASSERT_EQUAL("unexpected si_perf_data", ctx.first_siginfo.si_perf_data,
166			  TEST_SIG_DATA);
167#endif
168
169	return ret;
170}
171
172static int test__sigtrap(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
173{
174	struct perf_event_attr attr = make_event_attr();
175	struct sigaction action = {};
176	struct sigaction oldact;
177	pthread_t threads[NUM_THREADS];
178	pthread_barrier_t barrier;
179	char sbuf[STRERR_BUFSIZE];
180	int i, fd, ret = TEST_FAIL;
181
182	if (!BP_SIGNAL_IS_SUPPORTED) {
183		pr_debug("Test not supported on this architecture");
184		return TEST_SKIP;
185	}
186
187	pthread_barrier_init(&barrier, NULL, NUM_THREADS + 1);
188
189	action.sa_flags = SA_SIGINFO | SA_NODEFER;
190	action.sa_sigaction = sigtrap_handler;
191	sigemptyset(&action.sa_mask);
192	if (sigaction(SIGTRAP, &action, &oldact)) {
193		pr_debug("FAILED sigaction(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
194		goto out;
195	}
196
197	fd = sys_perf_event_open(&attr, 0, -1, -1, perf_event_open_cloexec_flag());
198	if (fd < 0) {
199		if (attr_has_sigtrap()) {
200			pr_debug("FAILED sys_perf_event_open(): %s\n",
201				 str_error_r(errno, sbuf, sizeof(sbuf)));
202		} else {
203			pr_debug("perf_event_attr doesn't have sigtrap\n");
204			ret = TEST_SKIP;
205		}
206		goto out_restore_sigaction;
207	}
208
209	for (i = 0; i < NUM_THREADS; i++) {
210		if (pthread_create(&threads[i], NULL, test_thread, &barrier)) {
211			pr_debug("FAILED pthread_create(): %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
212			goto out_close_perf_event;
213		}
214	}
215
216	ret = run_stress_test(fd, threads, &barrier);
217
218out_close_perf_event:
219	close(fd);
220out_restore_sigaction:
221	sigaction(SIGTRAP, &oldact, NULL);
222out:
223	pthread_barrier_destroy(&barrier);
224	return ret;
225}
226
227DEFINE_SUITE("Sigtrap", sigtrap);
228