1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Test for remove_on_exec.
4 *
5 * Copyright (C) 2021, Google LLC.
6 */
7
8#define _GNU_SOURCE
9
10/* We need the latest siginfo from the kernel repo. */
11#include <sys/types.h>
12#include <asm/siginfo.h>
13#define __have_siginfo_t 1
14#define __have_sigval_t 1
15#define __have_sigevent_t 1
16#define __siginfo_t_defined
17#define __sigval_t_defined
18#define __sigevent_t_defined
19#define _BITS_SIGINFO_CONSTS_H 1
20#define _BITS_SIGEVENT_CONSTS_H 1
21
22#include <stdbool.h>
23#include <stddef.h>
24#include <stdint.h>
25#include <stdio.h>
26#include <linux/perf_event.h>
27#include <pthread.h>
28#include <signal.h>
29#include <sys/ioctl.h>
30#include <sys/syscall.h>
31#include <unistd.h>
32
33#include "../kselftest_harness.h"
34
35static volatile int signal_count;
36
37static struct perf_event_attr make_event_attr(void)
38{
39	struct perf_event_attr attr = {
40		.type		= PERF_TYPE_HARDWARE,
41		.size		= sizeof(attr),
42		.config		= PERF_COUNT_HW_INSTRUCTIONS,
43		.sample_period	= 1000,
44		.exclude_kernel = 1,
45		.exclude_hv	= 1,
46		.disabled	= 1,
47		.inherit	= 1,
48		/*
49		 * Children normally retain their inherited event on exec; with
50		 * remove_on_exec, we'll remove their event, but the parent and
51		 * any other non-exec'd children will keep their events.
52		 */
53		.remove_on_exec = 1,
54		.sigtrap	= 1,
55	};
56	return attr;
57}
58
59static void sigtrap_handler(int signum, siginfo_t *info, void *ucontext)
60{
61	if (info->si_code != TRAP_PERF) {
62		fprintf(stderr, "%s: unexpected si_code %d\n", __func__, info->si_code);
63		return;
64	}
65
66	signal_count++;
67}
68
69FIXTURE(remove_on_exec)
70{
71	struct sigaction oldact;
72	int fd;
73};
74
75FIXTURE_SETUP(remove_on_exec)
76{
77	struct perf_event_attr attr = make_event_attr();
78	struct sigaction action = {};
79
80	signal_count = 0;
81
82	/* Initialize sigtrap handler. */
83	action.sa_flags = SA_SIGINFO | SA_NODEFER;
84	action.sa_sigaction = sigtrap_handler;
85	sigemptyset(&action.sa_mask);
86	ASSERT_EQ(sigaction(SIGTRAP, &action, &self->oldact), 0);
87
88	/* Initialize perf event. */
89	self->fd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, PERF_FLAG_FD_CLOEXEC);
90	ASSERT_NE(self->fd, -1);
91}
92
93FIXTURE_TEARDOWN(remove_on_exec)
94{
95	close(self->fd);
96	sigaction(SIGTRAP, &self->oldact, NULL);
97}
98
99/* Verify event propagates to fork'd child. */
100TEST_F(remove_on_exec, fork_only)
101{
102	int status;
103	pid_t pid = fork();
104
105	if (pid == 0) {
106		ASSERT_EQ(signal_count, 0);
107		ASSERT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
108		while (!signal_count);
109		_exit(42);
110	}
111
112	while (!signal_count); /* Child enables event. */
113	EXPECT_EQ(waitpid(pid, &status, 0), pid);
114	EXPECT_EQ(WEXITSTATUS(status), 42);
115}
116
117/*
118 * Verify that event does _not_ propagate to fork+exec'd child; event enabled
119 * after fork+exec.
120 */
121TEST_F(remove_on_exec, fork_exec_then_enable)
122{
123	pid_t pid_exec, pid_only_fork;
124	int pipefd[2];
125	int tmp;
126
127	/*
128	 * Non-exec child, to ensure exec does not affect inherited events of
129	 * other children.
130	 */
131	pid_only_fork = fork();
132	if (pid_only_fork == 0) {
133		/* Block until parent enables event. */
134		while (!signal_count);
135		_exit(42);
136	}
137
138	ASSERT_NE(pipe(pipefd), -1);
139	pid_exec = fork();
140	if (pid_exec == 0) {
141		ASSERT_NE(dup2(pipefd[1], STDOUT_FILENO), -1);
142		close(pipefd[0]);
143		execl("/proc/self/exe", "exec_child", NULL);
144		_exit((perror("exec failed"), 1));
145	}
146	close(pipefd[1]);
147
148	ASSERT_EQ(waitpid(pid_exec, &tmp, WNOHANG), 0); /* Child is running. */
149	/* Wait for exec'd child to start spinning. */
150	EXPECT_EQ(read(pipefd[0], &tmp, sizeof(int)), sizeof(int));
151	EXPECT_EQ(tmp, 42);
152	close(pipefd[0]);
153	/* Now we can enable the event, knowing the child is doing work. */
154	EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
155	/* If the event propagated to the exec'd child, it will exit normally... */
156	usleep(100000); /* ... give time for event to trigger (in case of bug). */
157	EXPECT_EQ(waitpid(pid_exec, &tmp, WNOHANG), 0); /* Should still be running. */
158	EXPECT_EQ(kill(pid_exec, SIGKILL), 0);
159
160	/* Verify removal from child did not affect this task's event. */
161	tmp = signal_count;
162	while (signal_count == tmp); /* Should not hang! */
163	/* Nor should it have affected the first child. */
164	EXPECT_EQ(waitpid(pid_only_fork, &tmp, 0), pid_only_fork);
165	EXPECT_EQ(WEXITSTATUS(tmp), 42);
166}
167
168/*
169 * Verify that event does _not_ propagate to fork+exec'd child; event enabled
170 * before fork+exec.
171 */
172TEST_F(remove_on_exec, enable_then_fork_exec)
173{
174	pid_t pid_exec;
175	int tmp;
176
177	EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
178
179	pid_exec = fork();
180	if (pid_exec == 0) {
181		execl("/proc/self/exe", "exec_child", NULL);
182		_exit((perror("exec failed"), 1));
183	}
184
185	/*
186	 * The child may exit abnormally at any time if the event propagated and
187	 * a SIGTRAP is sent before the handler was set up.
188	 */
189	usleep(100000); /* ... give time for event to trigger (in case of bug). */
190	EXPECT_EQ(waitpid(pid_exec, &tmp, WNOHANG), 0); /* Should still be running. */
191	EXPECT_EQ(kill(pid_exec, SIGKILL), 0);
192
193	/* Verify removal from child did not affect this task's event. */
194	tmp = signal_count;
195	while (signal_count == tmp); /* Should not hang! */
196}
197
198TEST_F(remove_on_exec, exec_stress)
199{
200	pid_t pids[30];
201	int i, tmp;
202
203	for (i = 0; i < sizeof(pids) / sizeof(pids[0]); i++) {
204		pids[i] = fork();
205		if (pids[i] == 0) {
206			execl("/proc/self/exe", "exec_child", NULL);
207			_exit((perror("exec failed"), 1));
208		}
209
210		/* Some forked with event disabled, rest with enabled. */
211		if (i > 10)
212			EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
213	}
214
215	usleep(100000); /* ... give time for event to trigger (in case of bug). */
216
217	for (i = 0; i < sizeof(pids) / sizeof(pids[0]); i++) {
218		/* All children should still be running. */
219		EXPECT_EQ(waitpid(pids[i], &tmp, WNOHANG), 0);
220		EXPECT_EQ(kill(pids[i], SIGKILL), 0);
221	}
222
223	/* Verify event is still alive. */
224	tmp = signal_count;
225	while (signal_count == tmp);
226}
227
228/* For exec'd child. */
229static void exec_child(void)
230{
231	struct sigaction action = {};
232	const int val = 42;
233
234	/* Set up sigtrap handler in case we erroneously receive a trap. */
235	action.sa_flags = SA_SIGINFO | SA_NODEFER;
236	action.sa_sigaction = sigtrap_handler;
237	sigemptyset(&action.sa_mask);
238	if (sigaction(SIGTRAP, &action, NULL))
239		_exit((perror("sigaction failed"), 1));
240
241	/* Signal parent that we're starting to spin. */
242	if (write(STDOUT_FILENO, &val, sizeof(int)) == -1)
243		_exit((perror("write failed"), 1));
244
245	/* Should hang here until killed. */
246	while (!signal_count);
247}
248
249#define main test_main
250TEST_HARNESS_MAIN
251#undef main
252int main(int argc, char *argv[])
253{
254	if (!strcmp(argv[0], "exec_child")) {
255		exec_child();
256		return 1;
257	}
258
259	return test_main(argc, argv);
260}
261