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(&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(&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