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 | |
35 | static volatile int signal_count; |
36 | |
37 | static 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 | |
59 | static 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 | |
69 | FIXTURE(remove_on_exec) |
70 | { |
71 | struct sigaction oldact; |
72 | int fd; |
73 | }; |
74 | |
75 | FIXTURE_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(set: &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 | |
93 | FIXTURE_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. */ |
100 | TEST_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 | */ |
121 | TEST_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 | */ |
172 | TEST_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 | |
198 | TEST_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. */ |
229 | static 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(set: &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 |
250 | TEST_HARNESS_MAIN |
251 | #undef main |
252 | int 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 | |