projects/linux·blob master · refs

628 lines · 15.2 KiB

1/* SPDX-License-Identifier: GPL-2.0 */
2
3#define _GNU_SOURCE
4#include <errno.h>
5#include <fcntl.h>
6#include <linux/types.h>
7#include <pthread.h>
8#include <sched.h>
9#include <signal.h>
10#include <stdio.h>
11#include <stdbool.h>
12#include <stdlib.h>
13#include <string.h>
14#include <syscall.h>
15#include <sys/epoll.h>
16#include <sys/mman.h>
17#include <sys/mount.h>
18#include <sys/wait.h>
19#include <time.h>
20#include <unistd.h>
21
22#include "pidfd.h"
23#include "kselftest.h"
24
25#define str(s) _str(s)
26#define _str(s) #s
27#define CHILD_THREAD_MIN_WAIT 3 /* seconds */
28
29#define MAX_EVENTS 5
30
31static bool have_pidfd_send_signal;
32
33static pid_t pidfd_clone(int flags, int *pidfd, int (*fn)(void *))
34{
35 size_t stack_size = 1024;
36 char *stack[1024] = { 0 };
37
38#ifdef __ia64__
39 return __clone2(fn, stack, stack_size, flags | SIGCHLD, NULL, pidfd);
40#else
41 return clone(fn, stack + stack_size, flags | SIGCHLD, NULL, pidfd);
42#endif
43}
44
45static pthread_t signal_received;
46
47static void set_signal_received_on_sigusr1(int sig)
48{
49 if (sig == SIGUSR1)
50 signal_received = pthread_self();
51}
52
53static int send_signal(int pidfd)
54{
55 int ret = 0;
56
57 if (sys_pidfd_send_signal(pidfd, SIGUSR1, NULL, 0) < 0) {
58 ret = -EINVAL;
59 goto exit;
60 }
61
62 if (signal_received != pthread_self()) {
63 ret = -EINVAL;
64 goto exit;
65 }
66
67exit:
68 signal_received = 0;
69 return ret;
70}
71
72static void *send_signal_worker(void *arg)
73{
74 int pidfd = (int)(intptr_t)arg;
75 int ret;
76
77 /* We forward any errors for the caller to handle. */
78 ret = send_signal(pidfd);
79 return (void *)(intptr_t)ret;
80}
81
82/*
83 * Straightforward test to see whether pidfd_send_signal() works is to send
84 * a signal to ourself.
85 */
86static int test_pidfd_send_signal_simple_success(void)
87{
88 int pidfd;
89 const char *test_name = "pidfd_send_signal send SIGUSR1";
90 pthread_t thread;
91 void *thread_res;
92 int err;
93
94 if (!have_pidfd_send_signal) {
95 ksft_test_result_skip(
96 "%s test: pidfd_send_signal() syscall not supported\n",
97 test_name);
98 return 0;
99 }
100
101 signal(SIGUSR1, set_signal_received_on_sigusr1);
102
103 /* Try sending a signal to ourselves via /proc/self. */
104 pidfd = open("/proc/self", O_DIRECTORY | O_CLOEXEC);
105 if (pidfd < 0)
106 ksft_exit_fail_msg(
107 "%s test: Failed to open process file descriptor\n",
108 test_name);
109 err = send_signal(pidfd);
110 if (err)
111 ksft_exit_fail_msg(
112 "%s test: Error %d on sending pidfd signal\n",
113 test_name, err);
114 close(pidfd);
115
116 /* Now try the same thing only using PIDFD_SELF_THREAD_GROUP. */
117 err = send_signal(PIDFD_SELF_THREAD_GROUP);
118 if (err)
119 ksft_exit_fail_msg(
120 "%s test: Error %d on PIDFD_SELF_THREAD_GROUP signal\n",
121 test_name, err);
122
123 /*
124 * Now try the same thing in a thread and assert thread ID is equal to
125 * worker thread ID.
126 */
127 if (pthread_create(&thread, NULL, send_signal_worker,
128 (void *)(intptr_t)PIDFD_SELF_THREAD))
129 ksft_exit_fail_msg("%s test: Failed to create thread\n",
130 test_name);
131 if (pthread_join(thread, &thread_res))
132 ksft_exit_fail_msg("%s test: Failed to join thread\n",
133 test_name);
134 err = (int)(intptr_t)thread_res;
135 if (err)
136 ksft_exit_fail_msg(
137 "%s test: Error %d on PIDFD_SELF_THREAD signal\n",
138 test_name, err);
139
140 ksft_test_result_pass("%s test: Sent signal\n", test_name);
141 return 0;
142}
143
144static int test_pidfd_send_signal_exited_fail(void)
145{
146 int pidfd, ret, saved_errno;
147 char buf[256];
148 pid_t pid;
149 const char *test_name = "pidfd_send_signal signal exited process";
150
151 if (!have_pidfd_send_signal) {
152 ksft_test_result_skip(
153 "%s test: pidfd_send_signal() syscall not supported\n",
154 test_name);
155 return 0;
156 }
157
158 pid = fork();
159 if (pid < 0)
160 ksft_exit_fail_msg("%s test: Failed to create new process\n",
161 test_name);
162
163 if (pid == 0)
164 _exit(EXIT_SUCCESS);
165
166 snprintf(buf, sizeof(buf), "/proc/%d", pid);
167
168 pidfd = open(buf, O_DIRECTORY | O_CLOEXEC);
169
170 ret = wait_for_pid(pid);
171 ksft_print_msg("waitpid WEXITSTATUS=%d\n", ret);
172
173 if (pidfd < 0)
174 ksft_exit_fail_msg(
175 "%s test: Failed to open process file descriptor\n",
176 test_name);
177
178 ret = sys_pidfd_send_signal(pidfd, 0, NULL, 0);
179 saved_errno = errno;
180 close(pidfd);
181 if (ret == 0)
182 ksft_exit_fail_msg(
183 "%s test: Managed to send signal to process even though it should have failed\n",
184 test_name);
185
186 if (saved_errno != ESRCH)
187 ksft_exit_fail_msg(
188 "%s test: Expected to receive ESRCH as errno value but received %d instead\n",
189 test_name, saved_errno);
190
191 ksft_test_result_pass("%s test: Failed to send signal as expected\n",
192 test_name);
193 return 0;
194}
195
196/*
197 * Maximum number of cycles we allow. This is equivalent to PID_MAX_DEFAULT.
198 * If users set a higher limit or we have cycled PIDFD_MAX_DEFAULT number of
199 * times then we skip the test to not go into an infinite loop or block for a
200 * long time.
201 */
202#define PIDFD_MAX_DEFAULT 0x8000
203
204static int test_pidfd_send_signal_recycled_pid_fail(void)
205{
206 int i, ret;
207 pid_t pid1;
208 const char *test_name = "pidfd_send_signal signal recycled pid";
209
210 if (!have_pidfd_send_signal) {
211 ksft_test_result_skip(
212 "%s test: pidfd_send_signal() syscall not supported\n",
213 test_name);
214 return 0;
215 }
216
217 ret = unshare(CLONE_NEWPID);
218 if (ret < 0) {
219 if (errno == EPERM) {
220 ksft_test_result_skip("%s test: Unsharing pid namespace not permitted\n",
221 test_name);
222 return 0;
223 }
224 ksft_exit_fail_msg("%s test: Failed to unshare pid namespace\n",
225 test_name);
226 }
227
228 ret = unshare(CLONE_NEWNS);
229 if (ret < 0) {
230 if (errno == EPERM) {
231 ksft_test_result_skip("%s test: Unsharing mount namespace not permitted\n",
232 test_name);
233 return 0;
234 }
235 ksft_exit_fail_msg("%s test: Failed to unshare mount namespace\n",
236 test_name);
237 }
238
239 ret = mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, 0);
240 if (ret < 0)
241 ksft_exit_fail_msg("%s test: Failed to remount / private\n",
242 test_name);
243
244 /* pid 1 in new pid namespace */
245 pid1 = fork();
246 if (pid1 < 0)
247 ksft_exit_fail_msg("%s test: Failed to create new process\n",
248 test_name);
249
250 if (pid1 == 0) {
251 char buf[256];
252 pid_t pid2;
253 int pidfd = -1;
254
255 (void)umount2("/proc", MNT_DETACH);
256 ret = mount("proc", "/proc", "proc", 0, NULL);
257 if (ret < 0)
258 _exit(PIDFD_ERROR);
259
260 /* grab pid PID_RECYCLE */
261 for (i = 0; i <= PIDFD_MAX_DEFAULT; i++) {
262 pid2 = fork();
263 if (pid2 < 0)
264 _exit(PIDFD_ERROR);
265
266 if (pid2 == 0)
267 _exit(PIDFD_PASS);
268
269 if (pid2 == PID_RECYCLE) {
270 snprintf(buf, sizeof(buf), "/proc/%d", pid2);
271 ksft_print_msg("pid to recycle is %d\n", pid2);
272 pidfd = open(buf, O_DIRECTORY | O_CLOEXEC);
273 }
274
275 if (wait_for_pid(pid2))
276 _exit(PIDFD_ERROR);
277
278 if (pid2 >= PID_RECYCLE)
279 break;
280 }
281
282 /*
283 * We want to be as predictable as we can so if we haven't been
284 * able to grab pid PID_RECYCLE skip the test.
285 */
286 if (pid2 != PID_RECYCLE) {
287 /* skip test */
288 close(pidfd);
289 _exit(PIDFD_SKIP);
290 }
291
292 if (pidfd < 0)
293 _exit(PIDFD_ERROR);
294
295 for (i = 0; i <= PIDFD_MAX_DEFAULT; i++) {
296 char c;
297 int pipe_fds[2];
298 pid_t recycled_pid;
299 int child_ret = PIDFD_PASS;
300
301 ret = pipe2(pipe_fds, O_CLOEXEC);
302 if (ret < 0)
303 _exit(PIDFD_ERROR);
304
305 recycled_pid = fork();
306 if (recycled_pid < 0)
307 _exit(PIDFD_ERROR);
308
309 if (recycled_pid == 0) {
310 close(pipe_fds[1]);
311 (void)read(pipe_fds[0], &c, 1);
312 close(pipe_fds[0]);
313
314 _exit(PIDFD_PASS);
315 }
316
317 /*
318 * Stop the child so we can inspect whether we have
319 * recycled pid PID_RECYCLE.
320 */
321 close(pipe_fds[0]);
322 ret = kill(recycled_pid, SIGSTOP);
323 close(pipe_fds[1]);
324 if (ret) {
325 (void)wait_for_pid(recycled_pid);
326 _exit(PIDFD_ERROR);
327 }
328
329 /*
330 * We have recycled the pid. Try to signal it. This
331 * needs to fail since this is a different process than
332 * the one the pidfd refers to.
333 */
334 if (recycled_pid == PID_RECYCLE) {
335 ret = sys_pidfd_send_signal(pidfd, SIGCONT,
336 NULL, 0);
337 if (ret && errno == ESRCH)
338 child_ret = PIDFD_XFAIL;
339 else
340 child_ret = PIDFD_FAIL;
341 }
342
343 /* let the process move on */
344 ret = kill(recycled_pid, SIGCONT);
345 if (ret)
346 (void)kill(recycled_pid, SIGKILL);
347
348 if (wait_for_pid(recycled_pid))
349 _exit(PIDFD_ERROR);
350
351 switch (child_ret) {
352 case PIDFD_FAIL:
353 /* fallthrough */
354 case PIDFD_XFAIL:
355 _exit(child_ret);
356 case PIDFD_PASS:
357 break;
358 default:
359 /* not reached */
360 _exit(PIDFD_ERROR);
361 }
362
363 /*
364 * If the user set a custom pid_max limit we could be
365 * in the millions.
366 * Skip the test in this case.
367 */
368 if (recycled_pid > PIDFD_MAX_DEFAULT)
369 _exit(PIDFD_SKIP);
370 }
371
372 /* failed to recycle pid */
373 _exit(PIDFD_SKIP);
374 }
375
376 ret = wait_for_pid(pid1);
377 switch (ret) {
378 case PIDFD_FAIL:
379 ksft_exit_fail_msg(
380 "%s test: Managed to signal recycled pid %d\n",
381 test_name, PID_RECYCLE);
382 case PIDFD_PASS:
383 ksft_exit_fail_msg("%s test: Failed to recycle pid %d\n",
384 test_name, PID_RECYCLE);
385 case PIDFD_SKIP:
386 ksft_test_result_skip("%s test: Skipping test\n", test_name);
387 ret = 0;
388 break;
389 case PIDFD_XFAIL:
390 ksft_test_result_pass(
391 "%s test: Failed to signal recycled pid as expected\n",
392 test_name);
393 ret = 0;
394 break;
395 default /* PIDFD_ERROR */:
396 ksft_exit_fail_msg("%s test: Error while running tests\n",
397 test_name);
398 }
399
400 return ret;
401}
402
403static int test_pidfd_send_signal_syscall_support(void)
404{
405 int pidfd, ret;
406 const char *test_name = "pidfd_send_signal check for support";
407
408 pidfd = open("/proc/self", O_DIRECTORY | O_CLOEXEC);
409 if (pidfd < 0)
410 ksft_exit_fail_msg(
411 "%s test: Failed to open process file descriptor\n",
412 test_name);
413
414 ret = sys_pidfd_send_signal(pidfd, 0, NULL, 0);
415 if (ret < 0) {
416 if (errno == ENOSYS) {
417 ksft_test_result_skip(
418 "%s test: pidfd_send_signal() syscall not supported\n",
419 test_name);
420 return 0;
421 }
422 ksft_exit_fail_msg("%s test: Failed to send signal\n",
423 test_name);
424 }
425
426 have_pidfd_send_signal = true;
427 close(pidfd);
428 ksft_test_result_pass(
429 "%s test: pidfd_send_signal() syscall is supported. Tests can be executed\n",
430 test_name);
431 return 0;
432}
433
434static void *test_pidfd_poll_exec_thread(void *priv)
435{
436 ksft_print_msg("Child Thread: starting. pid %d tid %ld ; and sleeping\n",
437 getpid(), syscall(SYS_gettid));
438 ksft_print_msg("Child Thread: doing exec of sleep\n");
439
440 execl("/bin/sleep", "sleep", str(CHILD_THREAD_MIN_WAIT), (char *)NULL);
441
442 ksft_print_msg("Child Thread: DONE. pid %d tid %ld\n",
443 getpid(), syscall(SYS_gettid));
444 return NULL;
445}
446
447static void poll_pidfd(const char *test_name, int pidfd)
448{
449 int c;
450 int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
451 struct epoll_event event, events[MAX_EVENTS];
452
453 if (epoll_fd == -1)
454 ksft_exit_fail_msg("%s test: Failed to create epoll file descriptor "
455 "(errno %d)\n",
456 test_name, errno);
457
458 event.events = EPOLLIN;
459 event.data.fd = pidfd;
460
461 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pidfd, &event)) {
462 ksft_exit_fail_msg("%s test: Failed to add epoll file descriptor "
463 "(errno %d)\n",
464 test_name, errno);
465 }
466
467 c = epoll_wait(epoll_fd, events, MAX_EVENTS, 5000);
468 if (c != 1 || !(events[0].events & EPOLLIN))
469 ksft_exit_fail_msg("%s test: Unexpected epoll_wait result (c=%d, events=%x) "
470 "(errno %d)\n",
471 test_name, c, events[0].events, errno);
472
473 close(epoll_fd);
474 return;
475
476}
477
478static int child_poll_exec_test(void *args)
479{
480 pthread_t t1;
481
482 ksft_print_msg("Child (pidfd): starting. pid %d tid %ld\n", getpid(),
483 syscall(SYS_gettid));
484 pthread_create(&t1, NULL, test_pidfd_poll_exec_thread, NULL);
485 /*
486 * Exec in the non-leader thread will destroy the leader immediately.
487 * If the wait in the parent returns too soon, the test fails.
488 */
489 while (1)
490 sleep(1);
491
492 return 0;
493}
494
495static void test_pidfd_poll_exec(int use_waitpid)
496{
497 int pid, pidfd = 0;
498 int status, ret;
499 time_t prog_start = time(NULL);
500 const char *test_name = "pidfd_poll check for premature notification on child thread exec";
501
502 ksft_print_msg("Parent: pid: %d\n", getpid());
503 pid = pidfd_clone(CLONE_PIDFD, &pidfd, child_poll_exec_test);
504 if (pid < 0)
505 ksft_exit_fail_msg("%s test: pidfd_clone failed (ret %d, errno %d)\n",
506 test_name, pid, errno);
507
508 ksft_print_msg("Parent: Waiting for Child (%d) to complete.\n", pid);
509
510 if (use_waitpid) {
511 ret = waitpid(pid, &status, 0);
512 if (ret == -1)
513 ksft_print_msg("Parent: error\n");
514
515 if (ret == pid)
516 ksft_print_msg("Parent: Child process waited for.\n");
517 } else {
518 poll_pidfd(test_name, pidfd);
519 }
520
521 time_t prog_time = time(NULL) - prog_start;
522
523 ksft_print_msg("Time waited for child: %lu\n", prog_time);
524
525 close(pidfd);
526
527 if (prog_time < CHILD_THREAD_MIN_WAIT || prog_time > CHILD_THREAD_MIN_WAIT + 2)
528 ksft_exit_fail_msg("%s test: Failed\n", test_name);
529 else
530 ksft_test_result_pass("%s test: Passed\n", test_name);
531}
532
533static void *test_pidfd_poll_leader_exit_thread(void *priv)
534{
535 ksft_print_msg("Child Thread: starting. pid %d tid %ld ; and sleeping\n",
536 getpid(), syscall(SYS_gettid));
537 sleep(CHILD_THREAD_MIN_WAIT);
538 ksft_print_msg("Child Thread: DONE. pid %d tid %ld\n", getpid(), syscall(SYS_gettid));
539 return NULL;
540}
541
542static time_t *child_exit_secs;
543static int child_poll_leader_exit_test(void *args)
544{
545 pthread_t t1, t2;
546
547 ksft_print_msg("Child: starting. pid %d tid %ld\n", getpid(), syscall(SYS_gettid));
548 pthread_create(&t1, NULL, test_pidfd_poll_leader_exit_thread, NULL);
549 pthread_create(&t2, NULL, test_pidfd_poll_leader_exit_thread, NULL);
550
551 /*
552 * glibc exit calls exit_group syscall, so explicitly call exit only
553 * so that only the group leader exits, leaving the threads alone.
554 */
555 *child_exit_secs = time(NULL);
556 syscall(SYS_exit, 0);
557 /* Never reached, but appeases compiler thinking we should return. */
558 exit(0);
559}
560
561static void test_pidfd_poll_leader_exit(int use_waitpid)
562{
563 int pid, pidfd = 0;
564 int status, ret = 0;
565 const char *test_name = "pidfd_poll check for premature notification on non-empty"
566 "group leader exit";
567
568 child_exit_secs = mmap(NULL, sizeof *child_exit_secs, PROT_READ | PROT_WRITE,
569 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
570
571 if (child_exit_secs == MAP_FAILED)
572 ksft_exit_fail_msg("%s test: mmap failed (errno %d)\n",
573 test_name, errno);
574
575 ksft_print_msg("Parent: pid: %d\n", getpid());
576 pid = pidfd_clone(CLONE_PIDFD, &pidfd, child_poll_leader_exit_test);
577 if (pid < 0)
578 ksft_exit_fail_msg("%s test: pidfd_clone failed (ret %d, errno %d)\n",
579 test_name, pid, errno);
580
581 ksft_print_msg("Parent: Waiting for Child (%d) to complete.\n", pid);
582
583 if (use_waitpid) {
584 ret = waitpid(pid, &status, 0);
585 if (ret == -1)
586 ksft_print_msg("Parent: error\n");
587 } else {
588 /*
589 * This sleep tests for the case where if the child exits, and is in
590 * EXIT_ZOMBIE, but the thread group leader is non-empty, then the poll
591 * doesn't prematurely return even though there are active threads
592 */
593 sleep(1);
594 poll_pidfd(test_name, pidfd);
595 }
596
597 if (ret == pid)
598 ksft_print_msg("Parent: Child process waited for.\n");
599
600 time_t since_child_exit = time(NULL) - *child_exit_secs;
601
602 ksft_print_msg("Time since child exit: %lu\n", since_child_exit);
603
604 close(pidfd);
605
606 if (since_child_exit < CHILD_THREAD_MIN_WAIT ||
607 since_child_exit > CHILD_THREAD_MIN_WAIT + 2)
608 ksft_exit_fail_msg("%s test: Failed\n", test_name);
609 else
610 ksft_test_result_pass("%s test: Passed\n", test_name);
611}
612
613int main(int argc, char **argv)
614{
615 ksft_print_header();
616 ksft_set_plan(8);
617
618 test_pidfd_poll_exec(0);
619 test_pidfd_poll_exec(1);
620 test_pidfd_poll_leader_exit(0);
621 test_pidfd_poll_leader_exit(1);
622 test_pidfd_send_signal_syscall_support();
623 test_pidfd_send_signal_simple_success();
624 test_pidfd_send_signal_exited_fail();
625 test_pidfd_send_signal_recycled_pid_fail();
626
627 ksft_exit_pass();
628}