1 /* SPDX-License-Identifier: GPL-2.0 */
2 
3 #define _GNU_SOURCE
4 #include <errno.h>
5 #include <linux/sched.h>
6 #include <linux/types.h>
7 #include <signal.h>
8 #include <stdint.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <sched.h>
12 #include <string.h>
13 #include <sys/resource.h>
14 #include <sys/time.h>
15 #include <sys/types.h>
16 #include <sys/wait.h>
17 #include <unistd.h>
18 
19 #include "pidfd.h"
20 #include "../kselftest_harness.h"
21 
22 #define ptr_to_u64(ptr) ((__u64)((uintptr_t)(ptr)))
23 
24 /* Attempt to de-conflict with the selftests tree. */
25 #ifndef SKIP
26 #define SKIP(s, ...)	XFAIL(s, ##__VA_ARGS__)
27 #endif
28 
sys_clone3(struct clone_args * args)29 static pid_t sys_clone3(struct clone_args *args)
30 {
31 	return syscall(__NR_clone3, args, sizeof(struct clone_args));
32 }
33 
sys_waitid(int which,pid_t pid,siginfo_t * info,int options,struct rusage * ru)34 static int sys_waitid(int which, pid_t pid, siginfo_t *info, int options,
35 		      struct rusage *ru)
36 {
37 	return syscall(__NR_waitid, which, pid, info, options, ru);
38 }
39 
TEST(wait_simple)40 TEST(wait_simple)
41 {
42 	int pidfd = -1;
43 	pid_t parent_tid = -1;
44 	struct clone_args args = {
45 		.parent_tid = ptr_to_u64(&parent_tid),
46 		.pidfd = ptr_to_u64(&pidfd),
47 		.flags = CLONE_PIDFD | CLONE_PARENT_SETTID,
48 		.exit_signal = SIGCHLD,
49 	};
50 	pid_t pid;
51 	siginfo_t info = {
52 		.si_signo = 0,
53 	};
54 
55 	pidfd = open("/proc/self", O_DIRECTORY | O_RDONLY | O_CLOEXEC);
56 	ASSERT_GE(pidfd, 0);
57 
58 	pid = sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL);
59 	ASSERT_NE(pid, 0);
60 	EXPECT_EQ(close(pidfd), 0);
61 	pidfd = -1;
62 
63 	pidfd = open("/dev/null", O_RDONLY | O_CLOEXEC);
64 	ASSERT_GE(pidfd, 0);
65 
66 	pid = sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL);
67 	ASSERT_NE(pid, 0);
68 	EXPECT_EQ(close(pidfd), 0);
69 	pidfd = -1;
70 
71 	pid = sys_clone3(&args);
72 	ASSERT_GE(pid, 0);
73 
74 	if (pid == 0)
75 		exit(EXIT_SUCCESS);
76 
77 	pid = sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL);
78 	ASSERT_GE(pid, 0);
79 	ASSERT_EQ(WIFEXITED(info.si_status), true);
80 	ASSERT_EQ(WEXITSTATUS(info.si_status), 0);
81 	EXPECT_EQ(close(pidfd), 0);
82 
83 	ASSERT_EQ(info.si_signo, SIGCHLD);
84 	ASSERT_EQ(info.si_code, CLD_EXITED);
85 	ASSERT_EQ(info.si_pid, parent_tid);
86 }
87 
TEST(wait_states)88 TEST(wait_states)
89 {
90 	int pidfd = -1;
91 	pid_t parent_tid = -1;
92 	struct clone_args args = {
93 		.parent_tid = ptr_to_u64(&parent_tid),
94 		.pidfd = ptr_to_u64(&pidfd),
95 		.flags = CLONE_PIDFD | CLONE_PARENT_SETTID,
96 		.exit_signal = SIGCHLD,
97 	};
98 	int pfd[2];
99 	pid_t pid;
100 	siginfo_t info = {
101 		.si_signo = 0,
102 	};
103 
104 	ASSERT_EQ(pipe(pfd), 0);
105 	pid = sys_clone3(&args);
106 	ASSERT_GE(pid, 0);
107 
108 	if (pid == 0) {
109 		char buf[2];
110 
111 		close(pfd[1]);
112 		kill(getpid(), SIGSTOP);
113 		ASSERT_EQ(read(pfd[0], buf, 1), 1);
114 		close(pfd[0]);
115 		kill(getpid(), SIGSTOP);
116 		exit(EXIT_SUCCESS);
117 	}
118 
119 	close(pfd[0]);
120 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WSTOPPED, NULL), 0);
121 	ASSERT_EQ(info.si_signo, SIGCHLD);
122 	ASSERT_EQ(info.si_code, CLD_STOPPED);
123 	ASSERT_EQ(info.si_pid, parent_tid);
124 
125 	ASSERT_EQ(sys_pidfd_send_signal(pidfd, SIGCONT, NULL, 0), 0);
126 
127 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WCONTINUED, NULL), 0);
128 	ASSERT_EQ(write(pfd[1], "C", 1), 1);
129 	close(pfd[1]);
130 	ASSERT_EQ(info.si_signo, SIGCHLD);
131 	ASSERT_EQ(info.si_code, CLD_CONTINUED);
132 	ASSERT_EQ(info.si_pid, parent_tid);
133 
134 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WUNTRACED, NULL), 0);
135 	ASSERT_EQ(info.si_signo, SIGCHLD);
136 	ASSERT_EQ(info.si_code, CLD_STOPPED);
137 	ASSERT_EQ(info.si_pid, parent_tid);
138 
139 	ASSERT_EQ(sys_pidfd_send_signal(pidfd, SIGKILL, NULL, 0), 0);
140 
141 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL), 0);
142 	ASSERT_EQ(info.si_signo, SIGCHLD);
143 	ASSERT_EQ(info.si_code, CLD_KILLED);
144 	ASSERT_EQ(info.si_pid, parent_tid);
145 
146 	EXPECT_EQ(close(pidfd), 0);
147 }
148 
TEST(wait_nonblock)149 TEST(wait_nonblock)
150 {
151 	int pidfd;
152 	unsigned int flags = 0;
153 	pid_t parent_tid = -1;
154 	struct clone_args args = {
155 		.parent_tid = ptr_to_u64(&parent_tid),
156 		.flags = CLONE_PARENT_SETTID,
157 		.exit_signal = SIGCHLD,
158 	};
159 	int ret;
160 	pid_t pid;
161 	siginfo_t info = {
162 		.si_signo = 0,
163 	};
164 
165 	/*
166 	 * Callers need to see ECHILD with non-blocking pidfds when no child
167 	 * processes exists.
168 	 */
169 	pidfd = sys_pidfd_open(getpid(), PIDFD_NONBLOCK);
170 	EXPECT_GE(pidfd, 0) {
171 		/* pidfd_open() doesn't support PIDFD_NONBLOCK. */
172 		ASSERT_EQ(errno, EINVAL);
173 		SKIP(return, "Skipping PIDFD_NONBLOCK test");
174 	}
175 
176 	ret = sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL);
177 	ASSERT_LT(ret, 0);
178 	ASSERT_EQ(errno, ECHILD);
179 	EXPECT_EQ(close(pidfd), 0);
180 
181 	pid = sys_clone3(&args);
182 	ASSERT_GE(pid, 0);
183 
184 	if (pid == 0) {
185 		kill(getpid(), SIGSTOP);
186 		exit(EXIT_SUCCESS);
187 	}
188 
189 	pidfd = sys_pidfd_open(pid, PIDFD_NONBLOCK);
190 	EXPECT_GE(pidfd, 0) {
191 		/* pidfd_open() doesn't support PIDFD_NONBLOCK. */
192 		ASSERT_EQ(errno, EINVAL);
193 		SKIP(return, "Skipping PIDFD_NONBLOCK test");
194 	}
195 
196 	flags = fcntl(pidfd, F_GETFL, 0);
197 	ASSERT_GT(flags, 0);
198 	ASSERT_GT((flags & O_NONBLOCK), 0);
199 
200 	/*
201 	 * Callers need to see EAGAIN/EWOULDBLOCK with non-blocking pidfd when
202 	 * child processes exist but none have exited.
203 	 */
204 	ret = sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL);
205 	ASSERT_LT(ret, 0);
206 	ASSERT_EQ(errno, EAGAIN);
207 
208 	/*
209 	 * Callers need to continue seeing 0 with non-blocking pidfd and
210 	 * WNOHANG raised explicitly when child processes exist but none have
211 	 * exited.
212 	 */
213 	ret = sys_waitid(P_PIDFD, pidfd, &info, WEXITED | WNOHANG, NULL);
214 	ASSERT_EQ(ret, 0);
215 
216 	ASSERT_EQ(fcntl(pidfd, F_SETFL, (flags & ~O_NONBLOCK)), 0);
217 
218 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WSTOPPED, NULL), 0);
219 	ASSERT_EQ(info.si_signo, SIGCHLD);
220 	ASSERT_EQ(info.si_code, CLD_STOPPED);
221 	ASSERT_EQ(info.si_pid, parent_tid);
222 
223 	ASSERT_EQ(sys_pidfd_send_signal(pidfd, SIGCONT, NULL, 0), 0);
224 
225 	ASSERT_EQ(sys_waitid(P_PIDFD, pidfd, &info, WEXITED, NULL), 0);
226 	ASSERT_EQ(info.si_signo, SIGCHLD);
227 	ASSERT_EQ(info.si_code, CLD_EXITED);
228 	ASSERT_EQ(info.si_pid, parent_tid);
229 
230 	EXPECT_EQ(close(pidfd), 0);
231 }
232 
233 TEST_HARNESS_MAIN
234