Cleanup alloc cache init_once handling
Jens Axboe
maintainerv2 cover Cleanup alloc cache init_once handling
Hi,
A minor prep patch cleaning up some confusion on types for uring_cmd, which don't matter now, but will after patch 2. Patch 2 gets rid of the init_once, and has the cache init functions pass in the number of bytes to clear for a fresh allocation.
Since v1:
- Make the iovec caching play nice with KASAN. We just free it now, as even basic KASAN will stomp on this memory. This should also fix the reported issue with KASAN_EXTRA_INFO and msghdr on the net side without needing KASAN changes.
- Cleanup the uring_cmd bits, we don't need to retain anything there.
- Use struct_group() for the rw and net bits.
- Add patch killing the _nocache() helper, just allow passing in a NULL cache for those two cases.
include/linux/io_uring/cmd.h | 2 +- include/linux/io_uring_types.h | 3 ++- io_uring/alloc_cache.h | 43 +++++++++++++++++++++++++++------- io_uring/futex.c | 4 ++-- io_uring/io_uring.c | 12 ++++++---- io_uring/io_uring.h | 21 +++++++---------- io_uring/net.c | 28 +++++----------------- io_uring/net.h | 20 +++++++++------- io_uring/poll.c | 2 +- io_uring/rw.c | 27 +++++---------------- io_uring/rw.h | 27 ++++++++++++--------- io_uring/timeout.c | 2 +- io_uring/uring_cmd.c | 17 ++++---------- io_uring/waitid.c | 2 +- 14 files changed, 102 insertions(+), 108 deletions(-)
Jens Axboe
maintainerPATCH v2 1/3 io_uring/uring_cmd: cleanup struct io_uring_cmd_data layout
A few spots in uring_cmd assume that the SQEs copied are always at the start of the structure, and hence mix req->async_data and the struct itself.
Clean that up and use the proper indices.
--- io_uring/uring_cmd.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
io_uring/uring_cmd.c +3 -3
@@ -192,8 +192,8 @@ static int io_uring_cmd_prep_setup(struct io_kiocb *req,return 0 ; } -memcpy (req->async_data, sqe,uring_sqe_size (req->ctx)); - ioucmd->sqe = req->async_data; +memcpy (cache->sqes, sqe,uring_sqe_size (req->ctx)); + ioucmd->sqe = cache->sqes;return 0 ; }
@@ -260,7 +260,7 @@ int io_uring_cmd(struct io_kiocb *req, unsigned int issue_flags)struct io_uring_cmd_data *cache = req->async_data;if (ioucmd->sqe != (void *) cache) -memcpy (cache, ioucmd->sqe,uring_sqe_size (req->ctx)); +memcpy (cache->sqes, ioucmd->sqe,uring_sqe_size (req->ctx));return -EAGAIN ; }else if (ret == -EIOCBQUEUED ) {return -EIOCBQUEUED ;
Signature · 1 line
2.47.2
Jens Axboe
maintainerPATCH v2 2/3 io_uring: get rid of alloc cache init_once handling
In reply to Jens Axboeinit_once is called when an object doesn't come from the cache, and hence needs initial clearing of certain members. While the whole struct could get cleared by memset() in that case, a few of the cache members are large enough that this may cause unnecessary overhead if the caches used aren't large enough to satisfy the workload. For those cases, some churn of kmalloc+kfree is to be expected.
Ensure that the 3 users that need clearing put the members they need cleared at the start of the struct, and wrap the rest of the struct in a struct group so the offset is known.
While at it, improve the interaction with KASAN such that when/if KASAN writes to members inside the struct that should be retained over caching, it won't trip over itself. For rw and net, the retaining of the iovec over caching is disabled if KASAN is enabled. A helper will free and clear those members in that case.
--- include/linux/io_uring/cmd.h | 2 +- include/linux/io_uring_types.h | 3 ++- io_uring/alloc_cache.h | 43 +++++++++++++++++++++++++++------- io_uring/futex.c | 4 ++-- io_uring/io_uring.c | 12 ++++++---- io_uring/io_uring.h | 5 ++-- io_uring/net.c | 28 +++++----------------- io_uring/net.h | 20 +++++++++------- io_uring/poll.c | 2 +- io_uring/rw.c | 27 +++++---------------- io_uring/rw.h | 27 ++++++++++++--------- io_uring/uring_cmd.c | 11 ++------- 12 files changed, 91 insertions(+), 93 deletions(-)
include/linux/io_uring/cmd.h +1 -1
@@ -19,8 +19,8 @@ struct io_uring_cmd { };struct io_uring_cmd_data { -struct io_uring_sqe sqes[2 ];void *op_data; +struct io_uring_sqe sqes[2 ]; };static inline const void *io_uring_sqe_cmd (const struct io_uring_sqe *sqe)
include/linux/io_uring_types.h +2 -1
@@ -222,7 +222,8 @@ struct io_alloc_cache {void **entries;unsigned int nr_cached;unsigned int max_cached; -size_t elem_size; +unsigned int elem_size; +unsigned int init_clear; };struct io_ring_ctx {
io_uring/alloc_cache.h +34 -9
75 lines not on this page · raw message
io_uring/futex.c +2 -2
@@ -36,7 +36,7 @@ struct io_futex_data {bool io_futex_cache_init (struct io_ring_ctx *ctx) {return io_alloc_cache_init (&ctx->futex_cache,IO_FUTEX_ALLOC_CACHE_MAX , -sizeof (struct io_futex_data )); +sizeof (struct io_futex_data ),0 ); }void io_futex_cache_free (struct io_ring_ctx *ctx)
@@ -320,7 +320,7 @@ int io_futex_wait(struct io_kiocb *req, unsigned int issue_flags) }io_ring_submit_lock (ctx, issue_flags); - ifd =io_cache_alloc (&ctx->futex_cache,GFP_NOWAIT ,NULL ); + ifd =io_cache_alloc (&ctx->futex_cache,GFP_NOWAIT );if (!ifd) { ret = -ENOMEM ; goto done_unlock;
io_uring/io_uring.c +7 -5
@@ -315,16 +315,18 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)INIT_LIST_HEAD (&ctx->cq_overflow_list);INIT_LIST_HEAD (&ctx->io_buffers_cache); ret =io_alloc_cache_init (&ctx->apoll_cache,IO_POLL_ALLOC_CACHE_MAX , -sizeof (struct async_poll )); +sizeof (struct async_poll ),0 ); ret |=io_alloc_cache_init (&ctx->netmsg_cache,IO_ALLOC_CACHE_MAX , -sizeof (struct io_async_msghdr )); +sizeof (struct io_async_msghdr ), + offsetof(struct io_async_msghdr , clear)); ret |=io_alloc_cache_init (&ctx->rw_cache,IO_ALLOC_CACHE_MAX , -sizeof (struct io_async_rw )); +sizeof (struct io_async_rw ), + offsetof(struct io_async_rw , clear)); ret |=io_alloc_cache_init (&ctx->uring_cache,IO_ALLOC_CACHE_MAX , -sizeof (struct io_uring_cmd_data )); +sizeof (struct io_uring_cmd_data ),0 );spin_lock_init (&ctx->msg_lock); ret |=io_alloc_cache_init (&ctx->msg_cache,IO_ALLOC_CACHE_MAX , -sizeof (struct io_kiocb )); +sizeof (struct io_kiocb ),0 ); ret |=io_futex_cache_init (ctx);if (ret) goto free_ref;
io_uring/io_uring.h +2 -3
@@ -226,10 +226,9 @@ static inline void io_req_set_res(struct io_kiocb *req, s32 res, u32 cflags) }static inline void *io_uring_alloc_async_data (struct io_alloc_cache *cache, -struct io_kiocb *req, -void (*init_once)(void *obj)) +struct io_kiocb *req) { - req->async_data =io_cache_alloc (cache,GFP_KERNEL , init_once); + req->async_data =io_cache_alloc (cache,GFP_KERNEL );if (req->async_data) req->flags |=REQ_F_ASYNC_DATA ;return req->async_data;
io_uring/net.c +6 -22
@@ -137,7 +137,6 @@ static void io_netmsg_iovec_free(struct io_async_msghdr *kmsg)static void io_netmsg_recycle (struct io_kiocb *req,unsigned int issue_flags) {struct io_async_msghdr *hdr = req->async_data; -struct iovec *iov;/* can't recycle, ensure we free the iovec if we have one */ if (unlikely (issue_flags &IO_URING_F_UNLOCKED )) {
@@ -146,39 +145,25 @@ static void io_netmsg_recycle(struct io_kiocb *req, unsigned int issue_flags) }/* Let normal cleanup path reap it if we fail adding to the cache */ - iov = hdr->free_iov; +io_alloc_cache_kasan (&hdr->free_iov, &hdr->free_iov_nr);if (io_alloc_cache_put (&req->ctx->netmsg_cache, hdr)) { -if (iov) -kasan_mempool_poison_object (iov); req->async_data =NULL ; req->flags &= ~REQ_F_ASYNC_DATA ; } } -static void io_msg_async_data_init (void *obj) -{ -struct io_async_msghdr *hdr = (struct io_async_msghdr *)obj; - - hdr->free_iov =NULL ; - hdr->free_iov_nr =0 ; -} -static struct io_async_msghdr *io_msg_alloc_async (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx;struct io_async_msghdr *hdr; - hdr =io_uring_alloc_async_data (&ctx->netmsg_cache, req, - io_msg_async_data_init); + hdr =io_uring_alloc_async_data (&ctx->netmsg_cache, req);if (!hdr)return NULL ;/* If the async data was cached, we might have an iov cached inside. */ -if (hdr->free_iov) { -kasan_mempool_unpoison_object (hdr->free_iov, - hdr->free_iov_nr *sizeof (struct iovec )); +if (hdr->free_iov) req->flags |=REQ_F_NEED_CLEANUP ; - }return hdr; }
@@ -1813,11 +1798,10 @@ void io_netmsg_cache_free(const void *entry) {struct io_async_msghdr *kmsg = (struct io_async_msghdr *) entry; -if (kmsg->free_iov) { -kasan_mempool_unpoison_object (kmsg->free_iov, - kmsg->free_iov_nr *sizeof (struct iovec )); +#if !defined(CONFIG_KASAN ) +if (kmsg->free_iov)io_netmsg_iovec_free (kmsg); - } +#endif kfree (kmsg); }#endif
io_uring/net.h +12 -8
@@ -5,16 +5,20 @@struct io_async_msghdr {#if defined(CONFIG_NET ) -struct iovec fast_iov; -/* points to an allocated iov, if NULL we use fast_iov instead */ struct iovec *free_iov; +/* points to an allocated iov, if NULL we use fast_iov instead */ int free_iov_nr; -int namelen; -__kernel_size_t controllen; -__kernel_size_t payloadlen; -struct sockaddr __user *uaddr; -struct msghdr msg; -struct sockaddr_storage addr; + struct_group(clear, + int namelen; +struct iovec fast_iov; +__kernel_size_t controllen; +__kernel_size_t payloadlen; +struct sockaddr __user *uaddr; +struct msghdr msg; +struct sockaddr_storage addr; + ); +#else +struct_group (clear);#endif };
io_uring/poll.c +1 -1
@@ -650,7 +650,7 @@ static struct async_poll *io_req_alloc_apoll(struct io_kiocb *req,kfree (apoll->double_poll); }else {if (!(issue_flags &IO_URING_F_UNLOCKED )) - apoll =io_cache_alloc (&ctx->apoll_cache,GFP_ATOMIC ,NULL ); + apoll =io_cache_alloc (&ctx->apoll_cache,GFP_ATOMIC );else apoll =kmalloc (sizeof (*apoll),GFP_ATOMIC );if (!apoll)
io_uring/rw.c +6 -21
@@ -158,16 +158,13 @@ static void io_rw_iovec_free(struct io_async_rw *rw)static void io_rw_recycle (struct io_kiocb *req,unsigned int issue_flags) {struct io_async_rw *rw = req->async_data; -struct iovec *iov;if (unlikely (issue_flags &IO_URING_F_UNLOCKED )) {io_rw_iovec_free (rw);return ; } - iov = rw->free_iovec; +io_alloc_cache_kasan (&rw->free_iovec, &rw->free_iov_nr);if (io_alloc_cache_put (&req->ctx->rw_cache, rw)) { -if (iov) -kasan_mempool_poison_object (iov); req->async_data =NULL ; req->flags &= ~REQ_F_ASYNC_DATA ; }
@@ -208,27 +205,16 @@ static void io_req_rw_cleanup(struct io_kiocb *req, unsigned int issue_flags) } } -static void io_rw_async_data_init (void *obj) -{ -struct io_async_rw *rw = (struct io_async_rw *)obj; - - rw->free_iovec =NULL ; - rw->bytes_done =0 ; -} -static int io_rw_alloc_async (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx;struct io_async_rw *rw; - rw =io_uring_alloc_async_data (&ctx->rw_cache, req, io_rw_async_data_init); + rw =io_uring_alloc_async_data (&ctx->rw_cache, req);if (!rw)return -ENOMEM ; -if (rw->free_iovec) { -kasan_mempool_unpoison_object (rw->free_iovec, - rw->free_iov_nr *sizeof (struct iovec )); +if (rw->free_iovec) req->flags |=REQ_F_NEED_CLEANUP ; - } rw->bytes_done =0 ;return 0 ; }
@@ -1323,10 +1309,9 @@ void io_rw_cache_free(const void *entry) {struct io_async_rw *rw = (struct io_async_rw *) entry; -if (rw->free_iovec) { -kasan_mempool_unpoison_object (rw->free_iovec, - rw->free_iov_nr *sizeof (struct iovec )); +#if !defined(CONFIG_KASAN ) +if (rw->free_iovec)io_rw_iovec_free (rw); - } +#endif kfree (rw); }
io_uring/rw.h +16 -11
@@ -9,19 +9,24 @@ struct io_meta_state {struct io_async_rw {size_t bytes_done; -struct iov_iter iter; -struct iov_iter_state iter_state; -struct iovec fast_iov;struct iovec *free_iovec; -int free_iov_nr; -/* wpq is for buffered io, while meta fields are used with direct io */ -union { -struct wait_page_queue wpq; -struct { -struct uio_meta meta; -struct io_meta_state meta_state; + struct_group(clear, + struct iov_iter iter; +struct iov_iter_state iter_state; +struct iovec fast_iov; +int free_iov_nr; +/* +* wpq is for buffered io, while meta fields are used with +* direct io +*/ +union { +struct wait_page_queue wpq; +struct { +struct uio_meta meta; +struct io_meta_state meta_state; + }; }; - }; + ); };int io_prep_read_fixed (struct io_kiocb *req,const struct io_uring_sqe *sqe);
io_uring/uring_cmd.c +2 -9
@@ -168,23 +168,16 @@ void io_uring_cmd_done(struct io_uring_cmd *ioucmd, ssize_t ret, u64 res2, }EXPORT_SYMBOL_GPL (io_uring_cmd_done); -static void io_uring_cmd_init_once (void *obj) -{ -struct io_uring_cmd_data *data = obj; - - data->op_data =NULL ; -} -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 io_uring_cmd_data *cache; - cache =io_uring_alloc_async_data (&req->ctx->uring_cache, req, - io_uring_cmd_init_once); + cache =io_uring_alloc_async_data (&req->ctx->uring_cache, req);if (!cache)return -ENOMEM ; + cache->op_data =NULL ;if (!(req->flags &REQ_F_FORCE_ASYNC )) {/* defer memcpy until we need it */
Signature · 1 line
2.47.2
Re: [PATCH 2/3] io_uring: get rid of alloc cache init_once handling
Quoted 19 lines · Jens Axboe
init_onceis called when an object doesn't come from the cache, and hence needs initial clearing of certain members. While the whole struct could get cleared bymemset()in that case, a few of the cache members are large enough that this may cause unnecessary overhead if the caches used aren't large enough to satisfy the workload. For those cases, some churn of kmalloc+kfree is to be expected.Ensure that the 3 users that need clearing put the members they need cleared at the start of the struct, and wrap the rest of the struct in a struct group so the offset is known.
While at it, improve the interaction with KASAN such that when/if KASAN writes to members inside the struct that should be retained over caching, it won't trip over itself. For rw and net, the retaining of the iovec over caching is disabled if KASAN is enabled. A helper will free and clear those members in that case.
io_uring/net.c +0
-0@@ -1813,11 +1798,10 @@ void io_netmsg_cache_free(const void *entry) {
io_uring/net.c void io_netmsg_cache_free(const void *entry) · line 1804
Quoted 10 lines
io_uring/net.c +3
-4struct io_async_msghdr *kmsg = (struct io_async_msghdr *) entry; -if (kmsg->free_iov) { -kasan_mempool_unpoison_object (kmsg->free_iov, - kmsg->free_iov_nr *sizeof (struct iovec )); +#if !defined(CONFIG_KASAN ) +if (kmsg->free_iov)io_netmsg_iovec_free (kmsg); - } +#endif
Among mostly ugly choices, this is an improvement over the init_once callback. I'd just fold the above codeguard into the code:
if (IS_DEFINED(CONFIG_KASAN) && kmsg->free_iov)
Other than that,
Quoted 23 lines
io_uring/net.c +0
-0kfree(kmsg); }#endif io_uring/net.h +2
-8@@ -5,16 +5,20 @@struct io_async_msghdr {#if defined(CONFIG_NET ) -struct iovec fast_iov; -/* points to an allocated iov, if NULL we use fast_iov instead */ struct iovec *free_iov; +/* points to an allocated iov, if NULL we use fast_iov instead */ int free_iov_nr; -int namelen; -__kernel_size_t controllen; -__kernel_size_t payloadlen; -struct sockaddr __user *uaddr; -struct msghdr msg; -struct sockaddr_storage addr; + struct_group(clear,
Signature · 1 line
Gabriel Krisman Bertazi
Jens Axboe
maintainerPATCH v2 3/3 io_uring/alloc_cache: get rid of _nocache() helper
In reply to Jens AxboeJust allow passing in NULL for the cache, if the type in question doesn't have a cache associated with it.
--- io_uring/io_uring.h | 18 +++++++----------- io_uring/timeout.c | 2 +- io_uring/waitid.c | 2 +- 3 files changed, 9 insertions(+), 13 deletions(-)
io_uring/io_uring.h +7 -11
@@ -228,18 +228,14 @@ static inline void io_req_set_res(struct io_kiocb *req, s32 res, u32 cflags)static inline void *io_uring_alloc_async_data (struct io_alloc_cache *cache,struct io_kiocb *req) { - req->async_data =io_cache_alloc (cache,GFP_KERNEL ); -if (req->async_data) - req->flags |=REQ_F_ASYNC_DATA ; -return req->async_data; -} +if (cache) { + req->async_data =io_cache_alloc (cache,GFP_KERNEL ); + }else { +const struct io_issue_def *def = &io_issue_defs[req->opcode]; -static inline void *io_uring_alloc_async_data_nocache (struct io_kiocb *req) -{ -const struct io_issue_def *def = &io_issue_defs[req->opcode]; - -WARN_ON_ONCE (!def->async_size); - req->async_data =kmalloc (def->async_size,GFP_KERNEL ); +WARN_ON_ONCE (!def->async_size); + req->async_data =kmalloc (def->async_size,GFP_KERNEL ); + }if (req->async_data) req->flags |=REQ_F_ASYNC_DATA ;return req->async_data;
io_uring/timeout.c +1 -1
@@ -544,7 +544,7 @@ static int __io_timeout_prep(struct io_kiocb *req,if (WARN_ON_ONCE (req_has_async_data (req)))return -EFAULT ; - data =io_uring_alloc_async_data_nocache (req); + data =io_uring_alloc_async_data (NULL , req);if (!data)return -ENOMEM ; data->req = req;
io_uring/waitid.c +1 -1
@@ -303,7 +303,7 @@ int io_waitid(struct io_kiocb *req, unsigned int issue_flags)struct io_waitid_async *iwa;int ret; - iwa =io_uring_alloc_async_data_nocache (req); + iwa =io_uring_alloc_async_data (NULL , req);if (!iwa)return -ENOMEM ;
Signature · 1 line
2.47.2