This adds support for open_by_handle_at(2) to io_uring.
First an attempt to do a non-blocking open by handle is made. If that
fails, for example, because the target inode is not cached, a blocking
attempt is made.
Signed-off-by: Thomas Bertschinger <tahbertschinger@xxxxxxxxx>
---
include/uapi/linux/io_uring.h | 1 +
io_uring/opdef.c | 15 +++++
io_uring/openclose.c | 111 ++++++++++++++++++++++++++++++++++
io_uring/openclose.h | 8 +++
4 files changed, 135 insertions(+)
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index a4aa83ad9527..c571929e7807 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -291,6 +291,7 @@ enum io_uring_op {
IORING_OP_WRITEV_FIXED,
IORING_OP_PIPE,
IORING_OP_NAME_TO_HANDLE_AT,
+ IORING_OP_OPEN_BY_HANDLE_AT,
/* this goes last, obviously */
IORING_OP_LAST,
diff --git a/io_uring/opdef.c b/io_uring/opdef.c
index 76306c9e0ecd..1aa36f3f30de 100644
--- a/io_uring/opdef.c
+++ b/io_uring/opdef.c
@@ -580,6 +580,15 @@ const struct io_issue_def io_issue_defs[] = {
.issue = io_name_to_handle_at,
#else
.prep = io_eopnotsupp_prep,
+#endif
+ },
+ [IORING_OP_OPEN_BY_HANDLE_AT] = {
+#if defined(CONFIG_FHANDLE)
+ .prep = io_open_by_handle_at_prep,
+ .issue = io_open_by_handle_at,
+ .async_size = sizeof(struct io_open_handle_async),
+#else
+ .prep = io_eopnotsupp_prep,
#endif
},
};
@@ -835,6 +844,12 @@ const struct io_cold_def io_cold_defs[] = {
[IORING_OP_NAME_TO_HANDLE_AT] = {
.name = "NAME_TO_HANDLE_AT",
},
+ [IORING_OP_OPEN_BY_HANDLE_AT] = {
+ .name = "OPEN_BY_HANDLE_AT",
+#if defined(CONFIG_FHANDLE)
+ .cleanup = io_open_by_handle_cleanup,
+#endif
+ }
};
const char *io_uring_get_opcode(u8 opcode)
diff --git a/io_uring/openclose.c b/io_uring/openclose.c
index 4da2afdb9773..dbc883f4654c 100644
--- a/io_uring/openclose.c
+++ b/io_uring/openclose.c
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/errno.h>
+#include <linux/exportfs.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/fdtable.h>
@@ -245,6 +246,116 @@ int io_name_to_handle_at(struct io_kiocb *req, unsigned int issue_flags)
io_req_set_res(req, ret, 0);
return IOU_COMPLETE;
}
+
+int io_open_by_handle_at_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
+{
+ struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
+ struct io_open_handle_async *ah;
+ u64 flags;
+ int ret;
+
+ flags = READ_ONCE(sqe->open_flags);
+ open->how = build_open_how(flags, 0);
+
+ ret = __io_open_prep(req, sqe);
+ if (ret)
+ return ret;
+
+ ah = io_uring_alloc_async_data(NULL, req);
+ if (!ah)
+ return -ENOMEM;
+ memset(&ah->path, 0, sizeof(ah->path));
+ ah->handle = get_user_handle(u64_to_user_ptr(READ_ONCE(sqe->addr)));
+ if (IS_ERR(ah->handle))
+ return PTR_ERR(ah->handle);
+
+ req->flags |= REQ_F_NEED_CLEANUP;
+
+ return 0;
+}
+
+int io_open_by_handle_at(struct io_kiocb *req, unsigned int issue_flags)
+{
+ struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
+ struct io_open_handle_async *ah = req->async_data;
+ bool nonblock_set = open->how.flags & O_NONBLOCK;
+ bool fixed = !!open->file_slot;
+ struct file *file;
+ struct open_flags op;
+ int ret;
+
+ ret = build_open_flags(&open->how, &op);
+ if (ret)
+ goto err;
+
+ if (issue_flags & IO_URING_F_NONBLOCK)
+ ah->handle->handle_type |= FILEID_CACHED;
+ else
+ ah->handle->handle_type &= ~FILEID_CACHED;
+
+ if (!ah->path.dentry) {
+ /*
+ * Handle has not yet been converted to path, either because
+ * this is our first try, or because we tried previously with
+ * IO_URING_F_NONBLOCK set, and failed.
+ */
+ ret = handle_to_path(open->dfd, ah->handle, &ah->path, op.open_flag);
+ if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
+ return -EAGAIN;
+
+ if (ret)
+ goto err;
+ }
+
+ if (!fixed) {
+ ret = __get_unused_fd_flags(open->how.flags, open->nofile);
+ if (ret < 0)
+ goto err;
+ }
+
+ if (issue_flags & IO_URING_F_NONBLOCK) {
+ WARN_ON_ONCE(io_openat_force_async(open));
+ op.lookup_flags |= LOOKUP_CACHED;
+ op.open_flag |= O_NONBLOCK;
+ }
+ file = do_filp_path_open(&ah->path, &op);
+
+ if (IS_ERR(file)) {
+ if (!fixed)
+ put_unused_fd(ret);
+ ret = PTR_ERR(file);
+ if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
+ return -EAGAIN;
+ goto err;
+ }
+
+ if ((issue_flags & IO_URING_F_NONBLOCK) && !nonblock_set)
+ file->f_flags &= ~O_NONBLOCK;
+
+ if (!fixed)
+ fd_install(ret, file);
+ else
+ ret = io_fixed_fd_install(req, issue_flags, file,
+ open->file_slot);
+
+err:
+ io_open_by_handle_cleanup(req);
+ req->flags &= ~REQ_F_NEED_CLEANUP;
+ if (ret < 0)
+ req_set_fail(req);
+ io_req_set_res(req, ret, 0);
+ return IOU_COMPLETE;
+}
+
+void io_open_by_handle_cleanup(struct io_kiocb *req)
+{
+ struct io_open_handle_async *ah = req->async_data;
+ if (ah->path.dentry) {
+ path_put(&ah->path);
+ }
+
+ kfree(ah->handle);
+}
#endif /* CONFIG_FHANDLE */
int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
diff --git a/io_uring/openclose.h b/io_uring/openclose.h
index 2fc1c8d35d0b..f966859a8a92 100644
--- a/io_uring/openclose.h
+++ b/io_uring/openclose.h
@@ -10,9 +10,17 @@ void io_open_cleanup(struct io_kiocb *req);
int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
int io_openat2(struct io_kiocb *req, unsigned int issue_flags);
+struct io_open_handle_async {
+ struct file_handle *handle;
+ struct path path;
+};
+
#if defined(CONFIG_FHANDLE)
int io_name_to_handle_at_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
int io_name_to_handle_at(struct io_kiocb *req, unsigned int issue_flags);
+int io_open_by_handle_at_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
+int io_open_by_handle_at(struct io_kiocb *req, unsigned int issue_flags);
+void io_open_by_handle_cleanup(struct io_kiocb *req);
#endif /* CONFIG_FHANDLE */
int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
--
2.51.0
