Bijan's rsrc generalisation + prep parts
cover Bijan's rsrc generalisation + prep parts
I guess we can agree that generic rsrc handling is a good thing to have, even if we have only files at the moment. This consists of related patches from the Bijan's longer series, doesn't include sharing and buffer bits. I suggest to merge it first. It's approx half of the all changes.
Based on 5.12 with a few pathes from 5.11 cherry-pick to reduce merge conflicts, because of merging/etc. may wait for a week or so for the next rc before potentially being merged. This also addressed tricky merge conflicts where it was applying and compiling well but still buggy.
Bijan, for the changed patches I also dropped your signed-off, so please reply if you're happy with the new versions so we can add it back. There are change logs (e.g. [did so]) in commit messages of those.
Mapping to the original v5 series:
1-5/9 (1-5/13 originally), mostly unchanged
6/9 -- my own prep
7/9 (7/13 originally), only file part
8/9 (10/13 originally), only file part
9/9 (11/13 before), unchanged
Bijan Mottahedeh (8):
io_uring: rename file related variables to rsrc
io_uring: generalize io_queue_rsrc_removal
io_uring: separate ref_list from fixed_rsrc_data
io_uring: add rsrc_ref locking routines
io_uring: split alloc_fixed_file_ref_node
io_uring: create common fixed_rsrc_ref_node handling routines
io_uring: create common fixed_rsrc_data allocation routines
io_uring: make percpu_ref_release names consistent
Pavel Begunkov (1):
io_uring: split ref_node alloc and init
fs/io_uring.c | 355 ++++++++++++++++++++-------------- include/uapi/linux/io_uring.h | 7 + 2 files changed, 216 insertions(+), 146 deletions(-)
Signature · 1 line
2.24.0
PATCH 1/9 io_uring: rename file related variables to rsrc
From: Bijan Mottahedeh <[email protected]>
This is a prep rename patch for subsequent patches to generalize file registration.
--- fs/io_uring.c | 228 +++++++++++++++++----------------- include/uapi/linux/io_uring.h | 7 ++ 2 files changed, 124 insertions(+), 111 deletions(-)
fs/io_uring.c +117 -111
@@ -195,24 +195,29 @@ struct io_mapped_ubuf {unsigned long acct_pages; }; -struct fixed_file_table { +struct io_rsrc_put { +struct list_head list; +struct file *file; +}; + +struct fixed_rsrc_table {struct file **files; }; -struct fixed_file_ref_node { +struct fixed_rsrc_ref_node {struct percpu_ref refs;struct list_head node; -struct list_head file_list; -struct fixed_file_data *file_data; +struct list_head rsrc_list; +struct fixed_rsrc_data *rsrc_data;struct llist_node llist;bool done; }; -struct fixed_file_data { -struct fixed_file_table *table; +struct fixed_rsrc_data { +struct fixed_rsrc_table *table;struct io_ring_ctx *ctx; -struct fixed_file_ref_node *node; +struct fixed_rsrc_ref_node *node;struct percpu_ref refs;struct completion done;struct list_head ref_list;
@@ -318,7 +323,7 @@ struct io_ring_ctx {* readers must ensure that ->refs is alive as long as the file* is * used. Only updated through io_uring_register(2). */ -struct fixed_file_data *file_data; +struct fixed_rsrc_data *file_data;unsigned nr_user_files;/* if used, fixed mapped user buffers */
@@ -382,8 +387,8 @@ struct io_ring_ctx {struct list_head inflight_list; }____cacheline_aligned_in_smp ; -struct delayed_work file_put_work; -struct llist_head file_put_llist; +struct delayed_work rsrc_put_work; +struct llist_head rsrc_put_llist;struct work_struct exit_work;struct io_restriction restrictions;
@@ -492,7 +497,7 @@ struct io_open {unsigned long nofile; }; -struct io_files_update { +struct io_rsrc_update {struct file *file;u64 arg;u32 nr_args;
@@ -686,7 +691,7 @@ struct io_kiocb {struct io_sr_msg sr_msg;struct io_open open;struct io_close close; -struct io_files_update files_update; +struct io_rsrc_update rsrc_update;struct io_fadvise fadvise;struct io_madvise madvise;struct io_epoll epoll;
@@ -716,7 +721,7 @@ struct io_kiocb {u64 user_data;struct io_kiocb *link; -struct percpu_ref *fixed_file_refs; +struct percpu_ref *fixed_rsrc_refs;/* * 1. used with ctx->iopoll_list with reads/writes
@@ -991,8 +996,8 @@ enum io_mem_account { ACCT_PINNED, }; -static void destroy_fixed_file_ref_node (struct fixed_file_ref_node *ref_node); -static struct fixed_file_ref_node *alloc_fixed_file_ref_node ( +static void destroy_fixed_rsrc_ref_node (struct fixed_rsrc_ref_node *ref_node); +static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node (struct io_ring_ctx *ctx); static void __io_complete_rw(struct io_kiocb *req, long res, long res2,
@@ -1005,13 +1010,13 @@ static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req);static void __io_queue_linked_timeout (struct io_kiocb *req);static void io_queue_linked_timeout (struct io_kiocb *req);static int __io_sqe_files_update (struct io_ring_ctx *ctx, -struct io_uring_files_update *ip, +struct io_uring_rsrc_update *ip,unsigned nr_args);static void __io_clean_op (struct io_kiocb *req);static struct file *io_file_get (struct io_submit_state *state,struct io_kiocb *req,int fd,bool fixed);static void __io_queue_sqe (struct io_kiocb *req,struct io_comp_state *cs); -static void io_file_put_work (struct work_struct *work); +static void io_rsrc_put_work (struct work_struct *work); static ssize_t io_import_iovec(int rw, struct io_kiocb *req, struct iovec **iovec, struct iov_iter *iter,
@@ -1051,9 +1056,9 @@ static inline void io_set_resource_node(struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx; -if (!req->fixed_file_refs) { - req->fixed_file_refs = &ctx->file_data->node->refs; -percpu_ref_get (req->fixed_file_refs); +if (!req->fixed_rsrc_refs) { + req->fixed_rsrc_refs = &ctx->file_data->node->refs; +percpu_ref_get (req->fixed_rsrc_refs); } }
@@ -1312,8 +1317,8 @@ static struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)INIT_LIST_HEAD (&ctx->timeout_list);spin_lock_init (&ctx->inflight_lock);INIT_LIST_HEAD (&ctx->inflight_list); -INIT_DELAYED_WORK (&ctx->file_put_work, io_file_put_work); -init_llist_head (&ctx->file_put_llist); +INIT_DELAYED_WORK (&ctx->rsrc_put_work, io_rsrc_put_work); +init_llist_head (&ctx->rsrc_put_llist);return ctx; err:if (ctx->fallback_req)
@@ -1958,8 +1963,8 @@ static void io_dismantle_req(struct io_kiocb *req)kfree (req->async_data);if (req->file)io_put_file (req, req->file, (req->flags &REQ_F_FIXED_FILE )); -if (req->fixed_file_refs) -percpu_ref_put (req->fixed_file_refs); +if (req->fixed_rsrc_refs) +percpu_ref_put (req->fixed_rsrc_refs);io_req_clean_work (req); }
@@ -5934,7 +5939,7 @@ static int io_async_cancel(struct io_kiocb *req)return 0 ; } -static int io_files_update_prep (struct io_kiocb *req, +static int io_rsrc_update_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe) {if (unlikely (req->ctx->flags &IORING_SETUP_SQPOLL ))
@@ -5944,11 +5949,11 @@ static int io_files_update_prep(struct io_kiocb *req,if (sqe->ioprio || sqe->rw_flags)return -EINVAL ; - req->files_update.offset =READ_ONCE (sqe->off); - req->files_update.nr_args =READ_ONCE (sqe->len); -if (!req->files_update.nr_args) + req->rsrc_update.offset =READ_ONCE (sqe->off); + req->rsrc_update.nr_args =READ_ONCE (sqe->len); +if (!req->rsrc_update.nr_args)return -EINVAL ; - req->files_update.arg =READ_ONCE (sqe->addr); + req->rsrc_update.arg =READ_ONCE (sqe->addr);return 0 ; }
@@ -5956,17 +5961,17 @@ static int io_files_update(struct io_kiocb *req, bool force_nonblock, struct io_comp_state *cs) {struct io_ring_ctx *ctx = req->ctx; -struct io_uring_files_update up; +struct io_uring_rsrc_update up;int ret;if (force_nonblock)return -EAGAIN ; - up.offset = req->files_update.offset; - up.fds = req->files_update.arg; + up.offset = req->rsrc_update.offset; + up.data = req->rsrc_update.arg;mutex_lock (&ctx->uring_lock); - ret =__io_sqe_files_update (ctx, &up, req->files_update.nr_args); + ret =__io_sqe_files_update (ctx, &up, req->rsrc_update.nr_args);mutex_unlock (&ctx->uring_lock);if (ret <0 )
@@ -6021,7 +6026,7 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)case IORING_OP_CLOSE :return io_close_prep (req, sqe);case IORING_OP_FILES_UPDATE : -return io_files_update_prep (req, sqe); +return io_rsrc_update_prep (req, sqe);case IORING_OP_STATX :return io_statx_prep (req, sqe);case IORING_OP_FADVISE :
@@ -6391,7 +6396,7 @@ static struct io_wq_work *io_wq_submit_work(struct io_wq_work *work)static inline struct file *io_file_from_index (struct io_ring_ctx *ctx,int index) { -struct fixed_file_table *table; +struct fixed_rsrc_table *table; table = &ctx->file_data->table[index >>IORING_FILE_TABLE_SHIFT ];return table->files[index &IORING_FILE_TABLE_MASK ];
@@ -6777,7 +6782,7 @@ static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, req->ctx = ctx; req->flags =0 ; req->link =NULL ; - req->fixed_file_refs =NULL ; + req->fixed_rsrc_refs =NULL ;/* one is dropped after submission, the other at completion */ refcount_set (&req->refs,2 ); req->task = current;
@@ -7252,28 +7257,28 @@ static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)#endif } -static void io_file_ref_kill (struct percpu_ref *ref) +static void io_rsrc_ref_kill (struct percpu_ref *ref) { -struct fixed_file_data *data; +struct fixed_rsrc_data *data; - data = container_of(ref, struct fixed_file_data, refs); + data = container_of(ref, struct fixed_rsrc_data, refs);complete (&data->done); } -static void io_sqe_files_set_node (struct fixed_file_data *file_data, -struct fixed_file_ref_node *ref_node) +static void io_sqe_rsrc_set_node (struct fixed_rsrc_data *rsrc_data, +struct fixed_rsrc_ref_node *ref_node) { -spin_lock_bh (&file_data->lock); - file_data->node = ref_node; -list_add_tail (&ref_node->node, &file_data->ref_list); -spin_unlock_bh (&file_data->lock); -percpu_ref_get (&file_data->refs); +spin_lock_bh (&rsrc_data->lock); + rsrc_data->node = ref_node; +list_add_tail (&ref_node->node, &rsrc_data->ref_list); +spin_unlock_bh (&rsrc_data->lock); +percpu_ref_get (&rsrc_data->refs); }static int io_sqe_files_unregister (struct io_ring_ctx *ctx) { -struct fixed_file_data *data = ctx->file_data; -struct fixed_file_ref_node *backup_node, *ref_node =NULL ; +struct fixed_rsrc_data *data = ctx->file_data; +struct fixed_rsrc_ref_node *backup_node, *ref_node =NULL ;unsigned nr_tables, i;int ret;
@@ -7292,7 +7297,7 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)percpu_ref_kill (&data->refs);/* wait for all refs nodes to complete */ -flush_delayed_work (&ctx->file_put_work); +flush_delayed_work (&ctx->rsrc_put_work); do { ret = wait_for_completion_interruptible(&data->done); if (!ret)
@@ -7301,7 +7306,7 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)if (ret <0 ) {percpu_ref_resurrect (&data->refs);reinit_completion (&data->done); -io_sqe_files_set_node (data, backup_node); +io_sqe_rsrc_set_node (data, backup_node);return ret; } }while (1 );
@@ -7315,7 +7320,7 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)kfree (data); ctx->file_data =NULL ; ctx->nr_user_files =0 ; -destroy_fixed_file_ref_node (backup_node); +destroy_fixed_rsrc_ref_node (backup_node);return 0 ; }
@@ -7538,13 +7543,13 @@ static int io_sqe_files_scm(struct io_ring_ctx *ctx) }#endif -static int io_sqe_alloc_file_tables (struct fixed_file_data *file_data, +static int io_sqe_alloc_file_tables (struct fixed_rsrc_data *file_data,unsigned nr_tables,unsigned nr_files) {int i;for (i =0 ; i < nr_tables; i++) { -struct fixed_file_table *table = &file_data->table[i]; +struct fixed_rsrc_table *table = &file_data->table[i];unsigned this_files; this_files =min (nr_files,IORING_MAX_FILES_TABLE );
@@ -7559,7 +7564,7 @@ static int io_sqe_alloc_file_tables(struct fixed_file_data *file_data,return 0 ;for (i =0 ; i < nr_tables; i++) { -struct fixed_file_table *table = &file_data->table[i]; +struct fixed_rsrc_table *table = &file_data->table[i];kfree (table->files); }return 1 ;
@@ -7627,56 +7632,51 @@ static void io_ring_file_put(struct io_ring_ctx *ctx, struct file *file)#endif } -struct io_file_put { -struct list_head list; -struct file *file; -}; - -static void __io_file_put_work (struct fixed_file_ref_node *ref_node) +static void __io_rsrc_put_work (struct fixed_rsrc_ref_node *ref_node) { -struct fixed_file_data *file_data = ref_node->file_data; -struct io_ring_ctx *ctx = file_data->ctx; -struct io_file_put *pfile, *tmp; +struct fixed_rsrc_data *rsrc_data = ref_node->rsrc_data; +struct io_ring_ctx *ctx = rsrc_data->ctx; +struct io_rsrc_put *prsrc, *tmp; -list_for_each_entry_safe (pfile, tmp, &ref_node->file_list, list) { -list_del (&pfile->list); -io_ring_file_put (ctx, pfile->file); -kfree (pfile); +list_for_each_entry_safe (prsrc, tmp, &ref_node->rsrc_list, list) { +list_del (&prsrc->list); +io_ring_file_put (ctx, prsrc->file); +kfree (prsrc); }percpu_ref_exit (&ref_node->refs);kfree (ref_node); -percpu_ref_put (&file_data->refs); +percpu_ref_put (&rsrc_data->refs); } -static void io_file_put_work (struct work_struct *work) +static void io_rsrc_put_work (struct work_struct *work) {struct io_ring_ctx *ctx;struct llist_node *node; - ctx = container_of(work, struct io_ring_ctx, file_put_work.work); - node =llist_del_all (&ctx->file_put_llist); + ctx = container_of(work, struct io_ring_ctx, rsrc_put_work.work); + node =llist_del_all (&ctx->rsrc_put_llist);while (node) { -struct fixed_file_ref_node *ref_node; +struct fixed_rsrc_ref_node *ref_node;struct llist_node *next = node->next; - ref_node = llist_entry(node, struct fixed_file_ref_node, llist); -__io_file_put_work (ref_node); + ref_node = llist_entry(node, struct fixed_rsrc_ref_node, llist); +__io_rsrc_put_work (ref_node); node = next; } } -static void io_file_data_ref_zero (struct percpu_ref *ref) +static void io_rsrc_data_ref_zero (struct percpu_ref *ref) { -struct fixed_file_ref_node *ref_node; -struct fixed_file_data *data; +struct fixed_rsrc_ref_node *ref_node; +struct fixed_rsrc_data *data;struct io_ring_ctx *ctx;bool first_add = false;int delay =HZ ; - ref_node = container_of(ref, struct fixed_file_ref_node, refs); - data = ref_node->file_data; + ref_node = container_of(ref, struct fixed_rsrc_ref_node, refs); + data = ref_node->rsrc_data; ctx = data->ctx;spin_lock_bh (&data->lock);
@@ -7684,12 +7684,12 @@ static void io_file_data_ref_zero(struct percpu_ref *ref)while (!list_empty (&data->ref_list)) { ref_node =list_first_entry (&data->ref_list, - struct fixed_file_ref_node, node); + struct fixed_rsrc_ref_node, node);/* recycle ref nodes in order */ if (!ref_node->done)break ;list_del (&ref_node->node); - first_add |=llist_add (&ref_node->llist, &ctx->file_put_llist); + first_add |=llist_add (&ref_node->llist, &ctx->rsrc_put_llist); }spin_unlock_bh (&data->lock);
@@ -7697,33 +7697,33 @@ static void io_file_data_ref_zero(struct percpu_ref *ref) delay =0 ;if (!delay) -mod_delayed_work (system_wq, &ctx->file_put_work,0 ); +mod_delayed_work (system_wq, &ctx->rsrc_put_work,0 );else if (first_add) -queue_delayed_work (system_wq, &ctx->file_put_work, delay); +queue_delayed_work (system_wq, &ctx->rsrc_put_work, delay); } -static struct fixed_file_ref_node *alloc_fixed_file_ref_node ( +static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node (struct io_ring_ctx *ctx) { -struct fixed_file_ref_node *ref_node; +struct fixed_rsrc_ref_node *ref_node; ref_node =kzalloc (sizeof (*ref_node),GFP_KERNEL );if (!ref_node)return NULL ; -if (percpu_ref_init (&ref_node->refs, io_file_data_ref_zero, +if (percpu_ref_init (&ref_node->refs, io_rsrc_data_ref_zero,0 ,GFP_KERNEL )) {kfree (ref_node);return NULL ; }INIT_LIST_HEAD (&ref_node->node); -INIT_LIST_HEAD (&ref_node->file_list); - ref_node->file_data = ctx->file_data; +INIT_LIST_HEAD (&ref_node->rsrc_list); + ref_node->rsrc_data = ctx->file_data; ref_node->done = false;return ref_node; } -static void destroy_fixed_file_ref_node (struct fixed_file_ref_node *ref_node) +static void destroy_fixed_rsrc_ref_node (struct fixed_rsrc_ref_node *ref_node) {percpu_ref_exit (&ref_node->refs);kfree (ref_node);
@@ -7736,8 +7736,8 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,unsigned nr_tables, i;struct file *file;int fd, ret = -ENOMEM ; -struct fixed_file_ref_node *ref_node; -struct fixed_file_data *file_data; +struct fixed_rsrc_ref_node *ref_node; +struct fixed_rsrc_data *file_data;if (ctx->file_data)return -EBUSY ;
@@ -7760,7 +7760,7 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,if (!file_data->table) goto out_free; -if (percpu_ref_init (&file_data->refs, io_file_ref_kill, +if (percpu_ref_init (&file_data->refs, io_rsrc_ref_kill,PERCPU_REF_ALLOW_REINIT ,GFP_KERNEL )) goto out_free;
@@ -7769,7 +7769,7 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, ctx->file_data = file_data;for (i =0 ; i < nr_args; i++, ctx->nr_user_files++) { -struct fixed_file_table *table; +struct fixed_rsrc_table *table;unsigned index;if (copy_from_user (&fd, &fds[i],sizeof (fd))) {
@@ -7813,7 +7813,7 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,return -ENOMEM ; } -io_sqe_files_set_node (file_data, ref_node); +io_sqe_rsrc_set_node (file_data, ref_node);return ret; out_fput:for (i =0 ; i < ctx->nr_user_files; i++) {
@@ -7876,28 +7876,34 @@ static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,#endif } -static int io_queue_file_removal (struct fixed_file_data *data, -struct file *file) +static int io_queue_rsrc_removal (struct fixed_rsrc_data *data, +struct file *rsrc) { -struct io_file_put *pfile; -struct fixed_file_ref_node *ref_node = data->node; +struct io_rsrc_put *prsrc; +struct fixed_rsrc_ref_node *ref_node = data->node; - pfile =kzalloc (sizeof (*pfile),GFP_KERNEL ); -if (!pfile) + prsrc =kzalloc (sizeof (*prsrc),GFP_KERNEL ); +if (!prsrc)return -ENOMEM ; - pfile->file = file; -list_add (&pfile->list, &ref_node->file_list); + prsrc->file = rsrc; +list_add (&prsrc->list, &ref_node->rsrc_list);return 0 ; } +static inline int io_queue_file_removal (struct fixed_rsrc_data *data, +struct file *file) +{ +return io_queue_rsrc_removal (data, file); +} +static int __io_sqe_files_update (struct io_ring_ctx *ctx, -struct io_uring_files_update *up, +struct io_uring_rsrc_update *up,unsigned nr_args) { -struct fixed_file_data *data = ctx->file_data; -struct fixed_file_ref_node *ref_node; +struct fixed_rsrc_data *data = ctx->file_data; +struct fixed_rsrc_ref_node *ref_node;struct file *file;__s32 __user *fds;int fd, i, err;
@@ -7914,9 +7920,9 @@ static int __io_sqe_files_update(struct io_ring_ctx *ctx,return -ENOMEM ; done =0 ; - fds =u64_to_user_ptr (up->fds); + fds =u64_to_user_ptr (up->data);while (nr_args) { -struct fixed_file_table *table; +struct fixed_rsrc_table *table;unsigned index; err =0 ;
@@ -7969,9 +7975,9 @@ static int __io_sqe_files_update(struct io_ring_ctx *ctx,if (needs_switch) {percpu_ref_kill (&data->node->refs); -io_sqe_files_set_node (data, ref_node); +io_sqe_rsrc_set_node (data, ref_node); }else -destroy_fixed_file_ref_node (ref_node); +destroy_fixed_rsrc_ref_node (ref_node);return done ? done : err; }
@@ -7979,7 +7985,7 @@ static int __io_sqe_files_update(struct io_ring_ctx *ctx,static int io_sqe_files_update (struct io_ring_ctx *ctx,void __user *arg,unsigned nr_args) { -struct io_uring_files_update up; +struct io_uring_rsrc_update up;if (!ctx->file_data)return -ENXIO ;
@@ -9350,7 +9356,7 @@ static void __io_uring_show_fdinfo(struct io_ring_ctx *ctx, struct seq_file *m)seq_printf (m,"SqThreadCpu:\t%d\n" , sq ?task_cpu (sq->thread) :-1 );seq_printf (m,"UserFiles:\t%u\n" , ctx->nr_user_files);for (i =0 ; has_lock && i < ctx->nr_user_files; i++) { -struct fixed_file_table *table; +struct fixed_rsrc_table *table;struct file *f; table = &ctx->file_data->table[i >>IORING_FILE_TABLE_SHIFT ];
include/uapi/linux/io_uring.h +7 -0
@@ -285,12 +285,19 @@ enum {IORING_REGISTER_LAST }; +/* deprecated, see struct io_uring_rsrc_update */ struct io_uring_files_update {__u32 offset;__u32 resv;__aligned_u64 /* __s32 * */ fds; }; +struct io_uring_rsrc_update { +__u32 offset; +__u32 resv; +__aligned_u64 data; +}; +#define IO_URING_OP_SUPPORTED (1U << 0)struct io_uring_probe_op {
Signature · 1 line
2.24.0
PATCH 2/9 io_uring: generalize io_queue_rsrc_removal
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Generalize io_queue_rsrc_removal to handle both files and buffers.
--- fs/io_uring.c | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-)
fs/io_uring.c +15 -7
@@ -195,9 +195,14 @@ struct io_mapped_ubuf {unsigned long acct_pages; }; +struct io_ring_ctx ; +struct io_rsrc_put {struct list_head list; -struct file *file; +union { +void *rsrc; +struct file *file; + }; };struct fixed_rsrc_table {
@@ -209,6 +214,8 @@ struct fixed_rsrc_ref_node {struct list_head node;struct list_head rsrc_list;struct fixed_rsrc_data *rsrc_data; +void (*rsrc_put)(struct io_ring_ctx *ctx, +struct io_rsrc_put *prsrc);struct llist_node llist;bool done; };
@@ -7570,8 +7577,9 @@ static int io_sqe_alloc_file_tables(struct fixed_rsrc_data *file_data,return 1 ; } -static void io_ring_file_put (struct io_ring_ctx *ctx,struct file *file) +static void io_ring_file_put (struct io_ring_ctx *ctx,struct io_rsrc_put *prsrc) { +struct file *file = prsrc->file;#if defined(CONFIG_UNIX )struct sock *sock = ctx->ring_sock->sk;struct sk_buff_head list, *head = &sock->sk_receive_queue;
@@ -7640,7 +7648,7 @@ static void __io_rsrc_put_work(struct fixed_rsrc_ref_node *ref_node)list_for_each_entry_safe (prsrc, tmp, &ref_node->rsrc_list, list) {list_del (&prsrc->list); -io_ring_file_put (ctx, prsrc->file); + ref_node->rsrc_put (ctx, prsrc);kfree (prsrc); }
@@ -7719,6 +7727,7 @@ static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node(INIT_LIST_HEAD (&ref_node->node);INIT_LIST_HEAD (&ref_node->rsrc_list); ref_node->rsrc_data = ctx->file_data; + ref_node->rsrc_put = io_ring_file_put; ref_node->done = false;return ref_node; }
@@ -7876,8 +7885,7 @@ static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,#endif } -static int io_queue_rsrc_removal (struct fixed_rsrc_data *data, -struct file *rsrc) +static int io_queue_rsrc_removal (struct fixed_rsrc_data *data,void *rsrc) {struct io_rsrc_put *prsrc;struct fixed_rsrc_ref_node *ref_node = data->node;
@@ -7886,7 +7894,7 @@ static int io_queue_rsrc_removal(struct fixed_rsrc_data *data,if (!prsrc)return -ENOMEM ; - prsrc->file = rsrc; + prsrc->rsrc = rsrc;list_add (&prsrc->list, &ref_node->rsrc_list);return 0 ;
@@ -7895,7 +7903,7 @@ static int io_queue_rsrc_removal(struct fixed_rsrc_data *data,static inline int io_queue_file_removal (struct fixed_rsrc_data *data,struct file *file) { -return io_queue_rsrc_removal (data, file); +return io_queue_rsrc_removal (data, (void *)file); } static int __io_sqe_files_update(struct io_ring_ctx *ctx,
Signature · 1 line
2.24.0
PATCH 3/9 io_uring: separate ref_list from fixed_rsrc_data
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Uplevel ref_list and make it common to all resources. This is to allow one common ref_list to be used for both files, and buffers in upcoming patches.
--- fs/io_uring.c | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-)
fs/io_uring.c +18 -17
@@ -227,8 +227,6 @@ struct fixed_rsrc_data {struct fixed_rsrc_ref_node *node;struct percpu_ref refs;struct completion done; -struct list_head ref_list; -spinlock_t lock; };struct io_buffer {
@@ -396,6 +394,8 @@ struct io_ring_ctx {struct delayed_work rsrc_put_work;struct llist_head rsrc_put_llist; +struct list_head rsrc_ref_list; +spinlock_t rsrc_ref_lock;struct work_struct exit_work;struct io_restriction restrictions;
@@ -1324,6 +1324,8 @@ static struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)INIT_LIST_HEAD (&ctx->timeout_list);spin_lock_init (&ctx->inflight_lock);INIT_LIST_HEAD (&ctx->inflight_list); +spin_lock_init (&ctx->rsrc_ref_lock); +INIT_LIST_HEAD (&ctx->rsrc_ref_list);INIT_DELAYED_WORK (&ctx->rsrc_put_work, io_rsrc_put_work);init_llist_head (&ctx->rsrc_put_llist);return ctx;
@@ -7272,13 +7274,14 @@ static void io_rsrc_ref_kill(struct percpu_ref *ref)complete (&data->done); } -static void io_sqe_rsrc_set_node (struct fixed_rsrc_data *rsrc_data, +static void io_sqe_rsrc_set_node (struct io_ring_ctx *ctx, +struct fixed_rsrc_data *rsrc_data,struct fixed_rsrc_ref_node *ref_node) { -spin_lock_bh (&rsrc_data->lock); +spin_lock_bh (&ctx->rsrc_ref_lock); rsrc_data->node = ref_node; -list_add_tail (&ref_node->node, &rsrc_data->ref_list); -spin_unlock_bh (&rsrc_data->lock); +list_add_tail (&ref_node->node, &ctx->rsrc_ref_list); +spin_unlock_bh (&ctx->rsrc_ref_lock);percpu_ref_get (&rsrc_data->refs); }
@@ -7295,9 +7298,9 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)if (!backup_node)return -ENOMEM ; -spin_lock_bh (&data->lock); +spin_lock_bh (&ctx->rsrc_ref_lock); ref_node = data->node; -spin_unlock_bh (&data->lock); +spin_unlock_bh (&ctx->rsrc_ref_lock);if (ref_node)percpu_ref_kill (&ref_node->refs);
@@ -7313,7 +7316,7 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)if (ret <0 ) {percpu_ref_resurrect (&data->refs);reinit_completion (&data->done); -io_sqe_rsrc_set_node (data, backup_node); +io_sqe_rsrc_set_node (ctx, data, backup_node);return ret; } }while (1 );
@@ -7687,11 +7690,11 @@ static void io_rsrc_data_ref_zero(struct percpu_ref *ref) data = ref_node->rsrc_data; ctx = data->ctx; -spin_lock_bh (&data->lock); +spin_lock_bh (&ctx->rsrc_ref_lock); ref_node->done = true; -while (!list_empty (&data->ref_list)) { - ref_node =list_first_entry (&data->ref_list, +while (!list_empty (&ctx->rsrc_ref_list)) { + ref_node =list_first_entry (&ctx->rsrc_ref_list, struct fixed_rsrc_ref_node, node);/* recycle ref nodes in order */ if (!ref_node->done)
@@ -7699,7 +7702,7 @@ static void io_rsrc_data_ref_zero(struct percpu_ref *ref)list_del (&ref_node->node); first_add |=llist_add (&ref_node->llist, &ctx->rsrc_put_llist); } -spin_unlock_bh (&data->lock); +spin_unlock_bh (&ctx->rsrc_ref_lock);if (percpu_ref_is_dying (&data->refs)) delay =0 ;
@@ -7760,8 +7763,6 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,return -ENOMEM ; file_data->ctx = ctx;init_completion (&file_data->done); -INIT_LIST_HEAD (&file_data->ref_list); -spin_lock_init (&file_data->lock); nr_tables =DIV_ROUND_UP (nr_args,IORING_MAX_FILES_TABLE ); file_data->table = kcalloc(nr_tables, sizeof(*file_data->table),
@@ -7822,7 +7823,7 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,return -ENOMEM ; } -io_sqe_rsrc_set_node (file_data, ref_node); +io_sqe_rsrc_set_node (ctx, file_data, ref_node);return ret; out_fput:for (i =0 ; i < ctx->nr_user_files; i++) {
@@ -7983,7 +7984,7 @@ static int __io_sqe_files_update(struct io_ring_ctx *ctx,if (needs_switch) {percpu_ref_kill (&data->node->refs); -io_sqe_rsrc_set_node (data, ref_node); +io_sqe_rsrc_set_node (ctx, data, ref_node); }else destroy_fixed_rsrc_ref_node (ref_node);
Signature · 1 line
2.24.0
PATCH 4/9 io_uring: add rsrc_ref locking routines
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Encapsulate resource reference locking into separate routines.
--- fs/io_uring.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-)
fs/io_uring.c +16 -6
@@ -7274,14 +7274,24 @@ static void io_rsrc_ref_kill(struct percpu_ref *ref)complete (&data->done); } +static inline void io_rsrc_ref_lock (struct io_ring_ctx *ctx) +{ +spin_lock_bh (&ctx->rsrc_ref_lock); +} + +static inline void io_rsrc_ref_unlock (struct io_ring_ctx *ctx) +{ +spin_unlock_bh (&ctx->rsrc_ref_lock); +} +static void io_sqe_rsrc_set_node (struct io_ring_ctx *ctx,struct fixed_rsrc_data *rsrc_data,struct fixed_rsrc_ref_node *ref_node) { -spin_lock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_lock (ctx); rsrc_data->node = ref_node;list_add_tail (&ref_node->node, &ctx->rsrc_ref_list); -spin_unlock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_unlock (ctx);percpu_ref_get (&rsrc_data->refs); }
@@ -7298,9 +7308,9 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)if (!backup_node)return -ENOMEM ; -spin_lock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_lock (ctx); ref_node = data->node; -spin_unlock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_unlock (ctx);if (ref_node)percpu_ref_kill (&ref_node->refs);
@@ -7690,7 +7700,7 @@ static void io_rsrc_data_ref_zero(struct percpu_ref *ref) data = ref_node->rsrc_data; ctx = data->ctx; -spin_lock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_lock (ctx); ref_node->done = true;while (!list_empty (&ctx->rsrc_ref_list)) {
@@ -7702,7 +7712,7 @@ static void io_rsrc_data_ref_zero(struct percpu_ref *ref)list_del (&ref_node->node); first_add |=llist_add (&ref_node->llist, &ctx->rsrc_put_llist); } -spin_unlock_bh (&ctx->rsrc_ref_lock); +io_rsrc_ref_unlock (ctx);if (percpu_ref_is_dying (&data->refs)) delay =0 ;
Signature · 1 line
2.24.0
PATCH 5/9 io_uring: split alloc_fixed_file_ref_node
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Split alloc_fixed_file_ref_node into resource generic/specific parts, to be leveraged for fixed buffers.
--- fs/io_uring.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
fs/io_uring.c +14 -2
@@ -7723,7 +7723,7 @@ static void io_rsrc_data_ref_zero(struct percpu_ref *ref)queue_delayed_work (system_wq, &ctx->rsrc_put_work, delay); } -static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node ( +static struct fixed_rsrc_ref_node *alloc_fixed_rsrc_ref_node (struct io_ring_ctx *ctx) {struct fixed_rsrc_ref_node *ref_node;
@@ -7739,9 +7739,21 @@ static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node( }INIT_LIST_HEAD (&ref_node->node);INIT_LIST_HEAD (&ref_node->rsrc_list); + ref_node->done = false; +return ref_node; +} + +static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node ( +struct io_ring_ctx *ctx) +{ +struct fixed_rsrc_ref_node *ref_node; + + ref_node =alloc_fixed_rsrc_ref_node (ctx); +if (!ref_node) +return NULL ; + ref_node->rsrc_data = ctx->file_data; ref_node->rsrc_put = io_ring_file_put; - ref_node->done = false;return ref_node; }
Signature · 1 line
2.24.0
PATCH 6/9 io_uring: split ref_node alloc and init
In reply to Pavel BegunkovA simple prep patch allowing to set refnode callbacks after it was allocated. This needed to 1) keep ourself off of hi-level functions where it's not pretty and they are not necessary 2) amortise ref_node allocation in the future, e.g. for updates.
--- fs/io_uring.c | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-)
fs/io_uring.c +11 -13
@@ -1004,8 +1004,10 @@ enum io_mem_account { };static void destroy_fixed_rsrc_ref_node (struct fixed_rsrc_ref_node *ref_node); -static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node ( +static struct fixed_rsrc_ref_node *alloc_fixed_rsrc_ref_node (struct io_ring_ctx *ctx); +static void init_fixed_file_ref_node (struct io_ring_ctx *ctx, +struct fixed_rsrc_ref_node *ref_node);static void __io_complete_rw (struct io_kiocb *req,long res,long res2,struct io_comp_state *cs);
@@ -7304,9 +7306,10 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)if (!data)return -ENXIO ; - backup_node =alloc_fixed_file_ref_node (ctx); + backup_node =alloc_fixed_rsrc_ref_node (ctx);if (!backup_node)return -ENOMEM ; +init_fixed_file_ref_node (ctx, backup_node);io_rsrc_ref_lock (ctx); ref_node = data->node;
@@ -7743,18 +7746,11 @@ static struct fixed_rsrc_ref_node *alloc_fixed_rsrc_ref_node(return ref_node; } -static struct fixed_rsrc_ref_node *alloc_fixed_file_ref_node ( -struct io_ring_ctx *ctx) +static void init_fixed_file_ref_node (struct io_ring_ctx *ctx, +struct fixed_rsrc_ref_node *ref_node) { -struct fixed_rsrc_ref_node *ref_node; - - ref_node =alloc_fixed_rsrc_ref_node (ctx); -if (!ref_node) -return NULL ; - ref_node->rsrc_data = ctx->file_data; ref_node->rsrc_put = io_ring_file_put; -return ref_node; }static void destroy_fixed_rsrc_ref_node (struct fixed_rsrc_ref_node *ref_node)
@@ -7839,11 +7835,12 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,return ret; } - ref_node =alloc_fixed_file_ref_node (ctx); + ref_node =alloc_fixed_rsrc_ref_node (ctx);if (!ref_node) {io_sqe_files_unregister (ctx);return -ENOMEM ; } +init_fixed_file_ref_node (ctx, ref_node);io_sqe_rsrc_set_node (ctx, file_data, ref_node);return ret;
@@ -7946,9 +7943,10 @@ static int __io_sqe_files_update(struct io_ring_ctx *ctx,if (done > ctx->nr_user_files)return -EINVAL ; - ref_node =alloc_fixed_file_ref_node (ctx); + ref_node =alloc_fixed_rsrc_ref_node (ctx);if (!ref_node)return -ENOMEM ; +init_fixed_file_ref_node (ctx, ref_node); done =0 ; fds =u64_to_user_ptr (up->data);
Signature · 1 line
2.24.0
PATCH 7/9 io_uring: create common fixed_rsrc_ref_node handling routines
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Create common routines to be used for both files/buffers registration.
--- fs/io_uring.c | 38 ++++++++++++++++++++++++++------------ 1 file changed, 26 insertions(+), 12 deletions(-)
fs/io_uring.c +26 -12
@@ -7297,20 +7297,13 @@ static void io_sqe_rsrc_set_node(struct io_ring_ctx *ctx,percpu_ref_get (&rsrc_data->refs); } -static int io_sqe_files_unregister (struct io_ring_ctx *ctx) +static int io_rsrc_ref_quiesce (struct fixed_rsrc_data *data, +struct io_ring_ctx *ctx, +struct fixed_rsrc_ref_node *backup_node) { -struct fixed_rsrc_data *data = ctx->file_data; -struct fixed_rsrc_ref_node *backup_node, *ref_node =NULL ; -unsigned nr_tables, i; +struct fixed_rsrc_ref_node *ref_node;int ret; -if (!data) -return -ENXIO ; - backup_node =alloc_fixed_rsrc_ref_node (ctx); -if (!backup_node) -return -ENOMEM ; -init_fixed_file_ref_node (ctx, backup_node); -io_rsrc_ref_lock (ctx); ref_node = data->node;io_rsrc_ref_unlock (ctx);
@@ -7334,6 +7327,28 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) } }while (1 ); +destroy_fixed_rsrc_ref_node (backup_node); +return 0 ; +} + +static int io_sqe_files_unregister (struct io_ring_ctx *ctx) +{ +struct fixed_rsrc_data *data = ctx->file_data; +struct fixed_rsrc_ref_node *backup_node; +unsigned nr_tables, i; +int ret; + +if (!data) +return -ENXIO ; + backup_node =alloc_fixed_rsrc_ref_node (ctx); +if (!backup_node) +return -ENOMEM ; +init_fixed_file_ref_node (ctx, backup_node); + + ret =io_rsrc_ref_quiesce (data, ctx, backup_node); +if (ret) +return ret; +__io_sqe_files_unregister (ctx); nr_tables =DIV_ROUND_UP (ctx->nr_user_files,IORING_MAX_FILES_TABLE );for (i =0 ; i < nr_tables; i++)
@@ -7343,7 +7358,6 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx)kfree (data); ctx->file_data =NULL ; ctx->nr_user_files =0 ; -destroy_fixed_rsrc_ref_node (backup_node);return 0 ; }
Signature · 1 line
2.24.0
PATCH 8/9 io_uring: create common fixed_rsrc_data allocation routines
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Create common alloc/free fixed_rsrc_data routines for both files and buffers.
--- fs/io_uring.c | 44 +++++++++++++++++++++++++++++--------------- 1 file changed, 29 insertions(+), 15 deletions(-)
fs/io_uring.c +29 -15
@@ -7331,6 +7331,31 @@ static int io_rsrc_ref_quiesce(struct fixed_rsrc_data *data,return 0 ; } +static struct fixed_rsrc_data *alloc_fixed_rsrc_data (struct io_ring_ctx *ctx) +{ +struct fixed_rsrc_data *data; + + data =kzalloc (sizeof (*data),GFP_KERNEL ); +if (!data) +return NULL ; + +if (percpu_ref_init (&data->refs, io_rsrc_ref_kill, +PERCPU_REF_ALLOW_REINIT ,GFP_KERNEL )) { +kfree (data); +return NULL ; + } + data->ctx = ctx; +init_completion (&data->done); +return data; +} + +static void free_fixed_rsrc_data (struct fixed_rsrc_data *data) +{ +percpu_ref_exit (&data->refs); +kfree (data->table); +kfree (data); +} +static int io_sqe_files_unregister (struct io_ring_ctx *ctx) {struct fixed_rsrc_data *data = ctx->file_data;
@@ -7353,9 +7378,7 @@ static int io_sqe_files_unregister(struct io_ring_ctx *ctx) nr_tables =DIV_ROUND_UP (ctx->nr_user_files,IORING_MAX_FILES_TABLE );for (i =0 ; i < nr_tables; i++)kfree (data->table[i].files); -kfree (data->table); -percpu_ref_exit (&data->refs); -kfree (data); +free_fixed_rsrc_data (data); ctx->file_data =NULL ; ctx->nr_user_files =0 ;return 0 ;
@@ -7790,11 +7813,9 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,if (nr_args >IORING_MAX_FIXED_FILES )return -EMFILE ; - file_data =kzalloc (sizeof (*ctx->file_data),GFP_KERNEL ); + file_data =alloc_fixed_rsrc_data (ctx);if (!file_data)return -ENOMEM ; - file_data->ctx = ctx; -init_completion (&file_data->done); nr_tables =DIV_ROUND_UP (nr_args,IORING_MAX_FILES_TABLE ); file_data->table = kcalloc(nr_tables, sizeof(*file_data->table),
@@ -7802,12 +7823,8 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,if (!file_data->table) goto out_free; -if (percpu_ref_init (&file_data->refs, io_rsrc_ref_kill, -PERCPU_REF_ALLOW_REINIT ,GFP_KERNEL )) - goto out_free; -if (io_sqe_alloc_file_tables (file_data, nr_tables, nr_args)) - goto out_ref; + goto out_free; ctx->file_data = file_data;for (i =0 ; i < nr_args; i++, ctx->nr_user_files++) {
@@ -7867,11 +7884,8 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,for (i =0 ; i < nr_tables; i++)kfree (file_data->table[i].files); ctx->nr_user_files =0 ; -out_ref: -percpu_ref_exit (&file_data->refs); out_free: -kfree (file_data->table); -kfree (file_data); +free_fixed_rsrc_data (ctx->file_data); ctx->file_data =NULL ;return ret; }
Signature · 1 line
2.24.0
PATCH 9/9 io_uring: make percpu_ref_release names consistent
In reply to Pavel BegunkovFrom: Bijan Mottahedeh <[email protected]>
Make the percpu ref release function names consistent between rsrc data and nodes.
--- fs/io_uring.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/io_uring.c +4 -4
@@ -7268,7 +7268,7 @@ static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)#endif } -static void io_rsrc_ref_kill (struct percpu_ref *ref) +static void io_rsrc_data_ref_zero (struct percpu_ref *ref) {struct fixed_rsrc_data *data;
@@ -7339,7 +7339,7 @@ static struct fixed_rsrc_data *alloc_fixed_rsrc_data(struct io_ring_ctx *ctx)if (!data)return NULL ; -if (percpu_ref_init (&data->refs, io_rsrc_ref_kill, +if (percpu_ref_init (&data->refs, io_rsrc_data_ref_zero,PERCPU_REF_ALLOW_REINIT ,GFP_KERNEL )) {kfree (data);return NULL ;
@@ -7728,7 +7728,7 @@ static void io_rsrc_put_work(struct work_struct *work) } } -static void io_rsrc_data_ref_zero (struct percpu_ref *ref) +static void io_rsrc_node_ref_zero (struct percpu_ref *ref) {struct fixed_rsrc_ref_node *ref_node;struct fixed_rsrc_data *data;
@@ -7772,7 +7772,7 @@ static struct fixed_rsrc_ref_node *alloc_fixed_rsrc_ref_node(if (!ref_node)return NULL ; -if (percpu_ref_init (&ref_node->refs, io_rsrc_data_ref_zero, +if (percpu_ref_init (&ref_node->refs, io_rsrc_node_ref_zero,0 ,GFP_KERNEL )) {kfree (ref_node);return NULL ;
Signature · 1 line
2.24.0
Quoted 12 lines · Pavel Begunkov
I guess we can agree that generic rsrc handling is a good thing to have, even if we have only files at the moment. This consists of related patches from the Bijan's longer series, doesn't include sharing and buffer bits. I suggest to merge it first. It's approx half of the all changes.
Based on 5.12 with a few pathes from 5.11 cherry-pick to reduce merge conflicts, because of merging/etc. may wait for a week or so for the next rc before potentially being merged. This also addressed tricky merge conflicts where it was applying and compiling well but still buggy.
Quoted 4 lines
Bijan, for the changed patches I also dropped your signed-off, so please reply if you're happy with the new versions so we can add it back. There are change logs (e.g. [did so]) in commit messages of those.
Looks good, thanks. I'll wait for your review of the buffer sharing patch, and once this series is picked up, I'll resend the buffers patches set.
Quoted 25 lines
Mapping to the original v5 series:
1-5/9 (1-5/13 originally), mostly unchanged
6/9 -- my own prep
7/9 (7/13 originally), only file part
8/9 (10/13 originally), only file part
9/9 (11/13 before), unchangedBijan Mottahedeh (8):
io_uring: rename file related variables to rsrc
io_uring: generalizeio_queue_rsrc_removal
io_uring: separateref_listfromfixed_rsrc_data
io_uring: addrsrc_reflocking routines
io_uring: splitalloc_fixed_file_ref_node
io_uring: create commonfixed_rsrc_ref_nodehandling routines
io_uring: create commonfixed_rsrc_dataallocation routines
io_uring: makepercpu_ref_releasenames consistentPavel Begunkov (1):
io_uring: splitref_nodealloc and initfs/io_uring.c | 355 ++++++++++++++++++++-------------- include/uapi/linux/io_uring.h | 7 + 2 files changed, 216 insertions(+), 146 deletions(-)
Jens Axboe
maintainerQuoted 12 lines · Pavel Begunkov
I guess we can agree that generic rsrc handling is a good thing to have, even if we have only files at the moment. This consists of related patches from the Bijan's longer series, doesn't include sharing and buffer bits. I suggest to merge it first. It's approx half of the all changes.
Based on 5.12 with a few pathes from 5.11 cherry-pick to reduce merge conflicts, because of merging/etc. may wait for a week or so for the next rc before potentially being merged. This also addressed tricky merge conflicts where it was applying and compiling well but still buggy.
Quoted 4 lines
Bijan, for the changed patches I also dropped your signed-off, so please reply if you're happy with the new versions so we can add it back. There are change logs (e.g. [did so]) in commit messages of those.
Thanks - I plan on merging this once -rc4 is cut, so we don't have any unnecessary merge conflicts.
Signature · 1 line
Jens Axboe