1 // SPDX-License-Identifier: GPL-2.0
2 #include <test_progs.h>
3 #include <sys/time.h>
4 #include <sys/resource.h>
5 #include "test_send_signal_kern.skel.h"
6 
7 static int sigusr1_received;
8 
9 static void sigusr1_handler(int signum)
10 {
11 	sigusr1_received = 1;
12 }
13 
14 static void test_send_signal_common(struct perf_event_attr *attr,
15 				    bool signal_thread)
16 {
17 	struct test_send_signal_kern *skel;
18 	int pipe_c2p[2], pipe_p2c[2];
19 	int err = -1, pmu_fd = -1;
20 	char buf[256];
21 	pid_t pid;
22 
23 	if (!ASSERT_OK(pipe(pipe_c2p), "pipe_c2p"))
24 		return;
25 
26 	if (!ASSERT_OK(pipe(pipe_p2c), "pipe_p2c")) {
27 		close(pipe_c2p[0]);
28 		close(pipe_c2p[1]);
29 		return;
30 	}
31 
32 	pid = fork();
33 	if (!ASSERT_GE(pid, 0, "fork")) {
34 		close(pipe_c2p[0]);
35 		close(pipe_c2p[1]);
36 		close(pipe_p2c[0]);
37 		close(pipe_p2c[1]);
38 		return;
39 	}
40 
41 	if (pid == 0) {
42 		int old_prio;
43 		volatile int j = 0;
44 
45 		/* install signal handler and notify parent */
46 		ASSERT_NEQ(signal(SIGUSR1, sigusr1_handler), SIG_ERR, "signal");
47 
48 		close(pipe_c2p[0]); /* close read */
49 		close(pipe_p2c[1]); /* close write */
50 
51 		/* boost with a high priority so we got a higher chance
52 		 * that if an interrupt happens, the underlying task
53 		 * is this process.
54 		 */
55 		errno = 0;
56 		old_prio = getpriority(PRIO_PROCESS, 0);
57 		ASSERT_OK(errno, "getpriority");
58 		ASSERT_OK(setpriority(PRIO_PROCESS, 0, -20), "setpriority");
59 
60 		/* notify parent signal handler is installed */
61 		ASSERT_EQ(write(pipe_c2p[1], buf, 1), 1, "pipe_write");
62 
63 		/* make sure parent enabled bpf program to send_signal */
64 		ASSERT_EQ(read(pipe_p2c[0], buf, 1), 1, "pipe_read");
65 
66 		/* wait a little for signal handler */
67 		for (int i = 0; i < 1000000000 && !sigusr1_received; i++) {
68 			j /= i + j + 1;
69 			if (!attr)
70 				/* trigger the nanosleep tracepoint program. */
71 				usleep(1);
72 		}
73 
74 		buf[0] = sigusr1_received ? '2' : '0';
75 		ASSERT_EQ(sigusr1_received, 1, "sigusr1_received");
76 		ASSERT_EQ(write(pipe_c2p[1], buf, 1), 1, "pipe_write");
77 
78 		/* wait for parent notification and exit */
79 		ASSERT_EQ(read(pipe_p2c[0], buf, 1), 1, "pipe_read");
80 
81 		/* restore the old priority */
82 		ASSERT_OK(setpriority(PRIO_PROCESS, 0, old_prio), "setpriority");
83 
84 		close(pipe_c2p[1]);
85 		close(pipe_p2c[0]);
86 		exit(0);
87 	}
88 
89 	close(pipe_c2p[1]); /* close write */
90 	close(pipe_p2c[0]); /* close read */
91 
92 	skel = test_send_signal_kern__open_and_load();
93 	if (!ASSERT_OK_PTR(skel, "skel_open_and_load"))
94 		goto skel_open_load_failure;
95 
96 	if (!attr) {
97 		err = test_send_signal_kern__attach(skel);
98 		if (!ASSERT_OK(err, "skel_attach")) {
99 			err = -1;
100 			goto destroy_skel;
101 		}
102 	} else {
103 		pmu_fd = syscall(__NR_perf_event_open, attr, pid, -1 /* cpu */,
104 				 -1 /* group id */, 0 /* flags */);
105 		if (!ASSERT_GE(pmu_fd, 0, "perf_event_open")) {
106 			err = -1;
107 			goto destroy_skel;
108 		}
109 
110 		skel->links.send_signal_perf =
111 			bpf_program__attach_perf_event(skel->progs.send_signal_perf, pmu_fd);
112 		if (!ASSERT_OK_PTR(skel->links.send_signal_perf, "attach_perf_event"))
113 			goto disable_pmu;
114 	}
115 
116 	/* wait until child signal handler installed */
117 	ASSERT_EQ(read(pipe_c2p[0], buf, 1), 1, "pipe_read");
118 
119 	/* trigger the bpf send_signal */
120 	skel->bss->signal_thread = signal_thread;
121 	skel->bss->sig = SIGUSR1;
122 	skel->bss->pid = pid;
123 
124 	/* notify child that bpf program can send_signal now */
125 	ASSERT_EQ(write(pipe_p2c[1], buf, 1), 1, "pipe_write");
126 
127 	/* wait for result */
128 	err = read(pipe_c2p[0], buf, 1);
129 	if (!ASSERT_GE(err, 0, "reading pipe"))
130 		goto disable_pmu;
131 	if (!ASSERT_GT(err, 0, "reading pipe error: size 0")) {
132 		err = -1;
133 		goto disable_pmu;
134 	}
135 
136 	ASSERT_EQ(buf[0], '2', "incorrect result");
137 
138 	/* notify child safe to exit */
139 	ASSERT_EQ(write(pipe_p2c[1], buf, 1), 1, "pipe_write");
140 
141 disable_pmu:
142 	close(pmu_fd);
143 destroy_skel:
144 	test_send_signal_kern__destroy(skel);
145 skel_open_load_failure:
146 	close(pipe_c2p[0]);
147 	close(pipe_p2c[1]);
148 	wait(NULL);
149 }
150 
151 static void test_send_signal_tracepoint(bool signal_thread)
152 {
153 	test_send_signal_common(NULL, signal_thread);
154 }
155 
156 static void test_send_signal_perf(bool signal_thread)
157 {
158 	struct perf_event_attr attr = {
159 		.sample_period = 1,
160 		.type = PERF_TYPE_SOFTWARE,
161 		.config = PERF_COUNT_SW_CPU_CLOCK,
162 	};
163 
164 	test_send_signal_common(&attr, signal_thread);
165 }
166 
167 static void test_send_signal_nmi(bool signal_thread)
168 {
169 	struct perf_event_attr attr = {
170 		.sample_period = 1,
171 		.type = PERF_TYPE_HARDWARE,
172 		.config = PERF_COUNT_HW_CPU_CYCLES,
173 	};
174 	int pmu_fd;
175 
176 	/* Some setups (e.g. virtual machines) might run with hardware
177 	 * perf events disabled. If this is the case, skip this test.
178 	 */
179 	pmu_fd = syscall(__NR_perf_event_open, &attr, 0 /* pid */,
180 			 -1 /* cpu */, -1 /* group_fd */, 0 /* flags */);
181 	if (pmu_fd == -1) {
182 		if (errno == ENOENT) {
183 			printf("%s:SKIP:no PERF_COUNT_HW_CPU_CYCLES\n",
184 			       __func__);
185 			test__skip();
186 			return;
187 		}
188 		/* Let the test fail with a more informative message */
189 	} else {
190 		close(pmu_fd);
191 	}
192 
193 	test_send_signal_common(&attr, signal_thread);
194 }
195 
196 void test_send_signal(void)
197 {
198 	if (test__start_subtest("send_signal_tracepoint"))
199 		test_send_signal_tracepoint(false);
200 	if (test__start_subtest("send_signal_perf"))
201 		test_send_signal_perf(false);
202 	if (test__start_subtest("send_signal_nmi"))
203 		test_send_signal_nmi(false);
204 	if (test__start_subtest("send_signal_tracepoint_thread"))
205 		test_send_signal_tracepoint(true);
206 	if (test__start_subtest("send_signal_perf_thread"))
207 		test_send_signal_perf(true);
208 	if (test__start_subtest("send_signal_nmi_thread"))
209 		test_send_signal_nmi(true);
210 }
211