io_uring/msg_ring.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/errno.h>
   4 #include <linux/file.h>
   5 #include <linux/slab.h>
   6 #include <linux/nospec.h>
   7 #include <linux/io_uring.h>
   8
   9 #include <uapi/linux/io_uring.h>
  10
  11 #include "io_uring.h"
  12 #include "rsrc.h"
  13 #include "filetable.h"
  14 #include "msg_ring.h"
  15
  16 struct io_msg {
  17         struct file                     *file;
  18         struct file                     *src_file;
  19         u64 user_data;
  20         u32 len;
  21         u32 cmd;
  22         u32 src_fd;
  23         u32 dst_fd;
  24         u32 flags;
  25 };
  26
  27 static void io_double_unlock_ctx(struct io_ring_ctx *octx)
  28 {
  29         mutex_unlock(&octx->uring_lock);
  30 }
  31
  32 static int io_double_lock_ctx(struct io_ring_ctx *octx,
  33                               unsigned int issue_flags)
  34 {
  35         /*
  36          * To ensure proper ordering between the two ctxs, we can only
  37          * attempt a trylock on the target. If that fails and we already have
  38          * the source ctx lock, punt to io-wq.
  39          */
  40         if (!(issue_flags & IO_URING_F_UNLOCKED)) {
  41                 if (!mutex_trylock(&octx->uring_lock))
  42                         return -EAGAIN;
  43                 return 0;
  44         }
  45         mutex_lock(&octx->uring_lock);
  46         return 0;
  47 }
  48
  49 void io_msg_ring_cleanup(struct io_kiocb *req)
  50 {
  51         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
  52
  53         if (WARN_ON_ONCE(!msg->src_file))
  54                 return;
  55
  56         fput(msg->src_file);
  57         msg->src_file = NULL;
  58 }
  59
  60 static int io_msg_ring_data(struct io_kiocb *req)
  61 {
  62         struct io_ring_ctx *target_ctx = req->file->private_data;
  63         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
  64
  65         if (msg->src_fd || msg->dst_fd || msg->flags)
  66                 return -EINVAL;
  67         if (target_ctx->flags & IORING_SETUP_R_DISABLED)
  68                 return -EBADFD;
  69
  70         if (io_post_aux_cqe(target_ctx, msg->user_data, msg->len, 0, true))
  71                 return 0;
  72
  73         return -EOVERFLOW;
  74 }
  75
  76 static struct file *io_msg_grab_file(struct io_kiocb *req, unsigned int issue_flags)
  77 {
  78         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
  79         struct io_ring_ctx *ctx = req->ctx;
  80         struct file *file = NULL;
  81         unsigned long file_ptr;
  82         int idx = msg->src_fd;
  83
  84         io_ring_submit_lock(ctx, issue_flags);
  85         if (likely(idx < ctx->nr_user_files)) {
  86                 idx = array_index_nospec(idx, ctx->nr_user_files);
  87                 file_ptr = io_fixed_file_slot(&ctx->file_table, idx)->file_ptr;
  88                 file = (struct file *) (file_ptr & FFS_MASK);
  89                 if (file)
  90                         get_file(file);
  91         }
  92         io_ring_submit_unlock(ctx, issue_flags);
  93         return file;
  94 }
  95
  96 static int io_msg_install_complete(struct io_kiocb *req, unsigned int issue_flags)
  97 {
  98         struct io_ring_ctx *target_ctx = req->file->private_data;
  99         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
 100         struct file *src_file = msg->src_file;
 101         int ret;
 102
 103         if (unlikely(io_double_lock_ctx(target_ctx, issue_flags)))
 104                 return -EAGAIN;
 105
 106         ret = __io_fixed_fd_install(target_ctx, src_file, msg->dst_fd);
 107         if (ret < 0)
 108                 goto out_unlock;
 109
 110         msg->src_file = NULL;
 111         req->flags &= ~REQ_F_NEED_CLEANUP;
 112
 113         if (msg->flags & IORING_MSG_RING_CQE_SKIP)
 114                 goto out_unlock;
 115         /*
 116          * If this fails, the target still received the file descriptor but
 117          * wasn't notified of the fact. This means that if this request
 118          * completes with -EOVERFLOW, then the sender must ensure that a
 119          * later IORING_OP_MSG_RING delivers the message.
 120          */
 121         if (!io_post_aux_cqe(target_ctx, msg->user_data, ret, 0, true))
 122                 ret = -EOVERFLOW;
 123 out_unlock:
 124         io_double_unlock_ctx(target_ctx);
 125         return ret;
 126 }
 127
 128 static int io_msg_send_fd(struct io_kiocb *req, unsigned int issue_flags)
 129 {
 130         struct io_ring_ctx *target_ctx = req->file->private_data;
 131         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
 132         struct io_ring_ctx *ctx = req->ctx;
 133         struct file *src_file = msg->src_file;
 134
 135         if (target_ctx == ctx)
 136                 return -EINVAL;
 137         if (!src_file) {
 138                 src_file = io_msg_grab_file(req, issue_flags);
 139                 if (!src_file)
 140                         return -EBADF;
 141                 msg->src_file = src_file;
 142                 req->flags |= REQ_F_NEED_CLEANUP;
 143         }
 144         return io_msg_install_complete(req, issue_flags);
 145 }
 146
 147 int io_msg_ring_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 148 {
 149         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
 150
 151         if (unlikely(sqe->buf_index || sqe->personality))
 152                 return -EINVAL;
 153
 154         msg->src_file = NULL;
 155         msg->user_data = READ_ONCE(sqe->off);
 156         msg->len = READ_ONCE(sqe->len);
 157         msg->cmd = READ_ONCE(sqe->addr);
 158         msg->src_fd = READ_ONCE(sqe->addr3);
 159         msg->dst_fd = READ_ONCE(sqe->file_index);
 160         msg->flags = READ_ONCE(sqe->msg_ring_flags);
 161         if (msg->flags & ~IORING_MSG_RING_CQE_SKIP)
 162                 return -EINVAL;
 163
 164         return 0;
 165 }
 166
 167 int io_msg_ring(struct io_kiocb *req, unsigned int issue_flags)
 168 {
 169         struct io_msg *msg = io_kiocb_to_cmd(req, struct io_msg);
 170         int ret;
 171
 172         ret = -EBADFD;
 173         if (!io_is_uring_fops(req->file))
 174                 goto done;
 175
 176         switch (msg->cmd) {
 177         case IORING_MSG_DATA:
 178                 ret = io_msg_ring_data(req);
 179                 break;
 180         case IORING_MSG_SEND_FD:
 181                 ret = io_msg_send_fd(req, issue_flags);
 182                 break;
 183         default:
 184                 ret = -EINVAL;
 185                 break;
 186         }
 187
 188 done:
 189         if (ret == -EAGAIN)
 190                 return -EAGAIN;
 191         if (ret < 0)
 192                 req_set_fail(req);
 193         io_req_set_res(req, ret, 0);
 194         return IOU_OK;
 195 }