Add io_uring support for waitid
Jens Axboe
maintainercover Add io_uring support for waitid
Hi,
This adds support for IORING_OP_WAITID, which is an async variant of the waitid(2) syscall. Rather than have a parent need to block waiting on a child task state change, it can now simply get an async notication when the requested state change has occured.
Patches 1..4 are purely prep patches, and should not have functional changes. They split out parts of do_wait() into __do_wait(), so that the prepare-to-wait and sleep parts are contained within do_wait().
Patch 5 adds io_uring support.
I wrote a few basic tests for this, which can be found in the 'waitid' branch of liburing:
https://git.kernel.dk/cgit/liburing/log/?h=waitid
include/linux/io_uring_types.h | 2 + include/uapi/linux/io_uring.h | 2 + io_uring/Makefile | 2 +- io_uring/cancel.c | 5 + io_uring/io_uring.c | 3 + io_uring/opdef.c | 9 ++ io_uring/waitid.c | 271 +++++++++++++++++++++++++++++++++ io_uring/waitid.h | 15 ++ kernel/exit.c | 132 +++++++++------- kernel/exit.h | 30 ++++ 10 files changed, 411 insertions(+), 60 deletions(-)
The code can also be found here:
https://git.kernel.dk/cgit/linux/log/?h=io_uring-waitid
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerPATCH 1/5 exit: abtract out should_wake helper for child_wait_callback()
Abstract out the helper that decides if we should wake up following a wake_up() callback on our internal waitqueue.
No functional changes intended in this patch.
--- kernel/exit.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)
kernel/exit.c +14 -6
@@ -1520,6 +1520,17 @@ static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)return 0 ; } +static bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p) +{ +if (!eligible_pid (wo, p)) +return false; + +if ((wo->wo_flags & __WNOTHREAD) && wo->child_wait.private != p->parent) +return false; + +return true; +} +static int child_wait_callback (wait_queue_entry_t *wait,unsigned mode,int sync,void *key) {
@@ -1527,13 +1538,10 @@ static int child_wait_callback(wait_queue_entry_t *wait, unsigned mode, child_wait);struct task_struct *p = key; -if (!eligible_pid (wo, p)) -return 0 ; +if (pid_child_should_wake (wo, p)) +return default_wake_function (wait, mode, sync, key); -if ((wo->wo_flags & __WNOTHREAD) && wait->private != p->parent) -return 0 ; - -return default_wake_function (wait, mode, sync, key); +return 0 ; }void __wake_up_parent (struct task_struct *p,struct task_struct *parent)
Signature · 1 line
2.40.1
Re: [PATCH 1/5] exit: abtract out should_wake helper for child_wait_callback()
Quoted 7 lines · Jens Axboe
Abstract out the helper that decides if we should wake up following a
wake_up()callback on our internal waitqueue.No functional changes intended in this patch.
Signed-off-by Jens Axboe <[email protected]>---
Jens Axboe
maintainerPATCH 2/5 exit: move core of do_wait() into helper
In reply to Jens AxboeRather than have a maze of gotos, put the actual logic in __do_wait() and have do_wait() loop deal with waitqueue setup/teardown and whether to call __do_wait() again.
No functional changes intended in this patch.
--- kernel/exit.c | 49 ++++++++++++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 19 deletions(-)
kernel/exit.c +30 -19
@@ -1590,16 +1590,10 @@ static int do_wait_pid(struct wait_opts *wo)return 0 ; } -static long do_wait (struct wait_opts *wo) +static long __do_wait (struct wait_opts *wo) { -int retval; - -trace_sched_process_wait (wo->wo_pid); +long retval; -init_waitqueue_func_entry (&wo->child_wait, child_wait_callback); - wo->child_wait.private = current; -add_wait_queue (¤t->signal->wait_chldexit, &wo->child_wait); -repeat:/* * If there is nothing that can match our criteria, just get out. * We will clear ->notask_error to zero if we see any child that
@@ -1617,18 +1611,18 @@ static long do_wait(struct wait_opts *wo)if (wo->wo_type ==PIDTYPE_PID ) { retval =do_wait_pid (wo);if (retval) - goto end; +return retval; }else {struct task_struct *tsk = current; do { retval = do_wait_thread(wo, tsk); if (retval) - goto end; + return retval; retval = ptrace_do_wait(wo, tsk); if (retval) - goto end; + return retval; if (wo->wo_flags & __WNOTHREAD) break;
@@ -1638,14 +1632,31 @@ static long do_wait(struct wait_opts *wo) notask: retval = wo->notask_error; -if (!retval && !(wo->wo_flags &WNOHANG )) { - retval = -ERESTARTSYS ; -if (!signal_pending (current)) { -schedule (); - goto repeat; - } - } -end: +if (!retval && !(wo->wo_flags &WNOHANG )) +return -ERESTARTSYS ; + +return retval; +} + +static long do_wait (struct wait_opts *wo) +{ +int retval; + +trace_sched_process_wait (wo->wo_pid); + +init_waitqueue_func_entry (&wo->child_wait, child_wait_callback); + wo->child_wait.private = current; +add_wait_queue (¤t->signal->wait_chldexit, &wo->child_wait); + +do { + retval =__do_wait (wo); +if (retval != -ERESTARTSYS ) +break ; +if (signal_pending (current)) +break ; +schedule (); + }while (1 ); +__set_current_state (TASK_RUNNING );remove_wait_queue (¤t->signal->wait_chldexit, &wo->child_wait);return retval;
Signature · 1 line
2.40.1
Re: [PATCH 2/5] exit: move core of do_wait() into helper
Quoted 8 lines · Jens Axboe
Rather than have a maze of gotos, put the actual logic in
__do_wait()and havedo_wait()loop deal with waitqueue setup/teardown and whether to call__do_wait()again.No functional changes intended in this patch.
Signed-off-by Jens Axboe <[email protected]>---
Honestly just makes the code easier to read in general,
Jens Axboe
maintainerPATCH 3/5 exit: add kernel_waitid_prepare() helper
In reply to Jens AxboeMove the setup logic out of kernel_waitid(), and into a separate helper.
No functional changes intended in this patch.
--- kernel/exit.c | 41 +++++++++++++++++++++++++++-------------- 1 file changed, 27 insertions(+), 14 deletions(-)
kernel/exit.c +27 -14
@@ -1662,14 +1662,12 @@ static long do_wait(struct wait_opts *wo)return retval; } -static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop, -int options,struct rusage *ru) +static int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags) { -struct wait_opts wo;struct pid *pid =NULL ;enum pid_type type; -long ret; -unsigned int f_flags =0 ;if (options & ~(WNOHANG |WNOWAIT |WEXITED |WSTOPPED |WCONTINUED | __WNOTHREAD|__WCLONE|__WALL))
@@ -1703,7 +1701,7 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop,if (upid <0 )return -EINVAL ; - pid =pidfd_get_pid (upid, &f_flags); + pid =pidfd_get_pid (upid, f_flags);if (IS_ERR (pid))return PTR_ERR (pid);
@@ -1712,19 +1710,34 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop,return -EINVAL ; } - wo.wo_type = type; - wo.wo_pid = pid; - wo.wo_flags = options; - wo.wo_info = infop; - wo.wo_rusage = ru; -if (f_flags &O_NONBLOCK ) - wo.wo_flags |=WNOHANG ; + wo->wo_type = type; + wo->wo_pid = pid; + wo->wo_flags = options; + wo->wo_info = infop; + wo->wo_rusage = ru; +if (*f_flags &O_NONBLOCK ) + wo->wo_flags |=WNOHANG ; + +return 0 ; +} + +static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop, +int options,struct rusage *ru) +{ +struct wait_opts wo; +long ret; +unsigned int f_flags =0 ; + + ret =kernel_waitid_prepare (&wo, which, upid, infop, options, ru, + &f_flags); +if (ret) +return ret; ret =do_wait (&wo);if (!ret && !(options &WNOHANG ) && (f_flags &O_NONBLOCK )) ret = -EAGAIN ; -put_pid (pid); +put_pid (wo.wo_pid);return ret; }
Signature · 1 line
2.40.1
Jens Axboe
maintainerPATCH 4/5 exit: add internal include file with helpers
In reply to Jens AxboeMove struct wait_opts and waitid_info into kernel/exit.h, and include function declarations for the recently added helpers. Make them non-static as well.
This is in preparation for adding a waitid operation through io_uring. With the abtracted helpers, this is now possible.
--- kernel/exit.c | 32 +++++++------------------------- kernel/exit.h | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 25 deletions(-) create mode 100644 kernel/exit.h
kernel/exit.c +7 -25
@@ -74,6 +74,8 @@#include <asm/unistd.h> #include <asm/mmu_context.h> +#include "exit.h" +/* * The default value should be high enough to not crash a system that randomly * crashes its kernel from time to time, but low enough to at least not permit
@@ -1037,26 +1039,6 @@ SYSCALL_DEFINE1(exit_group, int, error_code)return 0 ; } -struct waitid_info { -pid_t pid; -uid_t uid; -int status; -int cause; -}; - -struct wait_opts { -enum pid_type wo_type; -int wo_flags; -struct pid *wo_pid; - -struct waitid_info *wo_info; -int wo_stat; -struct rusage *wo_rusage; - -wait_queue_entry_t child_wait; -int notask_error; -}; -static int eligible_pid (struct wait_opts *wo,struct task_struct *p) { return wo->wo_type == PIDTYPE_MAX ||
@@ -1520,7 +1502,7 @@ static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)return 0 ; } -static bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p) +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p) {if (!eligible_pid (wo, p))return false;
@@ -1590,7 +1572,7 @@ static int do_wait_pid(struct wait_opts *wo)return 0 ; } -static long __do_wait (struct wait_opts *wo) +long __do_wait (struct wait_opts *wo) {long retval;
@@ -1662,9 +1644,9 @@ static long do_wait(struct wait_opts *wo)return retval; } -static int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, -struct waitid_info *infop,int options, -struct rusage *ru,unsigned int *f_flags) +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags) {struct pid *pid =NULL ;enum pid_type type;
kernel/exit.h new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +#ifndef LINUX_WAITID_H +#define LINUX_WAITID_H + +struct waitid_info { +pid_t pid; +uid_t uid; +int status; +int cause; +}; + +struct wait_opts { +enum pid_type wo_type; +int wo_flags; +struct pid *wo_pid; + +struct waitid_info *wo_info; +int wo_stat; +struct rusage *wo_rusage; + +wait_queue_entry_t child_wait; +int notask_error; +}; + +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p); +long __do_wait (struct wait_opts *wo); +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags); +#endif
Signature · 1 line
2.40.1
Re: [PATCH 4/5] exit: add internal include file with helpers
Quoted 110 lines · Jens Axboe
Move struct
wait_optsandwaitid_infointokernel/exit.h, and include function declarations for the recently added helpers. Make them non-static as well.This is in preparation for adding a waitid operation through
io_uring. With the abtracted helpers, this is now possible.Signed-off-by Jens Axboe <[email protected]>--- kernel/exit.c | 32 +++++++------------------------- kernel/exit.h | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 25 deletions(-) create mode 100644 kernel/exit.hkernel/exit.c +7
-25@@ -74,6 +74,8 @@#include <asm/unistd.h> #include <asm/mmu_context.h> +#include "exit.h" +/* * The default value should be high enough to not crash a system that randomly * crashes its kernel from time to time, but low enough to at least not permit @@ -1037,26 +1039,6 @@ SYSCALL_DEFINE1(exit_group, int, error_code)return 0 ; } -struct waitid_info { -pid_t pid; -uid_t uid; -int status; -int cause; -}; - -struct wait_opts { -enum pid_type wo_type; -int wo_flags; -struct pid *wo_pid; - -struct waitid_info *wo_info; -int wo_stat; -struct rusage *wo_rusage; - -wait_queue_entry_t child_wait; -int notask_error; -}; -static int eligible_pid (struct wait_opts *wo,struct task_struct *p) { return wo->wo_type == PIDTYPE_MAX ||@@ -1520,7 +1502,7 @@ static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)return 0 ; } -static bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p) +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p) {if (!eligible_pid (wo, p))return false;@@ -1590,7 +1572,7 @@ static int do_wait_pid(struct wait_opts *wo)return 0 ; } -static long __do_wait (struct wait_opts *wo) +long __do_wait (struct wait_opts *wo) {long retval;@@ -1662,9 +1644,9 @@ static long do_wait(struct wait_opts *wo)return retval; } -static int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, -struct waitid_info *infop,int options, -struct rusage *ru,unsigned int *f_flags) +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags) {struct pid *pid =NULL ;enum pid_type type;kernel/exit.h new file +19
-0@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +#ifndef LINUX_WAITID_H +#define LINUX_WAITID_H + +struct waitid_info { + pid_t pid; + uid_t uid; + int status; + int cause; +}; + +struct wait_opts { + enum pid_type wo_type; + int wo_flags; + struct pid *wo_pid; + + struct waitid_info *wo_info; + int wo_stat; + struct rusage *wo_rusage;
kernel/exit.h line 29
Quoted 10 lines
kernel/exit.h new file +10
-0+ +wait_queue_entry_t child_wait; +int notask_error; +}; + +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p); +long __do_wait (struct wait_opts *wo); +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags);
I know this isn't your mess obviously but could you try and see whether you can expose a nicer, dedicated struct and helper suited to io_uring's needs instead of exposing the messy kernel/exit.c format?
Jens Axboe
maintainerRe: [PATCH 4/5] exit: add internal include file with helpers
Quoted 31 lines · Christian Brauner
Quoted 31 lines
kernel/exit.h new file +25
-0@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +#ifndef LINUX_WAITID_H +#define LINUX_WAITID_H + +struct waitid_info { +pid_t pid; +uid_t uid; +int status; +int cause; +}; + +struct wait_opts { +enum pid_type wo_type; +int wo_flags; +struct pid *wo_pid; + +struct waitid_info *wo_info; +int wo_stat; +struct rusage *wo_rusage; + +wait_queue_entry_t child_wait; +int notask_error; +}; + +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p);
Quoted 8 lines
kernel/exit.h line 29
Quoted 4 lines
kernel/exit.h new file +4
-0+long __do_wait (struct wait_opts *wo); +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags);I know this isn't your mess obviously but could you try and see whether you can expose a nicer, dedicated struct and helper suited to io_uring's needs instead of exposing the messy
kernel/exit.cformat?
From a quick look, I think the wait_opts is pretty much what we need, not much to cut from that. For waitid_info, we can make do with just a forward declaration, we don't need the whole thing.
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerRe: [PATCH 4/5] exit: add internal include file with helpers
Quoted 41 lines · Jens Axboe
Quoted 31 lines · Christian Brauner
Quoted 31 lines
kernel/exit.h new file +25
-0@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only +#ifndef LINUX_WAITID_H +#define LINUX_WAITID_H + +struct waitid_info { +pid_t pid; +uid_t uid; +int status; +int cause; +}; + +struct wait_opts { +enum pid_type wo_type; +int wo_flags; +struct pid *wo_pid; + +struct waitid_info *wo_info; +int wo_stat; +struct rusage *wo_rusage; + +wait_queue_entry_t child_wait; +int notask_error; +}; + +bool pid_child_should_wake (struct wait_opts *wo,struct task_struct *p);Quoted 8 lines
kernel/exit.h line 29
Quoted 4 lines
kernel/exit.h new file +4
-0+long __do_wait (struct wait_opts *wo); +int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid, +struct waitid_info *infop,int options, +struct rusage *ru,unsigned int *f_flags);I know this isn't your mess obviously but could you try and see whether you can expose a nicer, dedicated struct and helper suited to io_uring's needs instead of exposing the messy
kernel/exit.cformat?
Quoted 3 lines
From a quick look, I think the
wait_optsis pretty much what we need, not much to cut from that. Forwaitid_info, we can make do with just a forward declaration, we don't need the whole thing.
I'm wrong obviously, we do need waitid_info as well as that is the output side... Seems to me that none of them have anything redundant wrt io_uring. They could be combined into one thing, but is it worth it?
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerPATCH 5/5 io_uring: add IORING_OP_WAITID support
In reply to Jens AxboeThis adds support for an async version of waitid(2), in a fully async version. If an event isn't immediately available, wait for a callback to trigger a retry.
The format of the sqe is as follows:
sqe->len The 'which', the idtype being queried/waited for.sqe->fd The 'pid' (or id) being waited for.sqe->file_index The 'options' being set.sqe->addr2 A pointer to siginfo_t, if any, being filled in.
buf_index, add3, and waitid_flags are reserved/unused for now. waitid_flags will be used for options for this request type. One interesting use case may be to add multi-shot support, so that the request stays armed and posts a notification every time a monitored process state change occurs.
Note that this does not support rusage, on Arnd's recommendation.
See the waitid(2) man page for details on the arguments.
--- include/linux/io_uring_types.h | 2 + include/uapi/linux/io_uring.h | 2 + io_uring/Makefile | 2 +- io_uring/cancel.c | 5 + io_uring/io_uring.c | 3 + io_uring/opdef.c | 9 ++ io_uring/waitid.c | 271 +++++++++++++++++++++++++++++++++ io_uring/waitid.h | 15 ++ 8 files changed, 308 insertions(+), 1 deletion(-) create mode 100644 io_uring/waitid.c create mode 100644 io_uring/waitid.h
include/linux/io_uring_types.h +2 -0
@@ -276,6 +276,8 @@ struct io_ring_ctx {struct hlist_head futex_list;struct io_alloc_cache futex_cache; +struct hlist_head waitid_list; +const struct cred *sq_creds;/* cred used for __io_sq_thread() */ struct io_sq_data *sq_data;/* if using sq thread polling */
include/uapi/linux/io_uring.h +2 -0
@@ -66,6 +66,7 @@ struct io_uring_sqe {__u32 msg_ring_flags;__u32 uring_cmd_flags;__u32 futex_flags; +__u32 waitid_flags; };__u64 user_data;/* data to be passed back at completion time */ /* pack this to avoid bogus arm OABI complaints */
@@ -239,6 +240,7 @@ enum io_uring_op {IORING_OP_FUTEX_WAIT ,IORING_OP_FUTEX_WAKE ,IORING_OP_FUTEX_WAITV , +IORING_OP_WAITID ,/* this goes last, obviously */ IORING_OP_LAST,
io_uring/Makefile +1 -1
@@ -8,6 +8,6 @@ obj-$(CONFIG_IO_URING) += io_uring.o xattr.o nop.o fs.o splice.o \ statx.o net.o msg_ring.o timeout.o \ sqpoll.o fdinfo.o tctx.o poll.o \ cancel.o kbuf.o rsrc.o rw.o opdef.o \ - notif.o + notif.o waitid.o obj-$(CONFIG_IO_WQ) += io-wq.o obj-$(CONFIG_FUTEX) += futex.o
io_uring/cancel.c +5 -0
@@ -16,6 +16,7 @@#include "poll.h" #include "timeout.h" #include "futex.h" +#include "waitid.h" #include "cancel.h" struct io_cancel {
@@ -124,6 +125,10 @@ int io_try_cancel(struct io_uring_task *tctx, struct io_cancel_data *cd,if (ret != -ENOENT )return ret; + ret =io_waitid_cancel (ctx, cd, issue_flags); +if (ret != -ENOENT ) +return ret; +spin_lock (&ctx->completion_lock);if (!(cd->flags &IORING_ASYNC_CANCEL_FD )) ret =io_timeout_cancel (ctx, cd);
io_uring/io_uring.c +3 -0
@@ -93,6 +93,7 @@#include "net.h" #include "notif.h" #include "futex.h" +#include "waitid.h" #include "timeout.h" #include "poll.h"
@@ -336,6 +337,7 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p) ctx->submit_state.free_list.next =NULL ;INIT_WQ_LIST (&ctx->locked_free_list);INIT_HLIST_HEAD (&ctx->futex_list); +INIT_HLIST_HEAD (&ctx->waitid_list);INIT_DELAYED_WORK (&ctx->fallback_work, io_fallback_req_func);INIT_WQ_LIST (&ctx->submit_state.compl_reqs);return ctx;
@@ -3259,6 +3261,7 @@ static __cold bool io_uring_try_cancel_requests(struct io_ring_ctx *ctx,mutex_lock (&ctx->uring_lock); ret |=io_poll_remove_all (ctx, task, cancel_all); ret |=io_futex_remove_all (ctx, task, cancel_all); + ret |=io_waitid_remove_all (ctx, task, cancel_all);mutex_unlock (&ctx->uring_lock); ret |=io_kill_timeouts (ctx, task, cancel_all);if (task)
io_uring/opdef.c +9 -0
@@ -34,6 +34,7 @@#include "cancel.h" #include "rw.h" #include "futex.h" +#include "waitid.h" static int io_no_issue (struct io_kiocb *req,unsigned int issue_flags) {
@@ -453,6 +454,10 @@ const struct io_issue_def io_issue_defs[] = { .prep = io_eopnotsupp_prep, #endif }, + [IORING_OP_WAITID ] = { + .prep = io_waitid_prep, + .issue = io_waitid, + }, };const struct io_cold_def io_cold_defs[] = {
@@ -681,6 +686,10 @@ const struct io_cold_def io_cold_defs[] = { [IORING_OP_FUTEX_WAITV ] = { .name ="FUTEX_WAITV" , }, + [IORING_OP_WAITID ] = { + .name ="WAITID" , + .async_size =sizeof (struct io_waitid_async ), + }, };const char *io_uring_get_opcode (u8 opcode)
io_uring/waitid.c new file +271 -0
271 lines not on this page · raw message
io_uring/waitid.h new file +15 -0
@@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "../kernel/exit.h" + +struct io_waitid_async { +struct io_kiocb *req; +struct wait_opts wo; +}; + +int io_waitid_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe); +int io_waitid (struct io_kiocb *req,unsigned int issue_flags); +int io_waitid_cancel (struct io_ring_ctx *ctx,struct io_cancel_data *cd, +unsigned int issue_flags); +bool io_waitid_remove_all (struct io_ring_ctx *ctx,struct task_struct *task, +bool cancel_all);
Signature · 1 line
2.40.1
Re: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 17 lines · Jens Axboe
This adds support for an async version of waitid(2), in a fully async version. If an event isn't immediately available, wait for a callback to trigger a retry.
The format of the sqe is as follows:
sqe->lenThe 'which', the idtype being queried/waited for.sqe->fdThe 'pid' (or id) being waited for.sqe->file_indexThe 'options' being set.sqe->addr2A pointer tosiginfo_t, if any, being filled in.
buf_index, add3, andwaitid_flagsare reserved/unused for now.waitid_flagswill be used for options for this request type. One interesting use case may be to add multi-shot support, so that the request stays armed and posts a notification every time a monitored process state change occurs.
Quoted 5 lines
Note that this does not support rusage, on Arnd's recommendation.
See the waitid(2) man page for details on the arguments.
Signed-off-by Jens Axboe <[email protected]>
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Arnd
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 20 lines · Arnd Bergmann
Quoted 19 lines · Jens Axboe
This adds support for an async version of waitid(2), in a fully async version. If an event isn't immediately available, wait for a callback to trigger a retry.
The format of the sqe is as follows:
sqe->lenThe 'which', the idtype being queried/waited for.sqe->fdThe 'pid' (or id) being waited for.sqe->file_indexThe 'options' being set.sqe->addr2A pointer tosiginfo_t, if any, being filled in.
buf_index, add3, andwaitid_flagsare reserved/unused for now.waitid_flagswill be used for options for this request type. One interesting use case may be to add multi-shot support, so that the request stays armed and posts a notification every time a monitored process state change occurs.Note that this does not support rusage, on Arnd's recommendation.
Quoted 8 lines
Quoted 3 lines
See the waitid(2) man page for details on the arguments.
Signed-off-by Jens Axboe <[email protected]>Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if compat_siginfo and siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 25 lines · Jens Axboe
Quoted 24 lines · Arnd Bergmann
Quoted 22 lines · Jens Axboe
This adds support for an async version of waitid(2), in a fully async version. If an event isn't immediately available, wait for a callback to trigger a retry.
The format of the sqe is as follows:
sqe->lenThe 'which', the idtype being queried/waited for.sqe->fdThe 'pid' (or id) being waited for.sqe->file_indexThe 'options' being set.sqe->addr2A pointer tosiginfo_t, if any, being filled in.
buf_index, add3, andwaitid_flagsare reserved/unused for now.waitid_flagswill be used for options for this request type. One interesting use case may be to add multi-shot support, so that the request stays armed and posts a notification every time a monitored process state change occurs.Note that this does not support rusage, on Arnd's recommendation.
See the waitid(2) man page for details on the arguments.
Signed-off-by Jens Axboe <[email protected]>
Quoted 8 lines
Quoted 4 lines
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!
Should be fixed in the current version:
Signature · 1 line
Jens Axboe
Re: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 31 lines · Jens Axboe
Quoted 30 lines · Jens Axboe
Quoted 28 lines · Arnd Bergmann
Quoted 17 lines · Jens Axboe
This adds support for an async version of waitid(2), in a fully async version. If an event isn't immediately available, wait for a callback to trigger a retry.
The format of the sqe is as follows:
sqe->lenThe 'which', the idtype being queried/waited for.sqe->fdThe 'pid' (or id) being waited for.sqe->file_indexThe 'options' being set.sqe->addr2A pointer tosiginfo_t, if any, being filled in.
buf_index, add3, andwaitid_flagsare reserved/unused for now.waitid_flagswill be used for options for this request type. One interesting use case may be to add multi-shot support, so that the request stays armed and posts a notification every time a monitored process state change occurs.Quoted 5 lines
Note that this does not support rusage, on Arnd's recommendation.
See the waitid(2) man page for details on the arguments.
Signed-off-by Jens Axboe <[email protected]>Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Quoted 7 lines
Quoted 3 lines
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
In kernel/signal.c in pidfd_send_signal() we have copy_siginfo_from_user_any() it seems that a similar version copy_siginfo_to_user_any() might be something to consider. We do have copy_siginfo_to_user32() and copy_siginfo_to_user(). But I may lack context why this wouldn't work here.
Re: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 15 lines · Christian Brauner
Quoted 14 lines · Jens Axboe
Quoted 10 lines · Jens Axboe
Quoted 4 lines · Arnd Bergmann
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.
We could add a copy_siginfo_to_user_any(), but I think open-coding it is easier here, since the in_compat_syscall() check does not work inside of the io_uring kernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.
Using copy_siginfo_to_user32() and copy_siginfo_to_user() is probably a good idea though, it's often faster and less error-prone than writing each member separately.
Arnd
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 24 lines · Arnd Bergmann
Quoted 15 lines · Christian Brauner
Quoted 14 lines · Jens Axboe
Quoted 10 lines · Jens Axboe
Quoted 4 lines · Arnd Bergmann
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.
Quoted 5 lines
We could add a
copy_siginfo_to_user_any(), but I think open-coding it is easier here, since thein_compat_syscall()check does not work inside of theio_uringkernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.
Yeah, unifying this stuff did cross my mind when adding another one. Which I think could still be done, you'd just need to pass in a 'compat' parameter similar to how it's done for iovec importing.
But if it's ok with everybody I'd rather do that as a cleanup post this.
Quoted 3 lines
Using
copy_siginfo_to_user32()andcopy_siginfo_to_user()is probably a good idea though, it's often faster and less error-prone than writing each member separately.
I was just pattern matching on the other use cases. I'll take a look at the siginfo copy helpers, thanks!
Signature · 1 line
Jens Axboe
Re: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 28 lines · Jens Axboe
Quoted 21 lines · Arnd Bergmann
Quoted 12 lines · Christian Brauner
Quoted 11 lines · Jens Axboe
Quoted 8 lines
Quoted 4 lines
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.Quoted 5 lines
We could add a
copy_siginfo_to_user_any(), but I think open-coding it is easier here, since thein_compat_syscall()check does not work inside of theio_uringkernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.
Quoted 5 lines
Yeah, unifying this stuff did cross my mind when adding another one. Which I think could still be done, you'd just need to pass in a 'compat' parameter similar to how it's done for iovec importing.
But if it's ok with everybody I'd rather do that as a cleanup post this.
Sure, keeping that separate seem best.
Looking at what copy_siginfo_from_user_any() actually does, I don't even think it's worth adapting copy_siginfo_to_user_any() for io_uring, since it's already just a trivial wrapper, and adding another argument would add more complexity overall than it saves.
Arnd
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 33 lines · Arnd Bergmann
Quoted 32 lines · Jens Axboe
Quoted 21 lines · Arnd Bergmann
Quoted 12 lines · Christian Brauner
Quoted 11 lines · Jens Axboe
Quoted 8 lines
Quoted 4 lines
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.Quoted 5 lines
We could add a
copy_siginfo_to_user_any(), but I think open-coding it is easier here, since thein_compat_syscall()check does not work inside of theio_uringkernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.Yeah, unifying this stuff did cross my mind when adding another one. Which I think could still be done, you'd just need to pass in a 'compat' parameter similar to how it's done for iovec importing.
Quoted 8 lines
Quoted 1 line
But if it's ok with everybody I'd rather do that as a cleanup post this.
Sure, keeping that separate seem best.
Looking at what
copy_siginfo_from_user_any()actually does, I don't even think it's worth adaptingcopy_siginfo_to_user_any()forio_uring, since it's already just a trivial wrapper, and adding another argument would add more complexity overall than it saves.
Yeah, took a look too this morning, and not sure there's much to reduce here that would make it cleaner. I'm going to send out a v2 with this unchanged, holler if people disagree.
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
Quoted 38 lines · Jens Axboe
Quoted 37 lines · Arnd Bergmann
Quoted 28 lines · Jens Axboe
Quoted 21 lines · Arnd Bergmann
Quoted 12 lines · Christian Brauner
Quoted 11 lines · Jens Axboe
Quoted 8 lines
Quoted 4 lines
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.Quoted 5 lines
We could add a
copy_siginfo_to_user_any(), but I think open-coding it is easier here, since thein_compat_syscall()check does not work inside of theio_uringkernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.Quoted 5 lines
Yeah, unifying this stuff did cross my mind when adding another one. Which I think could still be done, you'd just need to pass in a 'compat' parameter similar to how it's done for iovec importing.
But if it's ok with everybody I'd rather do that as a cleanup post this.
Sure, keeping that separate seem best.
Quoted 8 lines
Quoted 4 lines
Looking at what
copy_siginfo_from_user_any()actually does, I don't even think it's worth adaptingcopy_siginfo_to_user_any()forio_uring, since it's already just a trivial wrapper, and adding another argument would add more complexity overall than it saves.Yeah, took a look too this morning, and not sure there's much to reduce here that would make it cleaner. I'm going to send out a v2 with this unchanged, holler if people disagree.
Looking over changes, none have been made so far. So I guess a v2 can wait a bit. The branch was rebased to add Christian's acked-bys for some of the patches, and since a branch it was based on (io_uring-futex) got rebased to accommodate PeterZ's changes.
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerRe: [PATCH 5/5] io_uring: add IORING_OP_WAITID support
In reply to Jens AxboeQuoted 38 lines · Jens Axboe
Quoted 37 lines · Arnd Bergmann
Quoted 28 lines · Jens Axboe
Quoted 21 lines · Arnd Bergmann
Quoted 12 lines · Christian Brauner
Quoted 11 lines · Jens Axboe
Quoted 8 lines
Quoted 4 lines
Does this require argument conversion for compat tasks?
Even without the rusage argument, I think the siginfo remains incompatible with 32-bit tasks, unfortunately.
Hmm yes good point, if
compat_siginfoand siginfo are different, then it does need handling for that. Would be a trivial addition, I'll make that change. Thanks Arnd!Should be fixed in the current version:
Quoted 7 lines
Quoted 1 line
In
kernel/signal.cinpidfd_send_signal()we havecopy_siginfo_from_user_any()it seems that a similar versioncopy_siginfo_to_user_any()might be something to consider. We do havecopy_siginfo_to_user32()andcopy_siginfo_to_user(). But I may lack context why this wouldn't work here.Quoted 5 lines
We could add a
copy_siginfo_to_user_any(), but I think open-coding it is easier here, since thein_compat_syscall()check does not work inside of theio_uringkernel thread, it has to be "if (req->ctx->compat)" in order to match the wordsize of the task that started the request.Quoted 5 lines
Yeah, unifying this stuff did cross my mind when adding another one. Which I think could still be done, you'd just need to pass in a 'compat' parameter similar to how it's done for iovec importing.
But if it's ok with everybody I'd rather do that as a cleanup post this.
Sure, keeping that separate seem best.
Quoted 8 lines
Quoted 4 lines
Looking at what
copy_siginfo_from_user_any()actually does, I don't even think it's worth adaptingcopy_siginfo_to_user_any()forio_uring, since it's already just a trivial wrapper, and adding another argument would add more complexity overall than it saves.Yeah, took a look too this morning, and not sure there's much to reduce here that would make it cleaner. I'm going to send out a v2 with this unchanged, holler if people disagree.
One thing we could do is the below, but honestly not sure it's worth the hassle?
io_uring/waitid.c +3 -20
@@ -43,6 +43,8 @@ static bool io_waitid_compat_copy_si(struct io_waitid *iw, int signo)bool ret; infop = (struct compat_siginfo __user *) iw->infop; +if (!infop) +return true;if (!user_write_access_begin (infop,sizeof (*infop)))return false;
@@ -66,32 +68,13 @@ static bool io_waitid_compat_copy_si(struct io_waitid *iw, int signo)static bool io_waitid_copy_si (struct io_kiocb *req,int signo) { struct io_waitid *iw = io_kiocb_to_cmd(req, struct io_waitid); -bool ret; - -if (!iw->infop) -return true;#ifdef CONFIG_COMPAT if (req->ctx->compat)return io_waitid_compat_copy_si (iw, signo);#endif -if (!user_write_access_begin (iw->infop,sizeof (*iw->infop))) -return false; - -unsafe_put_user (signo, &iw->infop->si_signo, Efault); -unsafe_put_user (0 , &iw->infop->si_errno, Efault); -unsafe_put_user (iw->info.cause, &iw->infop->si_code, Efault); -unsafe_put_user (iw->info.pid, &iw->infop->si_pid, Efault); -unsafe_put_user (iw->info.uid, &iw->infop->si_uid, Efault); -unsafe_put_user (iw->info.status, &iw->infop->si_status, Efault); - ret = true; -done: -user_write_access_end (); -return ret; -Efault: - ret = false; - goto done; +return siginfo_put_user (iw->infop, &iw->info, signo); }static int io_waitid_finish (struct io_kiocb *req,int ret)
kernel/exit.c +23 -15
@@ -1723,6 +1723,28 @@ static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop,return ret; } +bool siginfo_put_user (struct siginfo __user *infop,struct waitid_info *wi, +int signo) +{ +if (!infop) +return true; + +if (!user_write_access_begin (infop,sizeof (*infop))) +return false; + +unsafe_put_user (signo, &infop->si_signo, Efault); +unsafe_put_user (0 , &infop->si_errno, Efault); +unsafe_put_user (wi->cause, &infop->si_code, Efault); +unsafe_put_user (wi->pid, &infop->si_pid, Efault); +unsafe_put_user (wi->uid, &infop->si_uid, Efault); +unsafe_put_user (wi->status, &infop->si_status, Efault); +user_write_access_end (); +return true; +Efault: +user_write_access_end (); +return false; +} + SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *, infop, int, options, struct rusage __user *, ru) {
@@ -1737,23 +1759,9 @@ SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,if (ru &©_to_user (ru, &r,sizeof (struct rusage )))return -EFAULT ; } -if (!infop) -return err; - -if (!user_write_access_begin (infop,sizeof (*infop))) +if (siginfo_put_user (infop, &info, signo))return -EFAULT ; - -unsafe_put_user (signo, &infop->si_signo, Efault); -unsafe_put_user (0 , &infop->si_errno, Efault); -unsafe_put_user (info.cause, &infop->si_code, Efault); -unsafe_put_user (info.pid, &infop->si_pid, Efault); -unsafe_put_user (info.uid, &infop->si_uid, Efault); -unsafe_put_user (info.status, &infop->si_status, Efault); -user_write_access_end ();return err; -Efault: -user_write_access_end (); -return -EFAULT ; } long kernel_wait4(pid_t upid, int __user *stat_addr, int options,
kernel/exit.h +2 -0
@@ -27,4 +27,6 @@ long __do_wait(struct wait_opts *wo);int kernel_waitid_prepare (struct wait_opts *wo,int which,pid_t upid,struct waitid_info *infop,int options,struct rusage *ru,unsigned int *f_flags); +bool siginfo_put_user (struct siginfo __user *infop,struct waitid_info *wi, +int signo);#endif
Signature · 1 line
Jens Axboe