2022-05-25 20:42:08 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/slab.h>
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
#include <linux/nospec.h>
|
2022-05-25 20:42:08 +08:00
|
|
|
#include <linux/io_uring.h>
|
|
|
|
|
|
|
|
#include <uapi/linux/io_uring.h>
|
|
|
|
|
|
|
|
#include "io_uring.h"
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
#include "rsrc.h"
|
|
|
|
#include "filetable.h"
|
2024-06-07 02:25:01 +08:00
|
|
|
#include "alloc_cache.h"
|
2022-05-25 20:42:08 +08:00
|
|
|
#include "msg_ring.h"
|
|
|
|
|
2023-01-04 00:05:07 +08:00
|
|
|
/* All valid masks for MSG_RING */
|
|
|
|
#define IORING_MSG_RING_MASK (IORING_MSG_RING_CQE_SKIP | \
|
|
|
|
IORING_MSG_RING_FLAGS_PASS)
|
|
|
|
|
2022-05-25 20:42:08 +08:00
|
|
|
struct io_msg {
|
|
|
|
struct file *file;
|
2022-12-07 11:53:34 +08:00
|
|
|
struct file *src_file;
|
2022-12-07 11:53:36 +08:00
|
|
|
struct callback_head tw;
|
2022-05-25 20:42:08 +08:00
|
|
|
u64 user_data;
|
|
|
|
u32 len;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
u32 cmd;
|
|
|
|
u32 src_fd;
|
2023-01-04 00:05:07 +08:00
|
|
|
union {
|
|
|
|
u32 dst_fd;
|
|
|
|
u32 cqe_flags;
|
|
|
|
};
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
u32 flags;
|
2022-05-25 20:42:08 +08:00
|
|
|
};
|
|
|
|
|
2023-01-20 00:01:27 +08:00
|
|
|
static void io_double_unlock_ctx(struct io_ring_ctx *octx)
|
|
|
|
{
|
|
|
|
mutex_unlock(&octx->uring_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int io_double_lock_ctx(struct io_ring_ctx *octx,
|
|
|
|
unsigned int issue_flags)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* To ensure proper ordering between the two ctxs, we can only
|
|
|
|
* attempt a trylock on the target. If that fails and we already have
|
|
|
|
* the source ctx lock, punt to io-wq.
|
|
|
|
*/
|
|
|
|
if (!(issue_flags & IO_URING_F_UNLOCKED)) {
|
|
|
|
if (!mutex_trylock(&octx->uring_lock))
|
|
|
|
return -EAGAIN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
mutex_lock(&octx->uring_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-12-07 11:53:34 +08:00
|
|
|
void io_msg_ring_cleanup(struct io_kiocb *req)
|
|
|
|
{
|
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!msg->src_file))
|
|
|
|
return;
|
|
|
|
|
|
|
|
fput(msg->src_file);
|
|
|
|
msg->src_file = NULL;
|
|
|
|
}
|
|
|
|
|
2023-01-21 00:38:05 +08:00
|
|
|
static inline bool io_msg_need_remote(struct io_ring_ctx *target_ctx)
|
|
|
|
{
|
2024-05-28 22:40:12 +08:00
|
|
|
return target_ctx->task_complete;
|
2023-01-21 00:38:05 +08:00
|
|
|
}
|
|
|
|
|
2024-03-29 01:00:21 +08:00
|
|
|
static void io_msg_tw_complete(struct io_kiocb *req, struct io_tw_state *ts)
|
2023-01-21 00:38:05 +08:00
|
|
|
{
|
2024-03-29 01:00:21 +08:00
|
|
|
struct io_ring_ctx *ctx = req->ctx;
|
2023-01-21 00:38:05 +08:00
|
|
|
|
2024-03-29 01:00:21 +08:00
|
|
|
io_add_aux_cqe(ctx, req->cqe.user_data, req->cqe.res, req->cqe.flags);
|
2024-06-07 02:25:01 +08:00
|
|
|
if (spin_trylock(&ctx->msg_lock)) {
|
|
|
|
if (io_alloc_cache_put(&ctx->msg_cache, req))
|
|
|
|
req = NULL;
|
|
|
|
spin_unlock(&ctx->msg_lock);
|
|
|
|
}
|
|
|
|
if (req)
|
|
|
|
kfree(req);
|
2024-03-29 01:00:21 +08:00
|
|
|
percpu_ref_put(&ctx->refs);
|
|
|
|
}
|
2023-01-21 00:38:05 +08:00
|
|
|
|
2024-07-01 22:40:29 +08:00
|
|
|
static int io_msg_remote_post(struct io_ring_ctx *ctx, struct io_kiocb *req,
|
|
|
|
int res, u32 cflags, u64 user_data)
|
2024-03-29 01:00:21 +08:00
|
|
|
{
|
2024-07-01 22:40:29 +08:00
|
|
|
req->task = READ_ONCE(ctx->submitter_task);
|
|
|
|
if (!req->task) {
|
|
|
|
kmem_cache_free(req_cachep, req);
|
|
|
|
return -EOWNERDEAD;
|
|
|
|
}
|
2024-03-29 01:00:21 +08:00
|
|
|
req->cqe.user_data = user_data;
|
|
|
|
io_req_set_res(req, res, cflags);
|
|
|
|
percpu_ref_get(&ctx->refs);
|
|
|
|
req->ctx = ctx;
|
|
|
|
req->io_task_work.func = io_msg_tw_complete;
|
|
|
|
io_req_task_work_add_remote(req, ctx, IOU_F_TWQ_LAZY_WAKE);
|
2024-07-01 22:40:29 +08:00
|
|
|
return 0;
|
2023-01-21 00:38:05 +08:00
|
|
|
}
|
|
|
|
|
2024-06-07 02:25:01 +08:00
|
|
|
static struct io_kiocb *io_msg_get_kiocb(struct io_ring_ctx *ctx)
|
|
|
|
{
|
|
|
|
struct io_kiocb *req = NULL;
|
|
|
|
|
|
|
|
if (spin_trylock(&ctx->msg_lock)) {
|
|
|
|
req = io_alloc_cache_get(&ctx->msg_cache);
|
|
|
|
spin_unlock(&ctx->msg_lock);
|
|
|
|
}
|
|
|
|
if (req)
|
|
|
|
return req;
|
|
|
|
return kmem_cache_alloc(req_cachep, GFP_KERNEL | __GFP_NOWARN);
|
|
|
|
}
|
|
|
|
|
2024-03-29 01:00:21 +08:00
|
|
|
static int io_msg_data_remote(struct io_kiocb *req)
|
2022-12-07 11:53:36 +08:00
|
|
|
{
|
|
|
|
struct io_ring_ctx *target_ctx = req->file->private_data;
|
2024-03-29 01:00:21 +08:00
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
|
|
|
struct io_kiocb *target;
|
|
|
|
u32 flags = 0;
|
2022-12-07 11:53:36 +08:00
|
|
|
|
2024-06-07 02:25:01 +08:00
|
|
|
target = io_msg_get_kiocb(req->ctx);
|
2024-03-29 01:00:21 +08:00
|
|
|
if (unlikely(!target))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (msg->flags & IORING_MSG_RING_FLAGS_PASS)
|
|
|
|
flags = msg->cqe_flags;
|
|
|
|
|
2024-07-01 22:40:29 +08:00
|
|
|
return io_msg_remote_post(target_ctx, target, msg->len, flags,
|
|
|
|
msg->user_data);
|
2022-12-07 11:53:36 +08:00
|
|
|
}
|
|
|
|
|
2023-01-20 00:04:40 +08:00
|
|
|
static int io_msg_ring_data(struct io_kiocb *req, unsigned int issue_flags)
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
{
|
|
|
|
struct io_ring_ctx *target_ctx = req->file->private_data;
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
2023-01-04 00:05:07 +08:00
|
|
|
u32 flags = 0;
|
2023-01-20 00:04:40 +08:00
|
|
|
int ret;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
|
2023-01-04 00:05:07 +08:00
|
|
|
if (msg->src_fd || msg->flags & ~IORING_MSG_RING_FLAGS_PASS)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!(msg->flags & IORING_MSG_RING_FLAGS_PASS) && msg->dst_fd)
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
return -EINVAL;
|
2023-01-21 00:38:06 +08:00
|
|
|
if (target_ctx->flags & IORING_SETUP_R_DISABLED)
|
|
|
|
return -EBADFD;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
|
2023-01-21 00:38:05 +08:00
|
|
|
if (io_msg_need_remote(target_ctx))
|
2024-03-29 01:00:21 +08:00
|
|
|
return io_msg_data_remote(req);
|
2022-12-07 11:53:36 +08:00
|
|
|
|
2023-01-04 00:05:07 +08:00
|
|
|
if (msg->flags & IORING_MSG_RING_FLAGS_PASS)
|
|
|
|
flags = msg->cqe_flags;
|
|
|
|
|
2023-01-20 00:04:40 +08:00
|
|
|
ret = -EOVERFLOW;
|
|
|
|
if (target_ctx->flags & IORING_SETUP_IOPOLL) {
|
|
|
|
if (unlikely(io_double_lock_ctx(target_ctx, issue_flags)))
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
2024-03-29 00:42:40 +08:00
|
|
|
if (io_post_aux_cqe(target_ctx, msg->user_data, msg->len, flags))
|
|
|
|
ret = 0;
|
|
|
|
if (target_ctx->flags & IORING_SETUP_IOPOLL)
|
|
|
|
io_double_unlock_ctx(target_ctx);
|
2023-01-20 00:04:40 +08:00
|
|
|
return ret;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
}
|
|
|
|
|
2022-12-07 11:53:34 +08:00
|
|
|
static struct file *io_msg_grab_file(struct io_kiocb *req, unsigned int issue_flags)
|
|
|
|
{
|
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
|
|
|
struct io_ring_ctx *ctx = req->ctx;
|
|
|
|
struct file *file = NULL;
|
|
|
|
int idx = msg->src_fd;
|
|
|
|
|
|
|
|
io_ring_submit_lock(ctx, issue_flags);
|
|
|
|
if (likely(idx < ctx->nr_user_files)) {
|
|
|
|
idx = array_index_nospec(idx, ctx->nr_user_files);
|
2023-06-20 19:32:34 +08:00
|
|
|
file = io_file_from_index(&ctx->file_table, idx);
|
2022-12-07 11:53:34 +08:00
|
|
|
if (file)
|
|
|
|
get_file(file);
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
}
|
2022-12-07 11:53:34 +08:00
|
|
|
io_ring_submit_unlock(ctx, issue_flags);
|
|
|
|
return file;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
}
|
|
|
|
|
2022-12-07 11:53:35 +08:00
|
|
|
static int io_msg_install_complete(struct io_kiocb *req, unsigned int issue_flags)
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
{
|
|
|
|
struct io_ring_ctx *target_ctx = req->file->private_data;
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
2022-12-07 11:53:34 +08:00
|
|
|
struct file *src_file = msg->src_file;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
int ret;
|
|
|
|
|
2022-12-07 11:53:34 +08:00
|
|
|
if (unlikely(io_double_lock_ctx(target_ctx, issue_flags)))
|
|
|
|
return -EAGAIN;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
|
|
|
|
ret = __io_fixed_fd_install(target_ctx, src_file, msg->dst_fd);
|
2022-12-07 11:53:34 +08:00
|
|
|
if (ret < 0)
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
goto out_unlock;
|
2022-12-07 11:53:35 +08:00
|
|
|
|
2022-12-07 11:53:34 +08:00
|
|
|
msg->src_file = NULL;
|
|
|
|
req->flags &= ~REQ_F_NEED_CLEANUP;
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
|
|
|
|
if (msg->flags & IORING_MSG_RING_CQE_SKIP)
|
|
|
|
goto out_unlock;
|
|
|
|
/*
|
|
|
|
* If this fails, the target still received the file descriptor but
|
|
|
|
* wasn't notified of the fact. This means that if this request
|
|
|
|
* completes with -EOVERFLOW, then the sender must ensure that a
|
|
|
|
* later IORING_OP_MSG_RING delivers the message.
|
|
|
|
*/
|
2023-03-16 20:11:42 +08:00
|
|
|
if (!io_post_aux_cqe(target_ctx, msg->user_data, ret, 0))
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
ret = -EOVERFLOW;
|
|
|
|
out_unlock:
|
2023-01-20 00:01:27 +08:00
|
|
|
io_double_unlock_ctx(target_ctx);
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-07 11:53:36 +08:00
|
|
|
static void io_msg_tw_fd_complete(struct callback_head *head)
|
|
|
|
{
|
|
|
|
struct io_msg *msg = container_of(head, struct io_msg, tw);
|
|
|
|
struct io_kiocb *req = cmd_to_io_kiocb(msg);
|
|
|
|
int ret = -EOWNERDEAD;
|
|
|
|
|
|
|
|
if (!(current->flags & PF_EXITING))
|
|
|
|
ret = io_msg_install_complete(req, IO_URING_F_UNLOCKED);
|
|
|
|
if (ret < 0)
|
|
|
|
req_set_fail(req);
|
|
|
|
io_req_queue_tw_complete(req, ret);
|
|
|
|
}
|
|
|
|
|
2024-03-29 01:00:21 +08:00
|
|
|
static int io_msg_fd_remote(struct io_kiocb *req)
|
|
|
|
{
|
|
|
|
struct io_ring_ctx *ctx = req->file->private_data;
|
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
|
|
|
struct task_struct *task = READ_ONCE(ctx->submitter_task);
|
|
|
|
|
|
|
|
if (unlikely(!task))
|
|
|
|
return -EOWNERDEAD;
|
|
|
|
|
|
|
|
init_task_work(&msg->tw, io_msg_tw_fd_complete);
|
|
|
|
if (task_work_add(task, &msg->tw, TWA_SIGNAL))
|
|
|
|
return -EOWNERDEAD;
|
|
|
|
|
|
|
|
return IOU_ISSUE_SKIP_COMPLETE;
|
|
|
|
}
|
|
|
|
|
2022-12-07 11:53:35 +08:00
|
|
|
static int io_msg_send_fd(struct io_kiocb *req, unsigned int issue_flags)
|
|
|
|
{
|
|
|
|
struct io_ring_ctx *target_ctx = req->file->private_data;
|
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
|
|
|
struct io_ring_ctx *ctx = req->ctx;
|
|
|
|
struct file *src_file = msg->src_file;
|
|
|
|
|
2023-03-16 20:11:42 +08:00
|
|
|
if (msg->len)
|
|
|
|
return -EINVAL;
|
2022-12-07 11:53:35 +08:00
|
|
|
if (target_ctx == ctx)
|
|
|
|
return -EINVAL;
|
2023-01-21 00:38:06 +08:00
|
|
|
if (target_ctx->flags & IORING_SETUP_R_DISABLED)
|
|
|
|
return -EBADFD;
|
2022-12-07 11:53:35 +08:00
|
|
|
if (!src_file) {
|
|
|
|
src_file = io_msg_grab_file(req, issue_flags);
|
|
|
|
if (!src_file)
|
|
|
|
return -EBADF;
|
|
|
|
msg->src_file = src_file;
|
|
|
|
req->flags |= REQ_F_NEED_CLEANUP;
|
|
|
|
}
|
2022-12-07 11:53:36 +08:00
|
|
|
|
2023-01-21 00:38:05 +08:00
|
|
|
if (io_msg_need_remote(target_ctx))
|
2024-03-29 01:00:21 +08:00
|
|
|
return io_msg_fd_remote(req);
|
2022-12-07 11:53:35 +08:00
|
|
|
return io_msg_install_complete(req, issue_flags);
|
|
|
|
}
|
|
|
|
|
2022-05-25 20:42:08 +08:00
|
|
|
int io_msg_ring_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
|
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
2022-05-25 20:42:08 +08:00
|
|
|
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
if (unlikely(sqe->buf_index || sqe->personality))
|
2022-05-25 20:42:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2022-12-07 11:53:34 +08:00
|
|
|
msg->src_file = NULL;
|
2022-05-25 20:42:08 +08:00
|
|
|
msg->user_data = READ_ONCE(sqe->off);
|
|
|
|
msg->len = READ_ONCE(sqe->len);
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
msg->cmd = READ_ONCE(sqe->addr);
|
|
|
|
msg->src_fd = READ_ONCE(sqe->addr3);
|
|
|
|
msg->dst_fd = READ_ONCE(sqe->file_index);
|
|
|
|
msg->flags = READ_ONCE(sqe->msg_ring_flags);
|
2023-01-04 00:05:07 +08:00
|
|
|
if (msg->flags & ~IORING_MSG_RING_MASK)
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2022-05-25 20:42:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int io_msg_ring(struct io_kiocb *req, unsigned int issue_flags)
|
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
|
2022-05-25 20:42:08 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = -EBADFD;
|
|
|
|
if (!io_is_uring_fops(req->file))
|
|
|
|
goto done;
|
|
|
|
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
switch (msg->cmd) {
|
|
|
|
case IORING_MSG_DATA:
|
2023-01-20 00:04:40 +08:00
|
|
|
ret = io_msg_ring_data(req, issue_flags);
|
io_uring: add support for passing fixed file descriptors
With IORING_OP_MSG_RING, one ring can send a message to another ring.
Extend that support to also allow sending a fixed file descriptor to
that ring, enabling one ring to pass a registered descriptor to another
one.
Arguments are extended to pass in:
sqe->addr3 fixed file slot in source ring
sqe->file_index fixed file slot in destination ring
IORING_OP_MSG_RING is extended to take a command argument in sqe->addr.
If set to zero (or IORING_MSG_DATA), it sends just a message like before.
If set to IORING_MSG_SEND_FD, a fixed file descriptor is sent according
to the above arguments.
Two common use cases for this are:
1) Server needs to be shutdown or restarted, pass file descriptors to
another onei
2) Backend is split, and one accepts connections, while others then get
the fd passed and handle the actual connection.
Both of those are classic SCM_RIGHTS use cases, and it's not possible to
support them with direct descriptors today.
By default, this will post a CQE to the target ring, similarly to how
IORING_MSG_DATA does it. If IORING_MSG_RING_CQE_SKIP is set, no message
is posted to the target ring. The issuer is expected to notify the
receiver side separately.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-06-13 18:47:02 +08:00
|
|
|
break;
|
|
|
|
case IORING_MSG_SEND_FD:
|
|
|
|
ret = io_msg_send_fd(req, issue_flags);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2022-05-25 20:42:08 +08:00
|
|
|
|
|
|
|
done:
|
2022-12-07 11:53:36 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
if (ret == -EAGAIN || ret == IOU_ISSUE_SKIP_COMPLETE)
|
|
|
|
return ret;
|
2022-05-25 20:42:08 +08:00
|
|
|
req_set_fail(req);
|
2022-12-07 11:53:36 +08:00
|
|
|
}
|
2022-05-25 20:42:08 +08:00
|
|
|
io_req_set_res(req, ret, 0);
|
|
|
|
return IOU_OK;
|
|
|
|
}
|
2024-06-07 02:25:01 +08:00
|
|
|
|
|
|
|
void io_msg_cache_free(const void *entry)
|
|
|
|
{
|
|
|
|
struct io_kiocb *req = (struct io_kiocb *) entry;
|
|
|
|
|
|
|
|
kmem_cache_free(req_cachep, req);
|
|
|
|
}
|