pidfd: waiting on processes through pidfds
Subsystems (5)
Christian Brauner
maintainerv3 cover pidfd: waiting on processes through pidfds
Hey everyone,
/* v3 */
This adds the ability to wait on processes using pidfds. This is one of the few missing pieces to make it possible to manage processes using only pidfds.
Now major changes have occured since v2. The only thing that was changed has been to move the translation of a pidfd into a struct pid to a dedicated helper that also does a get_pid() on it to keep the exit code identical for all switch cases.
I've also added a test to verify that we correctly fail when an invalid file descriptor is passed.
The core patch for waitid is pleasantly small. The largest change is caused by adding proper tests for waitid(P_PIDFD).
/* v2 */
/* v1 */
/* v0 */
Christian
Christian Brauner (2):
pidfd: add P_PIDFD to waitid()
pidfd: add pidfd_wait tests
include/linux/pid.h | 4 + include/uapi/linux/wait.h | 1 + kernel/exit.c | 33 ++- kernel/fork.c | 8 + kernel/signal.c | 7 +- tools/testing/selftests/pidfd/pidfd.h | 25 ++ tools/testing/selftests/pidfd/pidfd_test.c | 14 -- tools/testing/selftests/pidfd/pidfd_wait.c | 258 +++++++++++++++++++++ 8 files changed, 331 insertions(+), 19 deletions(-) create mode 100644 tools/testing/selftests/pidfd/pidfd_wait.c
Signature · 1 line
2.22.0
Christian Brauner
maintainerPATCH v3 1/2 pidfd: add P_PIDFD to waitid()
This adds the P_PIDFD type to waitid().
One of the last remaining bits for the pidfd api is to make it possible to wait on pidfds. With P_PIDFD added to waitid() the parts of userspace that want to use the pidfd api to exclusively manage processes can do so now.
One of the things this will unblock in the future is the ability to make it possible to retrieve the exit status via waitid(P_PIDFD) for non-parent processes if handed a _suitable_ pidfd that has this feature set. This is similar to what you can do on FreeBSD with kqueue(). It might even end up being possible to wait on a process as a non-parent if an appropriate property is enabled on the pidfd.
With P_PIDFD no scoping of the process identified by the pidfd is possible, i.e. it explicitly blocks things such as wait4(-1), wait4(0), waitid(P_ALL), waitid(P_PGID) etc. It only allows for semantics equivalent to wait4(pid), waitid(P_PID). Users that need scoping should rely on pid-based wait*() syscalls for now.
---
v1:
- Linus Torvalds <[email protected]>:
- use flag as discussed before, not a dedicated pidfd_wait() syscall
- Oleg Nesterov <[email protected]>:
- use flag as discussed before, not a dedicated pidfd_wait() syscall
v2:
- Linus Torvalds <[email protected]>:
- move find_get_pid() calls into switch statements to avoid checking the type argument twice
v3:
- Linus Torvalds <[email protected]>:
- add a dedicated helper which does the transformation from pidfd to struct pid to avoid open coding this
- take an additional reference to struct pid to keep the exit code unified
--- include/linux/pid.h | 4 ++++ include/uapi/linux/wait.h | 1 + kernel/exit.c | 33 ++++++++++++++++++++++++++++++--- kernel/fork.c | 8 ++++++++ kernel/signal.c | 7 +++++-- 5 files changed, 48 insertions(+), 5 deletions(-)
include/linux/pid.h +4 -0
@@ -72,6 +72,10 @@ extern struct pid init_struct_pid;extern const struct file_operations pidfd_fops; +struct file ; + +extern struct pid *pidfd_pid (const struct file *file); +static inline struct pid *get_pid (struct pid *pid) {if (pid)
include/uapi/linux/wait.h +1 -0
@@ -17,6 +17,7 @@#define P_ALL 0#define P_PID 1#define P_PGID 2 +#define P_PIDFD 3#endif /* _UAPI_LINUX_WAIT_H */
kernel/exit.c +30 -3
@@ -1552,6 +1552,23 @@ static long do_wait(struct wait_opts *wo)return retval; } +static struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd); +if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +} +static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop,int options,struct rusage *ru) {
@@ -1574,19 +1591,29 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, type =PIDTYPE_PID ;if (upid <=0 )return -EINVAL ; + + pid =find_get_pid (upid);break ;case P_PGID : type =PIDTYPE_PGID ;if (upid <=0 )return -EINVAL ; + + pid =find_get_pid (upid); +break ; +case P_PIDFD : + type =PIDTYPE_PID ; +if (upid <0 ) +return -EINVAL ; + + pid =pidfd_get_pid (upid); +if (IS_ERR (pid)) +return PTR_ERR (pid);break ;default :return -EINVAL ; } -if (type <PIDTYPE_MAX ) - pid =find_get_pid (upid); - wo.wo_type = type; wo.wo_pid = pid; wo.wo_flags = options;
kernel/fork.c +8 -0
@@ -1690,6 +1690,14 @@ static inline void rcu_copy_process(struct task_struct *p)#endif /* #ifdef CONFIG_TASKS_RCU */ } +struct pid *pidfd_pid (const struct file *file) +{ +if (file->f_op == &pidfd_fops) +return file->private_data; + +return ERR_PTR (-EBADF ); +} +static int pidfd_release (struct inode *inode,struct file *file) {struct pid *pid = file->private_data;
kernel/signal.c +5 -2
@@ -3672,8 +3672,11 @@ static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo, siginfo_t *info)static struct pid *pidfd_to_pid (const struct file *file) { -if (file->f_op == &pidfd_fops) -return file->private_data; +struct pid *pid; + + pid =pidfd_pid (file); +if (!IS_ERR (pid)) +return pid;return tgid_pidfd_to_pid (file); }
Signature · 1 line
2.22.0
Re: [PATCH v3 1/2] pidfd: add P_PIDFD to waitid()
Quoted 7 lines · Christian Brauner
kernel/exit.c +6
-0+static struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd);
kernel/exit.c static long do_wait(struct wait_opts *wo) · line 1570
Quoted 10 lines
kernel/exit.c +10
-0+if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +}
Agreed, this looks better than the previous version.
FWIW,
Christian Brauner
maintainerRe: [PATCH v3 1/2] pidfd: add P_PIDFD to waitid()
Quoted 21 lines · Oleg Nesterov
Quoted 7 lines · Christian Brauner
kernel/exit.c +6
-0+static struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd);kernel/exit.c static long do_wait(struct wait_opts *wo) · line 1570
Quoted 10 lines
kernel/exit.c +10
-0+if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +}Agreed, this looks better than the previous version.
Quoted 3 lines
FWIW,
Reviewed-by Oleg Nesterov <[email protected]>
Thanks Oleg!
Christian
Re: [PATCH v3 1/2] pidfd: add P_PIDFD to waitid()
In reply to Christian BraunerQuoted 40 lines · Christian Brauner
kernel/exit.c +20
-0@@ -1552,6 +1552,23 @@ static long do_wait(struct wait_opts *wo)return retval; } +static struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd); +if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +} +static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop,int options,struct rusage *ru) {@@ -1574,19 +1591,29 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, type =PIDTYPE_PID ;if (upid <=0 )return -EINVAL ; + + pid =find_get_pid (upid);break ;case P_PGID : type =PIDTYPE_PGID ;if (upid <=0 )return -EINVAL ; +
kernel/exit.c static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, · line 1611
Quoted 10 lines
kernel/exit.c +10
-0+ pid =find_get_pid (upid); +break ; +case P_PIDFD : + type =PIDTYPE_PID ; +if (upid <0 ) +return -EINVAL ; + + pid =pidfd_get_pid (upid); +if (IS_ERR (pid)) +return PTR_ERR (pid);
I spent some time convincing myself that this early bail out was correct. It seems this path is only reachable in the EBADF case, so that makes sense. The other failure modes in this switch all give a NULL pid so that the final do_wait() returns ECHILD. So, as long as that's intentional (which I think it is), this all looks fine. :)
Signature · 1 line
Kees Cook
Christian Brauner
maintainerRe: [PATCH v3 1/2] pidfd: add P_PIDFD to waitid()
Quoted 49 lines · Kees Cook
Quoted 48 lines · Christian Brauner
kernel/exit.c +28
-0@@ -1552,6 +1552,23 @@ static long do_wait(struct wait_opts *wo)return retval; } +static struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd); +if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +} +static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop,int options,struct rusage *ru) {@@ -1574,19 +1591,29 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, type =PIDTYPE_PID ;if (upid <=0 )return -EINVAL ; + + pid =find_get_pid (upid);break ;case P_PGID : type =PIDTYPE_PGID ;if (upid <=0 )return -EINVAL ; + + pid =find_get_pid (upid); +break ; +case P_PIDFD : + type =PIDTYPE_PID ; +if (upid <0 ) +return -EINVAL ; + + pid =pidfd_get_pid (upid);
Quoted 8 lines
kernel/exit.c static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, · line 1611
Quoted 2 lines
kernel/exit.c +2
-0+if (IS_ERR (pid)) +return PTR_ERR (pid);I spent some time convincing myself that this early bail out was correct. It seems this path is only reachable in the EBADF case, so that makes sense. The other failure modes in this switch all give a NULL pid so that the final
do_wait()returns ECHILD. So, as long as that's intentional (which I think it is), this all looks fine. :)
Yep, it is. I didn't want to refactor that out of do_wait(). :)
Thanks!
Christian
Quoted 2 lines
Reviewed-by Kees Cook <[email protected]>
Christian Brauner
maintainerPATCH v3 2/2 pidfd: add pidfd_wait tests
In reply to Christian BraunerAdd tests for pidfd_wait() and CLONE_WAIT_PID:
- test that waitid(P_PIDFD) can wait on a pidfd
- test that waitid(P_PIDFD) can wait on a pidfd and return siginfo_t
- test that waitid(P_PIDFD) works with WEXITED
- test that waitid(P_PIDFD) works with WSTOPPED
- test that waitid(P_PIDFD) works with WUNTRACED
- test that waitid(P_PIDFD) works with WCONTINUED
- test that waitid(P_PIDFD) works with WNOWAIT
- test that waitid(P_PIDFD)works with WNOHANG
---
v1:
- Christian Brauner <[email protected]>:
- adapt tests to new P_PIDFD concept
v2: unchanged
v3:
- Christian Brauner <[email protected]>:
- add a test for passing an invalid pidfd
--- tools/testing/selftests/pidfd/pidfd.h | 25 ++ tools/testing/selftests/pidfd/pidfd_test.c | 14 -- tools/testing/selftests/pidfd/pidfd_wait.c | 258 +++++++++++++++++++++ 3 files changed, 283 insertions(+), 14 deletions(-) create mode 100644 tools/testing/selftests/pidfd/pidfd_wait.c
tools/testing/selftests/pidfd/pidfd.h +25 -0
@@ -16,6 +16,26 @@#include "../kselftest.h" +#ifndef P_PIDFD +#define P_PIDFD 3 +#endif + +#ifndef CLONE_PIDFD +#define CLONE_PIDFD 0x00001000 +#endif + +#ifndef __NR_pidfd_open +#define __NR_pidfd_open -1 +#endif + +#ifndef __NR_pidfd_send_signal +#define __NR_pidfd_send_signal -1 +#endif + +#ifndef __NR_clone3 +#define __NR_clone3 -1 +#endif +/* * The kernel reserves 300 pids via RESERVED_PIDS in kernel/pid.c * That means, when it wraps around any pid < 300 will be skipped.
@@ -53,5 +73,10 @@ int wait_for_pid(pid_t pid) return WEXITSTATUS(status); } +static inline int sys_pidfd_send_signal (int pidfd,int sig,siginfo_t *info, +unsigned int flags) +{ +return syscall (__NR_pidfd_send_signal, pidfd, sig, info, flags); +}#endif /* __PIDFD_H */
tools/testing/selftests/pidfd/pidfd_test.c +0 -14
@@ -21,20 +21,12 @@#include "pidfd.h" #include "../kselftest.h" -#ifndef __NR_pidfd_send_signal -#define __NR_pidfd_send_signal -1 -#endif -#define str (s) _str(s)#define _str (s) #s#define CHILD_THREAD_MIN_WAIT 3/* seconds */ #define MAX_EVENTS 5 -#ifndef CLONE_PIDFD -#define CLONE_PIDFD 0x00001000 -#endif -static pid_t pidfd_clone (int flags,int *pidfd,int (*fn)(void *)) {size_t stack_size =1024 ;
@@ -47,12 +39,6 @@ static pid_t pidfd_clone(int flags, int *pidfd, int (*fn)(void *))#endif } -static inline int sys_pidfd_send_signal (int pidfd,int sig,siginfo_t *info, -unsigned int flags) -{ -return syscall (__NR_pidfd_send_signal, pidfd, sig, info, flags); -} -static int signal_received;static void set_signal_received_on_sigusr1 (int sig)
tools/testing/selftests/pidfd/pidfd_wait.c new file +258 -0
258 lines not on this page · raw message
Signature · 1 line
2.22.0
Re: [PATCH v3 2/2] pidfd: add pidfd_wait tests
Quoted 9 lines · Christian Brauner
Add tests for
pidfd_wait()andCLONE_WAIT_PID:
- test thatwaitid(P_PIDFD)can wait on a pidfd
- test thatwaitid(P_PIDFD)can wait on a pidfd and returnsiginfo_t
- test thatwaitid(P_PIDFD)works with WEXITED
- test thatwaitid(P_PIDFD)works with WSTOPPED
- test thatwaitid(P_PIDFD)works with WUNTRACED
- test thatwaitid(P_PIDFD)works with WCONTINUED
- test thatwaitid(P_PIDFD)works with WNOWAIT
- test that waitid(P_PIDFD)works with WNOHANG
This all looks good to me! :) One note that doesn't apply to this patch in particular, but might be nice to add (as I didn't see in the existing tests) was testing for pathological conditions: passing in /dev/zero for the pidfd, etc. (Maybe I missed those?)
Signature · 1 line
Kees Cook
Christian Brauner
maintainerRe: [PATCH v3 2/2] pidfd: add pidfd_wait tests
Quoted 11 lines · Kees Cook
Quoted 9 lines · Christian Brauner
Add tests for
pidfd_wait()andCLONE_WAIT_PID:
- test thatwaitid(P_PIDFD)can wait on a pidfd
- test thatwaitid(P_PIDFD)can wait on a pidfd and returnsiginfo_t
- test thatwaitid(P_PIDFD)works with WEXITED
- test thatwaitid(P_PIDFD)works with WSTOPPED
- test thatwaitid(P_PIDFD)works with WUNTRACED
- test thatwaitid(P_PIDFD)works with WCONTINUED
- test thatwaitid(P_PIDFD)works with WNOWAIT
- test that waitid(P_PIDFD)works with WNOHANG
Quoted 6 lines
Reviewed-by Kees Cook <[email protected]>This all looks good to me! :) One note that doesn't apply to this patch in particular, but might be nice to add (as I didn't see in the existing tests) was testing for pathological conditions: passing in
/dev/zerofor the pidfd, etc. (Maybe I missed those?)
Yeah, I can probably just add one for this scenario. :)
Thanks!
Christian