Commit 05f3fb3c authored by Jens Axboe's avatar Jens Axboe

io_uring: avoid ring quiesce for fixed file set unregister and update

We currently fully quiesce the ring before an unregister or update of
the fixed fileset. This is very expensive, and we can be a bit smarter
about this.

Add a percpu refcount for the file tables as a whole. Grab a percpu ref
when we use a registered file, and put it on completion. This is cheap
to do. Upon removal of a file from a set, switch the ref count to atomic
mode. When we hit zero ref on the completion side, then we know we can
drop the previously registered files. When the old files have been
dropped, switch the ref back to percpu mode for normal operation.

Since there's a period between doing the update and the kernel being
done with it, add a IORING_OP_FILES_UPDATE opcode that can perform the
same action. The application knows the update has completed when it gets
the CQE for it. Between doing the update and receiving this completion,
the application must continue to use the unregistered fd if submitting
IO on this particular file.

This takes the runtime of test/file-register from liburing from 14s to
about 0.7s.
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent b5dba59e
...@@ -179,6 +179,21 @@ struct fixed_file_table { ...@@ -179,6 +179,21 @@ struct fixed_file_table {
struct file **files; struct file **files;
}; };
enum {
FFD_F_ATOMIC,
};
struct fixed_file_data {
struct fixed_file_table *table;
struct io_ring_ctx *ctx;
struct percpu_ref refs;
struct llist_head put_llist;
unsigned long state;
struct work_struct ref_work;
struct completion done;
};
struct io_ring_ctx { struct io_ring_ctx {
struct { struct {
struct percpu_ref refs; struct percpu_ref refs;
...@@ -231,7 +246,7 @@ struct io_ring_ctx { ...@@ -231,7 +246,7 @@ struct io_ring_ctx {
* readers must ensure that ->refs is alive as long as the file* is * readers must ensure that ->refs is alive as long as the file* is
* used. Only updated through io_uring_register(2). * used. Only updated through io_uring_register(2).
*/ */
struct fixed_file_table *file_table; struct fixed_file_data *file_data;
unsigned nr_user_files; unsigned nr_user_files;
/* if used, fixed mapped user buffers */ /* if used, fixed mapped user buffers */
...@@ -370,6 +385,13 @@ struct io_open { ...@@ -370,6 +385,13 @@ struct io_open {
int flags; int flags;
}; };
struct io_files_update {
struct file *file;
u64 arg;
u32 nr_args;
u32 offset;
};
struct io_async_connect { struct io_async_connect {
struct sockaddr_storage address; struct sockaddr_storage address;
}; };
...@@ -421,6 +443,7 @@ struct io_kiocb { ...@@ -421,6 +443,7 @@ struct io_kiocb {
struct io_sr_msg sr_msg; struct io_sr_msg sr_msg;
struct io_open open; struct io_open open;
struct io_close close; struct io_close close;
struct io_files_update files_update;
}; };
struct io_async_ctx *io; struct io_async_ctx *io;
...@@ -496,6 +519,9 @@ static void io_double_put_req(struct io_kiocb *req); ...@@ -496,6 +519,9 @@ static void io_double_put_req(struct io_kiocb *req);
static void __io_double_put_req(struct io_kiocb *req); static void __io_double_put_req(struct io_kiocb *req);
static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req); 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,
unsigned nr_args);
static struct kmem_cache *req_cachep; static struct kmem_cache *req_cachep;
...@@ -945,6 +971,7 @@ static void io_free_req_many(struct io_ring_ctx *ctx, void **reqs, int *nr) ...@@ -945,6 +971,7 @@ static void io_free_req_many(struct io_ring_ctx *ctx, void **reqs, int *nr)
if (*nr) { if (*nr) {
kmem_cache_free_bulk(req_cachep, *nr, reqs); kmem_cache_free_bulk(req_cachep, *nr, reqs);
percpu_ref_put_many(&ctx->refs, *nr); percpu_ref_put_many(&ctx->refs, *nr);
percpu_ref_put_many(&ctx->file_data->refs, *nr);
*nr = 0; *nr = 0;
} }
} }
...@@ -955,8 +982,12 @@ static void __io_free_req(struct io_kiocb *req) ...@@ -955,8 +982,12 @@ static void __io_free_req(struct io_kiocb *req)
if (req->io) if (req->io)
kfree(req->io); kfree(req->io);
if (req->file && !(req->flags & REQ_F_FIXED_FILE)) if (req->file) {
if (req->flags & REQ_F_FIXED_FILE)
percpu_ref_put(&ctx->file_data->refs);
else
fput(req->file); fput(req->file);
}
if (req->flags & REQ_F_INFLIGHT) { if (req->flags & REQ_F_INFLIGHT) {
unsigned long flags; unsigned long flags;
...@@ -3293,6 +3324,45 @@ static int io_async_cancel(struct io_kiocb *req, struct io_kiocb **nxt) ...@@ -3293,6 +3324,45 @@ static int io_async_cancel(struct io_kiocb *req, struct io_kiocb **nxt)
return 0; return 0;
} }
static int io_files_update_prep(struct io_kiocb *req,
const struct io_uring_sqe *sqe)
{
if (sqe->flags || 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)
return -EINVAL;
req->files_update.arg = READ_ONCE(sqe->addr);
return 0;
}
static int io_files_update(struct io_kiocb *req, bool force_nonblock)
{
struct io_ring_ctx *ctx = req->ctx;
struct io_uring_files_update up;
int ret;
if (force_nonblock) {
req->work.flags |= IO_WQ_WORK_NEEDS_FILES;
return -EAGAIN;
}
up.offset = req->files_update.offset;
up.fds = req->files_update.arg;
mutex_lock(&ctx->uring_lock);
ret = __io_sqe_files_update(ctx, &up, req->files_update.nr_args);
mutex_unlock(&ctx->uring_lock);
if (ret < 0)
req_set_fail_links(req);
io_cqring_add_event(req, ret);
io_put_req(req);
return 0;
}
static int io_req_defer_prep(struct io_kiocb *req, static int io_req_defer_prep(struct io_kiocb *req,
const struct io_uring_sqe *sqe) const struct io_uring_sqe *sqe)
{ {
...@@ -3354,6 +3424,9 @@ static int io_req_defer_prep(struct io_kiocb *req, ...@@ -3354,6 +3424,9 @@ static int io_req_defer_prep(struct io_kiocb *req,
case IORING_OP_CLOSE: case IORING_OP_CLOSE:
ret = io_close_prep(req, sqe); ret = io_close_prep(req, sqe);
break; break;
case IORING_OP_FILES_UPDATE:
ret = io_files_update_prep(req, sqe);
break;
default: default:
printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n", printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
req->opcode); req->opcode);
...@@ -3532,6 +3605,14 @@ static int io_issue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe, ...@@ -3532,6 +3605,14 @@ static int io_issue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
} }
ret = io_close(req, nxt, force_nonblock); ret = io_close(req, nxt, force_nonblock);
break; break;
case IORING_OP_FILES_UPDATE:
if (sqe) {
ret = io_files_update_prep(req, sqe);
if (ret)
break;
}
ret = io_files_update(req, force_nonblock);
break;
default: default:
ret = -EINVAL; ret = -EINVAL;
break; break;
...@@ -3631,8 +3712,8 @@ static inline struct file *io_file_from_index(struct io_ring_ctx *ctx, ...@@ -3631,8 +3712,8 @@ static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
{ {
struct fixed_file_table *table; struct fixed_file_table *table;
table = &ctx->file_table[index >> IORING_FILE_TABLE_SHIFT]; table = &ctx->file_data->table[index >> IORING_FILE_TABLE_SHIFT];
return table->files[index & IORING_FILE_TABLE_MASK]; return table->files[index & IORING_FILE_TABLE_MASK];;
} }
static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req, static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
...@@ -3653,7 +3734,7 @@ static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req, ...@@ -3653,7 +3734,7 @@ static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
return ret; return ret;
if (flags & IOSQE_FIXED_FILE) { if (flags & IOSQE_FIXED_FILE) {
if (unlikely(!ctx->file_table || if (unlikely(!ctx->file_data ||
(unsigned) fd >= ctx->nr_user_files)) (unsigned) fd >= ctx->nr_user_files))
return -EBADF; return -EBADF;
fd = array_index_nospec(fd, ctx->nr_user_files); fd = array_index_nospec(fd, ctx->nr_user_files);
...@@ -3661,6 +3742,7 @@ static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req, ...@@ -3661,6 +3742,7 @@ static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
if (!req->file) if (!req->file)
return -EBADF; return -EBADF;
req->flags |= REQ_F_FIXED_FILE; req->flags |= REQ_F_FIXED_FILE;
percpu_ref_get(&ctx->file_data->refs);
} else { } else {
if (req->needs_fixed_file) if (req->needs_fixed_file)
return -EBADF; return -EBADF;
...@@ -4338,19 +4420,37 @@ static void __io_sqe_files_unregister(struct io_ring_ctx *ctx) ...@@ -4338,19 +4420,37 @@ static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
#endif #endif
} }
static void io_file_ref_kill(struct percpu_ref *ref)
{
struct fixed_file_data *data;
data = container_of(ref, struct fixed_file_data, refs);
complete(&data->done);
}
static int io_sqe_files_unregister(struct io_ring_ctx *ctx) static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
{ {
struct fixed_file_data *data = ctx->file_data;
unsigned nr_tables, i; unsigned nr_tables, i;
if (!ctx->file_table) if (!data)
return -ENXIO; return -ENXIO;
/* protect against inflight atomic switch, which drops the ref */
flush_work(&data->ref_work);
percpu_ref_get(&data->refs);
percpu_ref_kill_and_confirm(&data->refs, io_file_ref_kill);
wait_for_completion(&data->done);
percpu_ref_put(&data->refs);
percpu_ref_exit(&data->refs);
__io_sqe_files_unregister(ctx); __io_sqe_files_unregister(ctx);
nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE); nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE);
for (i = 0; i < nr_tables; i++) for (i = 0; i < nr_tables; i++)
kfree(ctx->file_table[i].files); kfree(data->table[i].files);
kfree(ctx->file_table); kfree(data->table);
ctx->file_table = NULL; kfree(data);
ctx->file_data = NULL;
ctx->nr_user_files = 0; ctx->nr_user_files = 0;
return 0; return 0;
} }
...@@ -4381,16 +4481,6 @@ static void io_finish_async(struct io_ring_ctx *ctx) ...@@ -4381,16 +4481,6 @@ static void io_finish_async(struct io_ring_ctx *ctx)
} }
#if defined(CONFIG_UNIX) #if defined(CONFIG_UNIX)
static void io_destruct_skb(struct sk_buff *skb)
{
struct io_ring_ctx *ctx = skb->sk->sk_user_data;
if (ctx->io_wq)
io_wq_flush(ctx->io_wq);
unix_destruct_scm(skb);
}
/* /*
* Ensure the UNIX gc is aware of our file set, so we are certain that * Ensure the UNIX gc is aware of our file set, so we are certain that
* the io_uring can be safely unregistered on process exit, even if we have * the io_uring can be safely unregistered on process exit, even if we have
...@@ -4438,7 +4528,7 @@ static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset) ...@@ -4438,7 +4528,7 @@ static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset)
fpl->max = SCM_MAX_FD; fpl->max = SCM_MAX_FD;
fpl->count = nr_files; fpl->count = nr_files;
UNIXCB(skb).fp = fpl; UNIXCB(skb).fp = fpl;
skb->destructor = io_destruct_skb; skb->destructor = unix_destruct_scm;
refcount_add(skb->truesize, &sk->sk_wmem_alloc); refcount_add(skb->truesize, &sk->sk_wmem_alloc);
skb_queue_head(&sk->sk_receive_queue, skb); skb_queue_head(&sk->sk_receive_queue, skb);
...@@ -4500,7 +4590,7 @@ static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables, ...@@ -4500,7 +4590,7 @@ static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
int i; int i;
for (i = 0; i < nr_tables; i++) { for (i = 0; i < nr_tables; i++) {
struct fixed_file_table *table = &ctx->file_table[i]; struct fixed_file_table *table = &ctx->file_data->table[i];
unsigned this_files; unsigned this_files;
this_files = min(nr_files, IORING_MAX_FILES_TABLE); this_files = min(nr_files, IORING_MAX_FILES_TABLE);
...@@ -4515,36 +4605,159 @@ static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables, ...@@ -4515,36 +4605,159 @@ static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
return 0; return 0;
for (i = 0; i < nr_tables; i++) { for (i = 0; i < nr_tables; i++) {
struct fixed_file_table *table = &ctx->file_table[i]; struct fixed_file_table *table = &ctx->file_data->table[i];
kfree(table->files); kfree(table->files);
} }
return 1; return 1;
} }
static void io_ring_file_put(struct io_ring_ctx *ctx, struct file *file)
{
#if defined(CONFIG_UNIX)
struct sock *sock = ctx->ring_sock->sk;
struct sk_buff_head list, *head = &sock->sk_receive_queue;
struct sk_buff *skb;
int i;
__skb_queue_head_init(&list);
/*
* Find the skb that holds this file in its SCM_RIGHTS. When found,
* remove this entry and rearrange the file array.
*/
skb = skb_dequeue(head);
while (skb) {
struct scm_fp_list *fp;
fp = UNIXCB(skb).fp;
for (i = 0; i < fp->count; i++) {
int left;
if (fp->fp[i] != file)
continue;
unix_notinflight(fp->user, fp->fp[i]);
left = fp->count - 1 - i;
if (left) {
memmove(&fp->fp[i], &fp->fp[i + 1],
left * sizeof(struct file *));
}
fp->count--;
if (!fp->count) {
kfree_skb(skb);
skb = NULL;
} else {
__skb_queue_tail(&list, skb);
}
fput(file);
file = NULL;
break;
}
if (!file)
break;
__skb_queue_tail(&list, skb);
skb = skb_dequeue(head);
}
if (skb_peek(&list)) {
spin_lock_irq(&head->lock);
while ((skb = __skb_dequeue(&list)) != NULL)
__skb_queue_tail(head, skb);
spin_unlock_irq(&head->lock);
}
#else
fput(file);
#endif
}
struct io_file_put {
struct llist_node llist;
struct file *file;
struct completion *done;
};
static void io_ring_file_ref_switch(struct work_struct *work)
{
struct io_file_put *pfile, *tmp;
struct fixed_file_data *data;
struct llist_node *node;
data = container_of(work, struct fixed_file_data, ref_work);
while ((node = llist_del_all(&data->put_llist)) != NULL) {
llist_for_each_entry_safe(pfile, tmp, node, llist) {
io_ring_file_put(data->ctx, pfile->file);
if (pfile->done)
complete(pfile->done);
else
kfree(pfile);
}
}
percpu_ref_get(&data->refs);
percpu_ref_switch_to_percpu(&data->refs);
}
static void io_file_data_ref_zero(struct percpu_ref *ref)
{
struct fixed_file_data *data;
data = container_of(ref, struct fixed_file_data, refs);
/* we can't safely switch from inside this context, punt to wq */
queue_work(system_wq, &data->ref_work);
}
static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
unsigned nr_args) unsigned nr_args)
{ {
__s32 __user *fds = (__s32 __user *) arg; __s32 __user *fds = (__s32 __user *) arg;
unsigned nr_tables; unsigned nr_tables;
struct file *file;
int fd, ret = 0; int fd, ret = 0;
unsigned i; unsigned i;
if (ctx->file_table) if (ctx->file_data)
return -EBUSY; return -EBUSY;
if (!nr_args) if (!nr_args)
return -EINVAL; return -EINVAL;
if (nr_args > IORING_MAX_FIXED_FILES) if (nr_args > IORING_MAX_FIXED_FILES)
return -EMFILE; return -EMFILE;
ctx->file_data = kzalloc(sizeof(*ctx->file_data), GFP_KERNEL);
if (!ctx->file_data)
return -ENOMEM;
ctx->file_data->ctx = ctx;
init_completion(&ctx->file_data->done);
nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE); nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE);
ctx->file_table = kcalloc(nr_tables, sizeof(struct fixed_file_table), ctx->file_data->table = kcalloc(nr_tables,
sizeof(struct fixed_file_table),
GFP_KERNEL); GFP_KERNEL);
if (!ctx->file_table) if (!ctx->file_data->table) {
kfree(ctx->file_data);
ctx->file_data = NULL;
return -ENOMEM; return -ENOMEM;
}
if (percpu_ref_init(&ctx->file_data->refs, io_file_data_ref_zero,
PERCPU_REF_ALLOW_REINIT, GFP_KERNEL)) {
kfree(ctx->file_data->table);
kfree(ctx->file_data);
ctx->file_data = NULL;
return -ENOMEM;
}
ctx->file_data->put_llist.first = NULL;
INIT_WORK(&ctx->file_data->ref_work, io_ring_file_ref_switch);
if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) { if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) {
kfree(ctx->file_table); percpu_ref_exit(&ctx->file_data->refs);
ctx->file_table = NULL; kfree(ctx->file_data->table);
kfree(ctx->file_data);
ctx->file_data = NULL;
return -ENOMEM; return -ENOMEM;
} }
...@@ -4561,13 +4774,14 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, ...@@ -4561,13 +4774,14 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
continue; continue;
} }
table = &ctx->file_table[i >> IORING_FILE_TABLE_SHIFT]; table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
index = i & IORING_FILE_TABLE_MASK; index = i & IORING_FILE_TABLE_MASK;
table->files[index] = fget(fd); file = fget(fd);
ret = -EBADF; ret = -EBADF;
if (!table->files[index]) if (!file)
break; break;
/* /*
* Don't allow io_uring instances to be registered. If UNIX * Don't allow io_uring instances to be registered. If UNIX
* isn't enabled, then this causes a reference cycle and this * isn't enabled, then this causes a reference cycle and this
...@@ -4575,26 +4789,26 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, ...@@ -4575,26 +4789,26 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
* handle it just fine, but there's still no point in allowing * handle it just fine, but there's still no point in allowing
* a ring fd as it doesn't support regular read/write anyway. * a ring fd as it doesn't support regular read/write anyway.
*/ */
if (table->files[index]->f_op == &io_uring_fops) { if (file->f_op == &io_uring_fops) {
fput(table->files[index]); fput(file);
break; break;
} }
ret = 0; ret = 0;
table->files[index] = file;
} }
if (ret) { if (ret) {
for (i = 0; i < ctx->nr_user_files; i++) { for (i = 0; i < ctx->nr_user_files; i++) {
struct file *file;
file = io_file_from_index(ctx, i); file = io_file_from_index(ctx, i);
if (file) if (file)
fput(file); fput(file);
} }
for (i = 0; i < nr_tables; i++) for (i = 0; i < nr_tables; i++)
kfree(ctx->file_table[i].files); kfree(ctx->file_data->table[i].files);
kfree(ctx->file_table); kfree(ctx->file_data->table);
ctx->file_table = NULL; kfree(ctx->file_data);
ctx->file_data = NULL;
ctx->nr_user_files = 0; ctx->nr_user_files = 0;
return ret; return ret;
} }
...@@ -4606,69 +4820,6 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, ...@@ -4606,69 +4820,6 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
return ret; return ret;
} }
static void io_sqe_file_unregister(struct io_ring_ctx *ctx, int index)
{
#if defined(CONFIG_UNIX)
struct file *file = io_file_from_index(ctx, index);
struct sock *sock = ctx->ring_sock->sk;
struct sk_buff_head list, *head = &sock->sk_receive_queue;
struct sk_buff *skb;
int i;
__skb_queue_head_init(&list);
/*
* Find the skb that holds this file in its SCM_RIGHTS. When found,
* remove this entry and rearrange the file array.
*/
skb = skb_dequeue(head);
while (skb) {
struct scm_fp_list *fp;
fp = UNIXCB(skb).fp;
for (i = 0; i < fp->count; i++) {
int left;
if (fp->fp[i] != file)
continue;
unix_notinflight(fp->user, fp->fp[i]);
left = fp->count - 1 - i;
if (left) {
memmove(&fp->fp[i], &fp->fp[i + 1],
left * sizeof(struct file *));
}
fp->count--;
if (!fp->count) {
kfree_skb(skb);
skb = NULL;
} else {
__skb_queue_tail(&list, skb);
}
fput(file);
file = NULL;
break;
}
if (!file)
break;
__skb_queue_tail(&list, skb);
skb = skb_dequeue(head);
}
if (skb_peek(&list)) {
spin_lock_irq(&head->lock);
while ((skb = __skb_dequeue(&list)) != NULL)
__skb_queue_tail(head, skb);
spin_unlock_irq(&head->lock);
}
#else
fput(io_file_from_index(ctx, index));
#endif
}
static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file, static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
int index) int index)
{ {
...@@ -4712,29 +4863,65 @@ static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file, ...@@ -4712,29 +4863,65 @@ static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
#endif #endif
} }
static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg, static void io_atomic_switch(struct percpu_ref *ref)
{
struct fixed_file_data *data;
data = container_of(ref, struct fixed_file_data, refs);
clear_bit(FFD_F_ATOMIC, &data->state);
}
static bool io_queue_file_removal(struct fixed_file_data *data,
struct file *file)
{
struct io_file_put *pfile, pfile_stack;
DECLARE_COMPLETION_ONSTACK(done);
/*
* If we fail allocating the struct we need for doing async reomval
* of this file, just punt to sync and wait for it.
*/
pfile = kzalloc(sizeof(*pfile), GFP_KERNEL);
if (!pfile) {
pfile = &pfile_stack;
pfile->done = &done;
}
pfile->file = file;
llist_add(&pfile->llist, &data->put_llist);
if (pfile == &pfile_stack) {
if (!test_and_set_bit(FFD_F_ATOMIC, &data->state)) {
percpu_ref_put(&data->refs);
percpu_ref_switch_to_atomic(&data->refs,
io_atomic_switch);
}
wait_for_completion(&done);
flush_work(&data->ref_work);
return false;
}
return true;
}
static int __io_sqe_files_update(struct io_ring_ctx *ctx,
struct io_uring_files_update *up,
unsigned nr_args) unsigned nr_args)
{ {
struct io_uring_files_update up; struct fixed_file_data *data = ctx->file_data;
bool ref_switch = false;
struct file *file;
__s32 __user *fds; __s32 __user *fds;
int fd, i, err; int fd, i, err;
__u32 done; __u32 done;
if (!ctx->file_table) if (check_add_overflow(up->offset, nr_args, &done))
return -ENXIO;
if (!nr_args)
return -EINVAL;
if (copy_from_user(&up, arg, sizeof(up)))
return -EFAULT;
if (up.resv)
return -EINVAL;
if (check_add_overflow(up.offset, nr_args, &done))
return -EOVERFLOW; return -EOVERFLOW;
if (done > ctx->nr_user_files) if (done > ctx->nr_user_files)
return -EINVAL; return -EINVAL;
done = 0; done = 0;
fds = u64_to_user_ptr(up.fds); fds = u64_to_user_ptr(up->fds);
while (nr_args) { while (nr_args) {
struct fixed_file_table *table; struct fixed_file_table *table;
unsigned index; unsigned index;
...@@ -4744,16 +4931,16 @@ static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg, ...@@ -4744,16 +4931,16 @@ static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
err = -EFAULT; err = -EFAULT;
break; break;
} }
i = array_index_nospec(up.offset, ctx->nr_user_files); i = array_index_nospec(up->offset, ctx->nr_user_files);
table = &ctx->file_table[i >> IORING_FILE_TABLE_SHIFT]; table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
index = i & IORING_FILE_TABLE_MASK; index = i & IORING_FILE_TABLE_MASK;
if (table->files[index]) { if (table->files[index]) {
io_sqe_file_unregister(ctx, i); file = io_file_from_index(ctx, index);
table->files[index] = NULL; table->files[index] = NULL;
if (io_queue_file_removal(data, file))
ref_switch = true;
} }
if (fd != -1) { if (fd != -1) {
struct file *file;
file = fget(fd); file = fget(fd);
if (!file) { if (!file) {
err = -EBADF; err = -EBADF;
...@@ -4779,11 +4966,32 @@ static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg, ...@@ -4779,11 +4966,32 @@ static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
} }
nr_args--; nr_args--;
done++; done++;
up.offset++; up->offset++;
}
if (ref_switch && !test_and_set_bit(FFD_F_ATOMIC, &data->state)) {
percpu_ref_put(&data->refs);
percpu_ref_switch_to_atomic(&data->refs, io_atomic_switch);
} }
return done ? done : err; return done ? done : err;
} }
static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
unsigned nr_args)
{
struct io_uring_files_update up;
if (!ctx->file_data)
return -ENXIO;
if (!nr_args)
return -EINVAL;
if (copy_from_user(&up, arg, sizeof(up)))
return -EFAULT;
if (up.resv)
return -EINVAL;
return __io_sqe_files_update(ctx, &up, nr_args);
}
static void io_put_work(struct io_wq_work *work) static void io_put_work(struct io_wq_work *work)
{ {
...@@ -5546,7 +5754,6 @@ static int io_uring_get_fd(struct io_ring_ctx *ctx) ...@@ -5546,7 +5754,6 @@ static int io_uring_get_fd(struct io_ring_ctx *ctx)
#if defined(CONFIG_UNIX) #if defined(CONFIG_UNIX)
ctx->ring_sock->file = file; ctx->ring_sock->file = file;
ctx->ring_sock->sk->sk_user_data = ctx;
#endif #endif
fd_install(ret, file); fd_install(ret, file);
return ret; return ret;
...@@ -5710,18 +5917,22 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode, ...@@ -5710,18 +5917,22 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
if (percpu_ref_is_dying(&ctx->refs)) if (percpu_ref_is_dying(&ctx->refs))
return -ENXIO; return -ENXIO;
if (opcode != IORING_UNREGISTER_FILES &&
opcode != IORING_REGISTER_FILES_UPDATE) {
percpu_ref_kill(&ctx->refs); percpu_ref_kill(&ctx->refs);
/* /*
* Drop uring mutex before waiting for references to exit. If another * Drop uring mutex before waiting for references to exit. If
* thread is currently inside io_uring_enter() it might need to grab * another thread is currently inside io_uring_enter() it might
* the uring_lock to make progress. If we hold it here across the drain * need to grab the uring_lock to make progress. If we hold it
* wait, then we can deadlock. It's safe to drop the mutex here, since * here across the drain wait, then we can deadlock. It's safe
* no new references will come in after we've killed the percpu ref. * to drop the mutex here, since no new references will come in
* after we've killed the percpu ref.
*/ */
mutex_unlock(&ctx->uring_lock); mutex_unlock(&ctx->uring_lock);
wait_for_completion(&ctx->completions[0]); wait_for_completion(&ctx->completions[0]);
mutex_lock(&ctx->uring_lock); mutex_lock(&ctx->uring_lock);
}
switch (opcode) { switch (opcode) {
case IORING_REGISTER_BUFFERS: case IORING_REGISTER_BUFFERS:
...@@ -5762,9 +5973,13 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode, ...@@ -5762,9 +5973,13 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
break; break;
} }
if (opcode != IORING_UNREGISTER_FILES &&
opcode != IORING_REGISTER_FILES_UPDATE) {
/* bring the ctx back to life */ /* bring the ctx back to life */
reinit_completion(&ctx->completions[0]); reinit_completion(&ctx->completions[0]);
percpu_ref_reinit(&ctx->refs); percpu_ref_reinit(&ctx->refs);
}
return ret; return ret;
} }
......
...@@ -80,6 +80,7 @@ enum { ...@@ -80,6 +80,7 @@ enum {
IORING_OP_FALLOCATE, IORING_OP_FALLOCATE,
IORING_OP_OPENAT, IORING_OP_OPENAT,
IORING_OP_CLOSE, IORING_OP_CLOSE,
IORING_OP_FILES_UPDATE,
/* this goes last, obviously */ /* this goes last, obviously */
IORING_OP_LAST, IORING_OP_LAST,
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment