Add support for multishot reads
Jens Axboe
maintainerv2 cover Add support for multishot reads
Hi,
We support multishot for other request types, generally in the shape of a flag for the request. Doing a flag based approach with reads isn't straightforward, as the read/write flags are in the RWF_ space. Instead, add a separate opcode for this, IORING_OP_READ_MULTISHOT.
This can only be used provided buffers, like other multishot request types that read/receive data.
It can also only be used for pollable file types, like a tun device or pipes, for example. File types that are always readable (or seekable), like regular files, cannot be used with multishot reads.
This is based on the io_uring-futex branch (which, in turn, is based on the io_uring-waitid branch). No dependencies as such between them, except the opcode numbering.
Can also be found here:
https://git.kernel.dk/cgit/linux/log/?h=io_uring-mshot-read
and there's a liburing branch with some basic support and some test cases here:
https://git.kernel.dk/cgit/liburing/log/?h=read-mshot
include/uapi/linux/io_uring.h | 1 + io_uring/opdef.c | 14 ++++++ io_uring/opdef.h | 2 + io_uring/rw.c | 92 ++++++++++++++++++++++++++++++++--- io_uring/rw.h | 2 + 5 files changed, 105 insertions(+), 6 deletions(-)
Changes since v1:
- Code reformatting
- Add/expand a few comments
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerPATCH v2 1/3 io_uring/rw: split io_read() into a helper
Add __io_read() which does the grunt of the work, leaving the completion side to the new io_read(). No functional changes in this patch.
--- io_uring/rw.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
io_uring/rw.c +12 -1
@@ -708,7 +708,7 @@ static int io_rw_init_file(struct io_kiocb *req, fmode_t mode)return 0 ; } -int io_read (struct io_kiocb *req,unsigned int issue_flags) +static int __io_read (struct io_kiocb *req,unsigned int issue_flags) { struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);struct io_rw_state __s, *s = &__s;
@@ -853,6 +853,17 @@ int io_read(struct io_kiocb *req, unsigned int issue_flags)/* it's faster to check here then delegate to kfree */ if (iovec)kfree (iovec); +return ret; +} + +int io_read (struct io_kiocb *req,unsigned int issue_flags) +{ +int ret; + + ret =__io_read (req, issue_flags); +if (unlikely (ret <0 )) +return ret; +return kiocb_done (req, ret, issue_flags); }
Signature · 1 line
2.40.1
Jens Axboe
maintainerPATCH v2 2/3 io_uring/rw: mark readv/writev as vectored in the opcode definition
In reply to Jens AxboeThis is cleaner than gating on the opcode type, particularly as more read/write type opcodes may be added.
Then we can use that for the data import, and for __io_read() on whether or not we need to copy state.
--- io_uring/opdef.c | 2 ++ io_uring/opdef.h | 2 ++ io_uring/rw.c | 10 ++++++---- 3 files changed, 10 insertions(+), 4 deletions(-)
io_uring/opdef.c +2 -0
@@ -65,6 +65,7 @@ const struct io_issue_def io_issue_defs[] = { .ioprio = 1, .iopoll = 1, .iopoll_queue = 1, + .vectored = 1, .prep = io_prep_rw, .issue = io_read, },
@@ -78,6 +79,7 @@ const struct io_issue_def io_issue_defs[] = { .ioprio = 1, .iopoll = 1, .iopoll_queue = 1, + .vectored = 1, .prep = io_prep_rw, .issue = io_write, },
io_uring/opdef.h +2 -0
@@ -29,6 +29,8 @@ struct io_issue_def { unsigned iopoll_queue : 1;/* opcode specific path will handle ->async_data allocation if needed */ unsigned manual_alloc : 1; +/* vectored opcode, set if 1) vectored, and 2) handler needs to know */ + unsigned vectored : 1;int (*issue)(struct io_kiocb *,unsigned int );int (*prep)(struct io_kiocb *,const struct io_uring_sqe *);
io_uring/rw.c +6 -4
@@ -388,8 +388,7 @@ static struct iovec *__io_import_iovec(int ddir, struct io_kiocb *req, buf =u64_to_user_ptr (rw->addr); sqe_len = rw->len; -if (opcode ==IORING_OP_READ || opcode ==IORING_OP_WRITE || - (req->flags &REQ_F_BUFFER_SELECT )) { +if (!io_issue_defs[opcode].vectored || req->flags &REQ_F_BUFFER_SELECT ) {if (io_do_buffer_select (req)) { buf =io_buffer_select (req, &sqe_len, issue_flags);if (!buf)
@@ -776,8 +775,11 @@ static int __io_read(struct io_kiocb *req, unsigned int issue_flags)if (ret == -EAGAIN || (req->flags &REQ_F_REISSUE )) { req->flags &= ~REQ_F_REISSUE ; -/* if we can poll, just do that */ -if (req->opcode ==IORING_OP_READ &&file_can_poll (req->file)) +/* +* If we can poll, just do that. For a vectored read, we'll +* need to copy state first. +*/ +if (file_can_poll (req->file) && !io_issue_defs[req->opcode].vectored)return -EAGAIN ;/* IOPOLL retry should happen for io-wq threads */ if (!force_nonblock && !(req->ctx->flags &IORING_SETUP_IOPOLL ))
Signature · 1 line
2.40.1
Jens Axboe
maintainerPATCH v2 3/3 io_uring/rw: add support for IORING_OP_READ_MULTISHOT
In reply to Jens AxboeThis behaves like IORING_OP_READ, except:
1) It only supports pollable files (eg pipes, sockets, etc). Note that for sockets, you probably want to use recv/recvmsg with multishot instead.
2) It supports multishot mode, meaning it will repeatedly trigger a read and fill a buffer when data is available. This allows similar use to recv/recvmsg but on non-sockets, where a single request will repeatedly post a CQE whenever data is read from it.
3) Because of #2, it must be used with provided buffers. This is uniformly true across any request type that supports multishot and transfers data, with the reason being that it's obviously not possible to pass in a single buffer for the data, as multiple reads may very well trigger before an application has a chance to process previous CQEs and the data passed from them.
--- include/uapi/linux/io_uring.h | 1 + io_uring/opdef.c | 12 ++++++ io_uring/rw.c | 73 +++++++++++++++++++++++++++++++++-- io_uring/rw.h | 2 + 4 files changed, 85 insertions(+), 3 deletions(-)
include/uapi/linux/io_uring.h +1 -0
@@ -246,6 +246,7 @@ enum io_uring_op {IORING_OP_FUTEX_WAIT ,IORING_OP_FUTEX_WAKE ,IORING_OP_FUTEX_WAITV , +IORING_OP_READ_MULTISHOT ,/* this goes last, obviously */ IORING_OP_LAST,
io_uring/opdef.c +12 -0
@@ -460,6 +460,15 @@ const struct io_issue_def io_issue_defs[] = { .prep = io_eopnotsupp_prep, #endif }, + [IORING_OP_READ_MULTISHOT ] = { + .needs_file =1 , + .unbound_nonreg_file =1 , + .pollin =1 , + .buffer_select =1 , + .audit_skip =1 , + .prep = io_read_mshot_prep, + .issue = io_read_mshot, + }, };const struct io_cold_def io_cold_defs[] = {
@@ -692,6 +701,9 @@ const struct io_cold_def io_cold_defs[] = { [IORING_OP_FUTEX_WAITV ] = { .name ="FUTEX_WAITV" , }, + [IORING_OP_READ_MULTISHOT ] = { + .name ="READ_MULTISHOT" , + }, };const char *io_uring_get_opcode (u8 opcode)
io_uring/rw.c +70 -3
86 lines not on this page · raw message
io_uring/rw.h +2 -0
@@ -23,3 +23,5 @@ int io_writev_prep_async(struct io_kiocb *req);void io_readv_writev_cleanup (struct io_kiocb *req);void io_rw_fail (struct io_kiocb *req);void io_req_rw_complete (struct io_kiocb *req,struct io_tw_state *ts); +int io_read_mshot_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe); +int io_read_mshot (struct io_kiocb *req,unsigned int issue_flags);
Signature · 1 line
2.40.1
Jens Axboe
maintainerRe: [PATCH 3/3] io_uring/rw: add support for IORING_OP_READ_MULTISHOT
io_uring/rw.c int io_read(struct io_kiocb *req, unsigned int issue_flags) · line 886
Quoted 11 lines · Jens Axboe
io_uring/rw.c +5
-2@@ -863,10 +879,61 @@ int io_read(struct io_kiocb *req, unsigned int issue_flags)int ret; ret =__io_read (req, issue_flags); -if (unlikely (ret <0 )) -return ret; +if (ret >=0 ) +return kiocb_done (req, ret, issue_flags); + +return ret; +}
Looks like this one got folded into the wrong patch, this belongs with patch 1 of course. The current git tree is correct, patch 1 does it this way and patch 3 doesn't touch it.
Signature · 1 line
Jens Axboe
Quoted 18 lines · Jens Axboe
Hi,
We support multishot for other request types, generally in the shape of a flag for the request. Doing a flag based approach with reads isn't straightforward, as the read/write flags are in the
RWF_space. Instead, add a separate opcode for this,IORING_OP_READ_MULTISHOT.This can only be used provided buffers, like other multishot request types that read/receive data.
It can also only be used for pollable file types, like a tun device or pipes, for example. File types that are always readable (or seekable), like regular files, cannot be used with multishot reads.
This is based on the io_uring-futex branch (which, in turn, is based on the io_uring-waitid branch). No dependencies as such between them, except the opcode numbering.
Quoted 8 lines
Can also be found here:
https://git.kernel.dk/cgit/linux/log/?h=io_uring-mshot-read
and there's a liburing branch with some basic support and some test cases here:
Hey Jens,
For the entire series, feel free to take:
Signature · 1 line
Gabriel Krisman Bertazi
Jens Axboe
maintainerQuoted 27 lines · Gabriel Krisman Bertazi
Quoted 25 lines · Jens Axboe
Hi,
We support multishot for other request types, generally in the shape of a flag for the request. Doing a flag based approach with reads isn't straightforward, as the read/write flags are in the
RWF_space. Instead, add a separate opcode for this,IORING_OP_READ_MULTISHOT.This can only be used provided buffers, like other multishot request types that read/receive data.
It can also only be used for pollable file types, like a tun device or pipes, for example. File types that are always readable (or seekable), like regular files, cannot be used with multishot reads.
This is based on the io_uring-futex branch (which, in turn, is based on the io_uring-waitid branch). No dependencies as such between them, except the opcode numbering.
Can also be found here:
https://git.kernel.dk/cgit/linux/log/?h=io_uring-mshot-read
and there's a liburing branch with some basic support and some test cases here:
Quoted 7 lines
Hey Jens,
For the entire series, feel free to take:
Reviewed-by Gabriel Krisman Bertazi <[email protected]>
Thanks, added!
Signature · 1 line
Jens Axboe