io_uring/rsrc: hold uring_lock across index-alloc put_user

io_files_update_with_index_alloc() installs a fixed file via
io_fixed_fd_install(), which drops ->uring_lock when the request runs on
io-wq, then put_user()s the allocated slot back to userspace. If that
faults, the error path calls __io_close_fixed() by slot index after
re-taking the lock.

The slot can be closed and reused between the install and that cleanup:
another fixed CLOSE plus open/accept/pipe/socket, or a FILES_UPDATE, can
put an unrelated file into the same slot. The error path then removes
that file instead of the one this request installed, ending an unrelated
file's fixed-table reference early. This is a correctness/DoS issue, not
a use-after-free: fixed-file requests hold an io_rsrc_node reference, so
the node and file stay alive until they are done.

Hold ->uring_lock across __io_fixed_fd_install() and put_user(), and do
the failure cleanup with io_fixed_fd_remove() under the same lock. This
is the same class as the io_pipe_fixed() fix in a3d7ee1128. Faulting
while holding ->uring_lock is fine, the registration paths already do
it.

Fixes: a7c41b4687 ("io_uring: let IORING_OP_FILES_UPDATE support choosing fixed file slots")
Signed-off-by: Yuansheng Yang <[email protected]>
Link: https://patch.msgid.link/[email protected]
[axboe: various touch-ups]
Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Yuansheng Yang
2026-11-04 08:51:32 -07:00
committed by Jens Axboe
parent 699e7ba591
commit d7c7037253
+16 -5
View File
@@ -572,11 +572,12 @@ static int io_files_update_with_index_alloc(struct io_kiocb *req,
{
struct io_rsrc_update *up = io_kiocb_to_cmd(req, struct io_rsrc_update);
__s32 __user *fds = u64_to_user_ptr(up->arg);
struct io_ring_ctx *ctx = req->ctx;
unsigned int done;
struct file *file;
int ret, fd;
if (!req->ctx->file_table.data.nr)
if (!ctx->file_table.data.nr)
return -ENXIO;
for (done = 0; done < up->nr_args; done++) {
@@ -590,15 +591,25 @@ static int io_files_update_with_index_alloc(struct io_kiocb *req,
ret = -EBADF;
break;
}
ret = io_fixed_fd_install(req, issue_flags, file,
IORING_FILE_INDEX_ALLOC);
if (ret < 0)
/*
* Hold the lock across the put_user(), if it's dropped the
* slot can be closed and reused before the error path runs.
*/
io_ring_submit_lock(ctx, issue_flags);
ret = __io_fixed_fd_install(ctx, file,
IORING_FILE_INDEX_ALLOC);
if (ret < 0) {
io_ring_submit_unlock(ctx, issue_flags);
fput(file);
break;
}
if (put_user(ret, &fds[done])) {
__io_close_fixed(req->ctx, issue_flags, ret);
io_fixed_fd_remove(ctx, ret);
io_ring_submit_unlock(ctx, issue_flags);
ret = -EFAULT;
break;
}
io_ring_submit_unlock(ctx, issue_flags);
}
if (done)