261 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Test for remove_on_exec.4 *5 * Copyright (C) 2021, Google LLC.6 */7 8#define _GNU_SOURCE9 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 114#define __have_sigval_t 115#define __have_sigevent_t 116#define __siginfo_t_defined17#define __sigval_t_defined18#define __sigevent_t_defined19#define _BITS_SIGINFO_CONSTS_H 120#define _BITS_SIGEVENT_CONSTS_H 121 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; with50 * remove_on_exec, we'll remove their event, but the parent and51 * 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 enabled119 * 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 of129 * 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 enabled170 * 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 and187 * 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_main250TEST_HARNESS_MAIN251#undef main252int 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