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);