btrfs: fix reading from userspace in btrfs_uring_encoded_read()
Subsystems (2)
v4 cover btrfs: fix reading from userspace in btrfs_uring_encoded_read()
Version 4 of mine and Jens' patches, to make sure that when our io_uring function gets called a second time, it doesn't accidentally read something from userspace that's gone out of scope or otherwise gotten corrupted.
I sent a version 3 on December 17, but it looks like that got forgotten about over Christmas (unsurprisingly). Version 4 fixes a problem that I noticed, namely that we weren't taking a copy of the iovs, which also necessitated creating a struct to store these things in. This does simplify things by removing the need for the kmemdup, however.
I also have a patch for io_uring encoded writes ready to go, but it's waiting on some of the stuff introduced here.
Jens Axboe (2):
io_uring/cmd: rename struct uring_cache to io_uring_cmd_data io_uring/cmd: add per-op data to struct io_uring_cmd_data
Mark Harmstone (2):
io_uring: add io_uring_cmd_get_async_data helper
btrfs: don't read from userspace twice in btrfs_uring_encoded_read()
fs/btrfs/ioctl.c | 125 +++++++++++++++++++---------------- include/linux/io_uring/cmd.h | 10 +++ io_uring/io_uring.c | 2 +- io_uring/opdef.c | 3 +- io_uring/uring_cmd.c | 23 +++++-- io_uring/uring_cmd.h | 4 -- 6 files changed, 97 insertions(+), 70 deletions(-)
Signature · 1 line
2.45.2
PATCH v4 1/4 io_uring/cmd: rename struct uring_cache to io_uring_cmd_data
From: Jens Axboe <[email protected]>
In preparation for making this more generically available for ->uring_cmd() usage that needs stable command data, rename it and move it to io_uring/cmd.h instead.
--- include/linux/io_uring/cmd.h | 4 ++++ io_uring/io_uring.c | 2 +- io_uring/opdef.c | 3 ++- io_uring/uring_cmd.c | 10 +++++----- io_uring/uring_cmd.h | 4 ---- 5 files changed, 12 insertions(+), 11 deletions(-)
include/linux/io_uring/cmd.h +4 -0
@@ -18,6 +18,10 @@ struct io_uring_cmd {u8 pdu[32 ];/* available inline for free use */ }; +struct io_uring_cmd_data { +struct io_uring_sqe sqes[2 ]; +}; +static inline const void *io_uring_sqe_cmd (const struct io_uring_sqe *sqe) {return sqe->cmd;
io_uring/io_uring.c +1 -1
@@ -320,7 +320,7 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p) ret |=io_alloc_cache_init (&ctx->rw_cache,IO_ALLOC_CACHE_MAX ,sizeof (struct io_async_rw )); ret |=io_alloc_cache_init (&ctx->uring_cache,IO_ALLOC_CACHE_MAX , -sizeof (struct uring_cache )); +sizeof (struct io_uring_cmd_data ));spin_lock_init (&ctx->msg_lock); ret |=io_alloc_cache_init (&ctx->msg_cache,IO_ALLOC_CACHE_MAX ,sizeof (struct io_kiocb ));
io_uring/opdef.c +2 -1
@@ -7,6 +7,7 @@#include <linux/fs.h> #include <linux/file.h> #include <linux/io_uring.h> +#include <linux/io_uring/cmd.h> #include "io_uring.h" #include "opdef.h"
@@ -414,7 +415,7 @@ const struct io_issue_def io_issue_defs[] = { .plug = 1, .iopoll = 1, .iopoll_queue = 1, - .async_size = 2 * sizeof(struct io_uring_sqe), + .async_size = sizeof(struct io_uring_cmd_data), .prep = io_uring_cmd_prep, .issue = io_uring_cmd, },
io_uring/uring_cmd.c +5 -5
@@ -16,10 +16,10 @@#include "rsrc.h" #include "uring_cmd.h" -static struct uring_cache *io_uring_async_get (struct io_kiocb *req) +static struct io_uring_cmd_data *io_uring_async_get (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx; -struct uring_cache *cache; +struct io_uring_cmd_data *cache; cache =io_alloc_cache_get (&ctx->uring_cache);if (cache) {
@@ -35,7 +35,7 @@ static struct uring_cache *io_uring_async_get(struct io_kiocb *req)static void io_req_uring_cleanup (struct io_kiocb *req,unsigned int issue_flags) { struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd); -struct uring_cache *cache = req->async_data; +struct io_uring_cmd_data *cache = req->async_data;if (issue_flags &IO_URING_F_UNLOCKED )return ;
@@ -183,7 +183,7 @@ static int io_uring_cmd_prep_setup(struct io_kiocb *req, const struct io_uring_sqe *sqe) { struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd); -struct uring_cache *cache; +struct io_uring_cmd_data *cache; cache =io_uring_async_get (req);if (unlikely (!cache))
@@ -260,7 +260,7 @@ int io_uring_cmd(struct io_kiocb *req, unsigned int issue_flags) ret = file->f_op->uring_cmd (ioucmd, issue_flags);if (ret == -EAGAIN ) { -struct uring_cache *cache = req->async_data; +struct io_uring_cmd_data *cache = req->async_data;if (ioucmd->sqe != (void *) cache)memcpy (cache, ioucmd->sqe,uring_sqe_size (req->ctx));
io_uring/uring_cmd.h +0 -4
@@ -1,9 +1,5 @@// SPDX-License-Identifier: GPL-2.0 -struct uring_cache { -struct io_uring_sqe sqes[2 ]; -}; -int io_uring_cmd (struct io_kiocb *req,unsigned int issue_flags);int io_uring_cmd_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe);
Signature · 1 line
2.45.2
PATCH v4 2/4 io_uring/cmd: add per-op data to struct io_uring_cmd_data
In reply to Mark HarmstoneFrom: Jens Axboe <[email protected]>
In case an op handler for ->uring_cmd() needs stable storage for user data, it can allocate io_uring_cmd_data->op_data and use it for the duration of the request. When the request gets cleaned up, uring_cmd will free it automatically.
--- include/linux/io_uring/cmd.h | 1 + io_uring/uring_cmd.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)
include/linux/io_uring/cmd.h +1 -0
@@ -20,6 +20,7 @@ struct io_uring_cmd {struct io_uring_cmd_data {struct io_uring_sqe sqes[2 ]; +void *op_data; };static inline const void *io_uring_sqe_cmd (const struct io_uring_sqe *sqe)
io_uring/uring_cmd.c +11 -2
@@ -23,12 +23,16 @@ static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req) cache =io_alloc_cache_get (&ctx->uring_cache);if (cache) { + cache->op_data =NULL ; req->flags |=REQ_F_ASYNC_DATA ; req->async_data = cache;return cache; } -if (!io_alloc_async_data (req)) -return req->async_data; +if (!io_alloc_async_data (req)) { + cache = req->async_data; + cache->op_data =NULL ; +return cache; + }return NULL ; }
@@ -37,6 +41,11 @@ static void io_req_uring_cleanup(struct io_kiocb *req, unsigned int issue_flags) struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);struct io_uring_cmd_data *cache = req->async_data; +if (cache->op_data) { +kfree (cache->op_data); + cache->op_data =NULL ; + } +if (issue_flags &IO_URING_F_UNLOCKED )return ;if (io_alloc_cache_put (&req->ctx->uring_cache, cache)) {
Signature · 1 line
2.45.2
RE: [PATCH 2/4] io_uring/cmd: add per-op data to struct io_uring_cmd_data
Hi,
Quoted 38 lines
-----Original Message-----
From: Mark Harmstone <[email protected]>
Sent: Friday, January 3, 2025 11:02 PM
To: [email protected]; [email protected]
Cc: Jens Axboe <[email protected]>
Subject: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataFrom: Jens Axboe <[email protected]>
In case an op handler for ->uring_cmd() needs stable storage for user data, it can allocate
io_uring_cmd_data->op_dataand use it for the duration of the request. When the request gets cleaned up,uring_cmdwill free it automatically.Signed-off-by Jens Axboe <[email protected]>--- include/linux/io_uring/cmd.h | 1 + io_uring/uring_cmd.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)include/linux/io_uring/cmd.h index renamed from include/linux/io_uring/cmd.h +0
-0
61f97a398e9d..a65c7043078f100644include/linux/io_uring/cmd.h +1
-1@@ -20,6 +20,7 @@ struct io_uring_cmd {struct io_uring_cmd_data {struct io_uring_sqe sqes[2 ]; +void *op_data; };static inline const void *io_uring_sqe_cmd (const struct io_uring_sqe *sqe) diff --git a/io_uring/uring_cmd.c b/io_uring/uring_cmd.c index
629cb4266da6..ce7726a04883100644
io_uring/uring_cmd.c static struct io_uring_cmd_data · line 27
Quoted 5 lines
io_uring/uring_cmd.c +1
-0@@ -23,12 +23,16 @@ static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req) cache = io_alloc_cache_get(&ctx->uring_cache);if (cache) { + cache->op_data =NULL ;
Why is op_data set to NULL here? If you are worried about some omissions, would it be better to use WARN_ON to assert that op_data is a null pointer? This will also make it easier to analyze the cause of the problem.
---
Li Zetao
Jens Axboe
maintainerRe: [PATCH 2/4] io_uring/cmd: add per-op data to struct io_uring_cmd_data
Quoted 42 lines · lizetao
Hi,
Quoted 40 lines
-----Original Message-----
From: Mark Harmstone <[email protected]>
Sent: Friday, January 3, 2025 11:02 PM
To: [email protected]; [email protected]
Cc: Jens Axboe <[email protected]>
Subject: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataFrom: Jens Axboe <[email protected]>
In case an op handler for ->uring_cmd() needs stable storage for user data, it can allocate
io_uring_cmd_data->op_dataand use it for the duration of the request. When the request gets cleaned up,uring_cmdwill free it automatically.Signed-off-by Jens Axboe <[email protected]>--- include/linux/io_uring/cmd.h | 1 + io_uring/uring_cmd.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)include/linux/io_uring/cmd.h index renamed from include/linux/io_uring/cmd.h +0
-0
61f97a398e9d..a65c7043078f100644include/linux/io_uring/cmd.h +1
-1@@ -20,6 +20,7 @@ struct io_uring_cmd {struct io_uring_cmd_data {struct io_uring_sqe sqes[2 ]; +void *op_data; };static inline const void *io_uring_sqe_cmd (const struct io_uring_sqe *sqe) diff --git a/io_uring/uring_cmd.c b/io_uring/uring_cmd.c index
629cb4266da6..ce7726a04883100644io_uring/uring_cmd.c +0
-0@@ -23,12 +23,16 @@ static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req)
Quoted 8 lines
io_uring/uring_cmd.c static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req) · line 26
Quoted 3 lines
io_uring/uring_cmd.c +1
-0cache =io_alloc_cache_get (&ctx->uring_cache);if (cache) { + cache->op_data =NULL ;Why is
op_dataset to NULL here? If you are worried about some omissions, would it be better to useWARN_ONto assert thatop_datais a null pointer? This will also make it easier to analyze the cause of the problem.
Clearing the per-op data is prudent when allocating getting this struct, to avoid previous garbage. The alternative would be clearing it when it's freed, either way is fine imho. A WARN_ON would not make sense, as it can validly be non-NULL already.
Signature · 1 line
Jens Axboe
RE: [PATCH 2/4] io_uring/cmd: add per-op data to struct io_uring_cmd_data
Hi,
Quoted 61 lines
-----Original Message-----
From: Jens Axboe <[email protected]>
Sent: Monday, January 6, 2025 10:46 PM
To: lizetao <[email protected]>; Mark Harmstone <[email protected]>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataQuoted 43 lines · lizetao
Hi,
Quoted 41 lines
-----Original Message-----
From: Mark Harmstone <[email protected]>
Sent: Friday, January 3, 2025 11:02 PM
To: [email protected]; [email protected]
Cc: Jens Axboe <[email protected]>
Subject: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataFrom: Jens Axboe <[email protected]>
In case an op handler for ->uring_cmd() needs stable storage for user data, it can allocate
io_uring_cmd_data->op_dataand use it for the duration of the request. When the request gets cleaned up,uring_cmdwill free it automatically.Signed-off-by Jens Axboe <[email protected]>--- include/linux/io_uring/cmd.h | 1 + io_uring/uring_cmd.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)(quoted diff) +0
-0
b/include/linux/io_uring/cmd.hindex61f97a398e9d..a65c7043078f100644include/linux/io_uring/cmd.h +1
-0@@ -20,6 +20,7 @@ struct io_uring_cmd {struct io_uring_cmd_data {struct io_uring_sqe sqes[2 ]; +void *op_data; }; static inline const void *io_uring_sqe_cmd(const struct io_uring_sqe*sqe) diff --git
a/io_uring/uring_cmd.cb/io_uring/uring_cmd.cindex629cb4266da6..ce7726a04883100644io_uring/uring_cmd.c +0
-0@@ -23,12 +23,16 @@ static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req)Quoted 8 lines
io_uring/uring_cmd.c static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req) · line 26
Quoted 3 lines
io_uring/uring_cmd.c +1
-0cache =io_alloc_cache_get (&ctx->uring_cache);if (cache) { + cache->op_data =NULL ;Why is
op_dataset to NULL here? If you are worried about some omissions, would it be better to useWARN_ONto assert thatop_datais a null pointer? This will also make it easier to analyze the cause of the problem.
Quoted 4 lines
Clearing the per-op data is prudent when allocating getting this struct, to avoid previous garbage. The alternative would be clearing it when it's freed, either way is fine imho. A
WARN_ONwould not make sense, as it can validly be non- NULL already.
I still can't fully understand, the usage logic of op_data should be as follows:
When applying for and initializing the cache, op_data has been set to NULL. In io_req_uring_cleanup, the op_data memory will be released and set to NULL. So if the cache in uring_cache, its op_data should be NULL? If it is non-NULL, is there a risk of memory leak if it is directly set to null?
Quoted 3 lines
--
Jens Axboe
---
Li Zetao
Jens Axboe
maintainerRe: [PATCH 2/4] io_uring/cmd: add per-op data to struct io_uring_cmd_data
Quoted 68 lines · lizetao
Hi,
Quoted 61 lines
-----Original Message-----
From: Jens Axboe <[email protected]>
Sent: Monday, January 6, 2025 10:46 PM
To: lizetao <[email protected]>; Mark Harmstone <[email protected]>
Cc: [email protected]; [email protected]
Subject: Re: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataQuoted 43 lines · lizetao
Hi,
Quoted 41 lines
-----Original Message-----
From: Mark Harmstone <[email protected]>
Sent: Friday, January 3, 2025 11:02 PM
To: [email protected]; [email protected]
Cc: Jens Axboe <[email protected]>
Subject: [PATCH 2/4]io_uring/cmd: add per-op data to structio_uring_cmd_dataFrom: Jens Axboe <[email protected]>
In case an op handler for ->uring_cmd() needs stable storage for user data, it can allocate
io_uring_cmd_data->op_dataand use it for the duration of the request. When the request gets cleaned up,uring_cmdwill free it automatically.Signed-off-by Jens Axboe <[email protected]>--- include/linux/io_uring/cmd.h | 1 + io_uring/uring_cmd.c | 13 +++++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)(quoted diff) +0
-0
b/include/linux/io_uring/cmd.hindex61f97a398e9d..a65c7043078f100644include/linux/io_uring/cmd.h +1
-0@@ -20,6 +20,7 @@ struct io_uring_cmd {struct io_uring_cmd_data {struct io_uring_sqe sqes[2 ]; +void *op_data; }; static inline const void *io_uring_sqe_cmd(const struct io_uring_sqe*sqe) diff --git
a/io_uring/uring_cmd.cb/io_uring/uring_cmd.cindex629cb4266da6..ce7726a04883100644io_uring/uring_cmd.c +0
-0@@ -23,12 +23,16 @@ static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req)Quoted 8 lines
io_uring/uring_cmd.c static struct io_uring_cmd_data *io_uring_async_get(struct io_kiocb *req) · line 26
Quoted 3 lines
io_uring/uring_cmd.c +1
-0cache =io_alloc_cache_get (&ctx->uring_cache);if (cache) { + cache->op_data =NULL ;Why is
op_dataset to NULL here? If you are worried about some omissions, would it be better to useWARN_ONto assert thatop_datais a null pointer? This will also make it easier to analyze the cause of the problem.Quoted 4 lines
Clearing the per-op data is prudent when allocating getting this struct, to avoid previous garbage. The alternative would be clearing it when it's freed, either way is fine imho. A
WARN_ONwould not make sense, as it can validly be non- NULL already.
Quoted 6 lines
I still can't fully understand, the usage logic of
op_datashould be as follows: When applying for and initializing the cache,op_datahas been set to NULL. Inio_req_uring_cleanup, theop_datamemory will be released and set to NULL. So if the cache inuring_cache, itsop_datashould be NULL? If it is non-NULL, is there a risk of memory leak if it is directly set to null?
Ah forgot I did clear it for freeing. So yes, this NULL setting on the alloc side is redundant. But let's just leave it for now, once this gets merged with the alloc cache cleanups that are pending for 6.14, it'll go away anyway.
Signature · 1 line
Jens Axboe
PATCH v4 3/4 io_uring: add io_uring_cmd_get_async_data helper
In reply to Mark HarmstoneAdd a helper function in include/linux/io_uring/cmd.h to read the async_data pointer from a struct io_uring_cmd.
--- include/linux/io_uring/cmd.h | 5 +++++ 1 file changed, 5 insertions(+)
include/linux/io_uring/cmd.h +5 -0
@@ -118,4 +118,9 @@ static inline struct task_struct *io_uring_cmd_get_task(struct io_uring_cmd *cmd return cmd_to_io_kiocb(cmd)->tctx->task; } +static inline struct io_uring_cmd_data *io_uring_cmd_get_async_data (struct io_uring_cmd *cmd) +{ +return cmd_to_io_kiocb (cmd)->async_data; +} +#endif /* _LINUX_IO_URING_CMD_H */
Signature · 1 line
2.45.2
PATCH v4 4/4 btrfs: don't read from userspace twice in btrfs_uring_encoded_read()
In reply to Mark HarmstoneIf we return -EAGAIN the first time because we need to block, btrfs_uring_encoded_read() will get called twice. Take a copy of args, the iovs, and the iter the first time, as by the time we are called the second time these may have gone out of scope.
--- fs/btrfs/ioctl.c | 125 ++++++++++++++++++++++++++--------------------- 1 file changed, 68 insertions(+), 57 deletions(-)
fs/btrfs/ioctl.c +68 -57
@@ -4787,25 +4787,29 @@ static int btrfs_uring_read_extent(struct kiocb *iocb, struct iov_iter *iter,return ret; } +struct btrfs_uring_encoded_data { +struct btrfs_ioctl_encoded_io_args args; +struct iovec iovstack[UIO_FASTIOV ]; +struct iovec *iov; +struct iov_iter iter; +}; +static int btrfs_uring_encoded_read (struct io_uring_cmd *cmd,unsigned int issue_flags) { size_t copy_end_kernel = offsetofend(struct btrfs_ioctl_encoded_io_args, flags);size_t copy_end; -struct btrfs_ioctl_encoded_io_args args = {0 };int ret;u64 disk_bytenr, disk_io_size;struct file *file;struct btrfs_inode *inode;struct btrfs_fs_info *fs_info;struct extent_io_tree *io_tree; -struct iovec iovstack[UIO_FASTIOV ]; -struct iovec *iov = iovstack; -struct iov_iter iter;loff_t pos;struct kiocb kiocb;struct extent_state *cached_state =NULL ;u64 start, lockend;void __user *sqe_addr; +struct btrfs_uring_encoded_data *data =io_uring_cmd_get_async_data (cmd)->op_data;if (!capable (CAP_SYS_ADMIN )) { ret = -EPERM ;
@@ -4819,43 +4823,64 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issueif (issue_flags &IO_URING_F_COMPAT ) {#if defined(CONFIG_64BIT ) && defined(CONFIG_COMPAT ) -struct btrfs_ioctl_encoded_io_args_32 args32; - copy_end = offsetofend(struct btrfs_ioctl_encoded_io_args_32, flags); -if (copy_from_user (&args32, sqe_addr, copy_end)) { - ret = -EFAULT ; - goto out_acct; - } - args.iov =compat_ptr (args32.iov); - args.iovcnt = args32.iovcnt; - args.offset = args32.offset; - args.flags = args32.flags;#else return -ENOTTY ;#endif }else { copy_end = copy_end_kernel; -if (copy_from_user (&args, sqe_addr, copy_end)) { - ret = -EFAULT ; + } + +if (!data) { + data =kzalloc (sizeof (*data),GFP_NOFS ); +if (!data) { + ret = -ENOMEM ; goto out_acct; } - } -if (args.flags !=0 ) -return -EINVAL ; +io_uring_cmd_get_async_data (cmd)->op_data = data; - ret =import_iovec (ITER_DEST , args.iov, args.iovcnt,ARRAY_SIZE (iovstack), - &iov, &iter); -if (ret <0 ) - goto out_acct; +if (issue_flags &IO_URING_F_COMPAT ) { +#if defined(CONFIG_64BIT ) && defined(CONFIG_COMPAT ) +struct btrfs_ioctl_encoded_io_args_32 args32; -if (iov_iter_count (&iter) ==0 ) { - ret =0 ; - goto out_free; +if (copy_from_user (&args32, sqe_addr, copy_end)) { + ret = -EFAULT ; + goto out_acct; + } + + data->args.iov =compat_ptr (args32.iov); + data->args.iovcnt = args32.iovcnt; + data->args.offset = args32.offset; + data->args.flags = args32.flags; +#endif + }else { +if (copy_from_user (&data->args, sqe_addr, copy_end)) { + ret = -EFAULT ; + goto out_acct; + } + } + +if (data->args.flags !=0 ) { + ret = -EINVAL ; + goto out_acct; + } + + data->iov = data->iovstack; + ret =import_iovec (ITER_DEST , data->args.iov, data->args.iovcnt, +ARRAY_SIZE (data->iovstack), &data->iov, + &data->iter); +if (ret <0 ) + goto out_acct; + +if (iov_iter_count (&data->iter) ==0 ) { + ret =0 ; + goto out_free; + } } - pos = args.offset; - ret =rw_verify_area (READ , file, &pos, args.len); + pos = data->args.offset; + ret =rw_verify_area (READ , file, &pos, data->args.len);if (ret <0 ) goto out_free;
@@ -4868,15 +4893,16 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue start =ALIGN_DOWN (pos, fs_info->sectorsize); lockend = start +BTRFS_MAX_UNCOMPRESSED -1 ; - ret =btrfs_encoded_read (&kiocb, &iter, &args, &cached_state, - &disk_bytenr, &disk_io_size); + ret =btrfs_encoded_read (&kiocb, &data->iter, &data->args, + &cached_state, &disk_bytenr, &disk_io_size);if (ret <0 && ret != -EIOCBQUEUED ) goto out_free;file_accessed (file); -if (copy_to_user (sqe_addr + copy_end, (const char *)&args + copy_end_kernel, -sizeof (args) - copy_end_kernel)) { +if (copy_to_user (sqe_addr + copy_end, + (const char *)&data->args + copy_end_kernel, +sizeof (data->args) - copy_end_kernel)) {if (ret == -EIOCBQUEUED ) {unlock_extent (io_tree, start, lockend, &cached_state);btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED );
@@ -4886,39 +4912,24 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue }if (ret == -EIOCBQUEUED ) { -u64 count; - -/* -* If we've optimized things by storing the iovecs on the stack, -* undo this. -*/ -if (!iov) { - iov =kmemdup (iovstack,sizeof (struct iovec ) * args.iovcnt, -GFP_NOFS ); -if (!iov) { -unlock_extent (io_tree, start, lockend, &cached_state); -btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED ); - ret = -ENOMEM ; - goto out_acct; - } - } - - count =min_t (u64,iov_iter_count (&iter), disk_io_size); +u64 count =min_t (u64,iov_iter_count (&data->iter), + disk_io_size);/* Match ioctl by not returning past EOF if uncompressed. */ -if (!args.compression) - count =min_t (u64, count, args.len); +if (!data->args.compression) + count =min_t (u64, count, data->args.len); - ret =btrfs_uring_read_extent (&kiocb, &iter, start, lockend, - cached_state, disk_bytenr, - disk_io_size, count, - args.compression, iov, cmd); + ret =btrfs_uring_read_extent (&kiocb, &data->iter, start, + lockend, cached_state, + disk_bytenr, disk_io_size, count, + data->args.compression, + data->iov, cmd); goto out_acct; } out_free: -kfree (iov); +kfree (data->iov); out_acct:if (ret >0 )
Signature · 1 line
2.45.2
Jens Axboe
maintainerQuoted 5 lines · Mark Harmstone
Version 4 of mine and Jens' patches, to make sure that when our
io_uringfunction gets called a second time, it doesn't accidentally read something from userspace that's gone out of scope or otherwise gotten corrupted.
Quoted 8 lines
I sent a version 3 on December 17, but it looks like that got forgotten about over Christmas (unsurprisingly). Version 4 fixes a problem that I noticed, namely that we weren't taking a copy of the iovs, which also necessitated creating a struct to store these things in. This does simplify things by removing the need for the kmemdup, however.
I also have a patch for
io_uringencoded writes ready to go, but it's waiting on some of the stuff introduced here.
Looks fine to me, and we really should get this into 6.13. The encoded reads are somewhat broken without it, violating the usual expectations on how persistent passed in data should be.
Signature · 1 line
Jens Axboe
Quoted 12 lines · Jens Axboe
Quoted 11 lines · Mark Harmstone
Version 4 of mine and Jens' patches, to make sure that when our
io_uringfunction gets called a second time, it doesn't accidentally read something from userspace that's gone out of scope or otherwise gotten corrupted.I sent a version 3 on December 17, but it looks like that got forgotten about over Christmas (unsurprisingly). Version 4 fixes a problem that I noticed, namely that we weren't taking a copy of the iovs, which also necessitated creating a struct to store these things in. This does simplify things by removing the need for the kmemdup, however.
Quoted 6 lines
Quoted 2 lines
I also have a patch for
io_uringencoded writes ready to go, but it's waiting on some of the stuff introduced here.Looks fine to me, and we really should get this into 6.13. The encoded reads are somewhat broken without it, violating the usual expectations on how persistent passed in data should be.
Ok, I'll add the to the queue for the next RC.
Quoted 7 lines · Mark Harmstone
Version 4 of mine and Jens' patches, to make sure that when our
io_uringfunction gets called a second time, it doesn't accidentally read something from userspace that's gone out of scope or otherwise gotten corrupted.I sent a version 3 on December 17, but it looks like that got forgotten about over Christmas (unsurprisingly).
V3 lacked the cover letter and it was not obvious if it's urgent fix, new devlopemnent or a regular fix. Also it touched code outside of btrfs, did not have any acks or word agreement that it would be ok to take the fixes via btrfs tree.