io_uring/tctx.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/mm.h>
   6 #include <linux/slab.h>
   7 #include <linux/nospec.h>
   8 #include <linux/io_uring.h>
   9
  10 #include <uapi/linux/io_uring.h>
  11
  12 #include "io_uring_types.h"
  13 #include "io_uring.h"
  14 #include "tctx.h"
  15
  16 static struct io_wq *io_init_wq_offload(struct io_ring_ctx *ctx,
  17                                         struct task_struct *task)
  18 {
  19         struct io_wq_hash *hash;
  20         struct io_wq_data data;
  21         unsigned int concurrency;
  22
  23         mutex_lock(&ctx->uring_lock);
  24         hash = ctx->hash_map;
  25         if (!hash) {
  26                 hash = kzalloc(sizeof(*hash), GFP_KERNEL);
  27                 if (!hash) {
  28                         mutex_unlock(&ctx->uring_lock);
  29                         return ERR_PTR(-ENOMEM);
  30                 }
  31                 refcount_set(&hash->refs, 1);
  32                 init_waitqueue_head(&hash->wait);
  33                 ctx->hash_map = hash;
  34         }
  35         mutex_unlock(&ctx->uring_lock);
  36
  37         data.hash = hash;
  38         data.task = task;
  39         data.free_work = io_wq_free_work;
  40         data.do_work = io_wq_submit_work;
  41
  42         /* Do QD, or 4 * CPUS, whatever is smallest */
  43         concurrency = min(ctx->sq_entries, 4 * num_online_cpus());
  44
  45         return io_wq_create(concurrency, &data);
  46 }
  47
  48 void __io_uring_free(struct task_struct *tsk)
  49 {
  50         struct io_uring_task *tctx = tsk->io_uring;
  51
  52         WARN_ON_ONCE(!xa_empty(&tctx->xa));
  53         WARN_ON_ONCE(tctx->io_wq);
  54         WARN_ON_ONCE(tctx->cached_refs);
  55
  56         percpu_counter_destroy(&tctx->inflight);
  57         kfree(tctx);
  58         tsk->io_uring = NULL;
  59 }
  60
  61 __cold int io_uring_alloc_task_context(struct task_struct *task,
  62                                        struct io_ring_ctx *ctx)
  63 {
  64         struct io_uring_task *tctx;
  65         int ret;
  66
  67         tctx = kzalloc(sizeof(*tctx), GFP_KERNEL);
  68         if (unlikely(!tctx))
  69                 return -ENOMEM;
  70
  71         ret = percpu_counter_init(&tctx->inflight, 0, GFP_KERNEL);
  72         if (unlikely(ret)) {
  73                 kfree(tctx);
  74                 return ret;
  75         }
  76
  77         tctx->io_wq = io_init_wq_offload(ctx, task);
  78         if (IS_ERR(tctx->io_wq)) {
  79                 ret = PTR_ERR(tctx->io_wq);
  80                 percpu_counter_destroy(&tctx->inflight);
  81                 kfree(tctx);
  82                 return ret;
  83         }
  84
  85         xa_init(&tctx->xa);
  86         init_waitqueue_head(&tctx->wait);
  87         atomic_set(&tctx->in_idle, 0);
  88         atomic_set(&tctx->inflight_tracked, 0);
  89         task->io_uring = tctx;
  90         spin_lock_init(&tctx->task_lock);
  91         INIT_WQ_LIST(&tctx->task_list);
  92         INIT_WQ_LIST(&tctx->prio_task_list);
  93         init_task_work(&tctx->task_work, tctx_task_work);
  94         return 0;
  95 }
  96
  97 int __io_uring_add_tctx_node(struct io_ring_ctx *ctx)
  98 {
  99         struct io_uring_task *tctx = current->io_uring;
 100         struct io_tctx_node *node;
 101         int ret;
 102
 103         if (unlikely(!tctx)) {
 104                 ret = io_uring_alloc_task_context(current, ctx);
 105                 if (unlikely(ret))
 106                         return ret;
 107
 108                 tctx = current->io_uring;
 109                 if (ctx->iowq_limits_set) {
 110                         unsigned int limits[2] = { ctx->iowq_limits[0],
 111                                                    ctx->iowq_limits[1], };
 112
 113                         ret = io_wq_max_workers(tctx->io_wq, limits);
 114                         if (ret)
 115                                 return ret;
 116                 }
 117         }
 118         if (!xa_load(&tctx->xa, (unsigned long)ctx)) {
 119                 node = kmalloc(sizeof(*node), GFP_KERNEL);
 120                 if (!node)
 121                         return -ENOMEM;
 122                 node->ctx = ctx;
 123                 node->task = current;
 124
 125                 ret = xa_err(xa_store(&tctx->xa, (unsigned long)ctx,
 126                                         node, GFP_KERNEL));
 127                 if (ret) {
 128                         kfree(node);
 129                         return ret;
 130                 }
 131
 132                 mutex_lock(&ctx->uring_lock);
 133                 list_add(&node->ctx_node, &ctx->tctx_list);
 134                 mutex_unlock(&ctx->uring_lock);
 135         }
 136         tctx->last = ctx;
 137         return 0;
 138 }
 139
 140 /*
 141  * Remove this io_uring_file -> task mapping.
 142  */
 143 __cold void io_uring_del_tctx_node(unsigned long index)
 144 {
 145         struct io_uring_task *tctx = current->io_uring;
 146         struct io_tctx_node *node;
 147
 148         if (!tctx)
 149                 return;
 150         node = xa_erase(&tctx->xa, index);
 151         if (!node)
 152                 return;
 153
 154         WARN_ON_ONCE(current != node->task);
 155         WARN_ON_ONCE(list_empty(&node->ctx_node));
 156
 157         mutex_lock(&node->ctx->uring_lock);
 158         list_del(&node->ctx_node);
 159         mutex_unlock(&node->ctx->uring_lock);
 160
 161         if (tctx->last == node->ctx)
 162                 tctx->last = NULL;
 163         kfree(node);
 164 }
 165
 166 __cold void io_uring_clean_tctx(struct io_uring_task *tctx)
 167 {
 168         struct io_wq *wq = tctx->io_wq;
 169         struct io_tctx_node *node;
 170         unsigned long index;
 171
 172         xa_for_each(&tctx->xa, index, node) {
 173                 io_uring_del_tctx_node(index);
 174                 cond_resched();
 175         }
 176         if (wq) {
 177                 /*
 178                  * Must be after io_uring_del_tctx_node() (removes nodes under
 179                  * uring_lock) to avoid race with io_uring_try_cancel_iowq().
 180                  */
 181                 io_wq_put_and_exit(wq);
 182                 tctx->io_wq = NULL;
 183         }
 184 }
 185
 186 void io_uring_unreg_ringfd(void)
 187 {
 188         struct io_uring_task *tctx = current->io_uring;
 189         int i;
 190
 191         for (i = 0; i < IO_RINGFD_REG_MAX; i++) {
 192                 if (tctx->registered_rings[i]) {
 193                         fput(tctx->registered_rings[i]);
 194                         tctx->registered_rings[i] = NULL;
 195                 }
 196         }
 197 }
 198
 199 static int io_ring_add_registered_fd(struct io_uring_task *tctx, int fd,
 200                                      int start, int end)
 201 {
 202         struct file *file;
 203         int offset;
 204
 205         for (offset = start; offset < end; offset++) {
 206                 offset = array_index_nospec(offset, IO_RINGFD_REG_MAX);
 207                 if (tctx->registered_rings[offset])
 208                         continue;
 209
 210                 file = fget(fd);
 211                 if (!file) {
 212                         return -EBADF;
 213                 } else if (!io_is_uring_fops(file)) {
 214                         fput(file);
 215                         return -EOPNOTSUPP;
 216                 }
 217                 tctx->registered_rings[offset] = file;
 218                 return offset;
 219         }
 220
 221         return -EBUSY;
 222 }
 223
 224 /*
 225  * Register a ring fd to avoid fdget/fdput for each io_uring_enter()
 226  * invocation. User passes in an array of struct io_uring_rsrc_update
 227  * with ->data set to the ring_fd, and ->offset given for the desired
 228  * index. If no index is desired, application may set ->offset == -1U
 229  * and we'll find an available index. Returns number of entries
 230  * successfully processed, or < 0 on error if none were processed.
 231  */
 232 int io_ringfd_register(struct io_ring_ctx *ctx, void __user *__arg,
 233                        unsigned nr_args)
 234 {
 235         struct io_uring_rsrc_update __user *arg = __arg;
 236         struct io_uring_rsrc_update reg;
 237         struct io_uring_task *tctx;
 238         int ret, i;
 239
 240         if (!nr_args || nr_args > IO_RINGFD_REG_MAX)
 241                 return -EINVAL;
 242
 243         mutex_unlock(&ctx->uring_lock);
 244         ret = io_uring_add_tctx_node(ctx);
 245         mutex_lock(&ctx->uring_lock);
 246         if (ret)
 247                 return ret;
 248
 249         tctx = current->io_uring;
 250         for (i = 0; i < nr_args; i++) {
 251                 int start, end;
 252
 253                 if (copy_from_user(&reg, &arg[i], sizeof(reg))) {
 254                         ret = -EFAULT;
 255                         break;
 256                 }
 257
 258                 if (reg.resv) {
 259                         ret = -EINVAL;
 260                         break;
 261                 }
 262
 263                 if (reg.offset == -1U) {
 264                         start = 0;
 265                         end = IO_RINGFD_REG_MAX;
 266                 } else {
 267                         if (reg.offset >= IO_RINGFD_REG_MAX) {
 268                                 ret = -EINVAL;
 269                                 break;
 270                         }
 271                         start = reg.offset;
 272                         end = start + 1;
 273                 }
 274
 275                 ret = io_ring_add_registered_fd(tctx, reg.data, start, end);
 276                 if (ret < 0)
 277                         break;
 278
 279                 reg.offset = ret;
 280                 if (copy_to_user(&arg[i], &reg, sizeof(reg))) {
 281                         fput(tctx->registered_rings[reg.offset]);
 282                         tctx->registered_rings[reg.offset] = NULL;
 283                         ret = -EFAULT;
 284                         break;
 285                 }
 286         }
 287
 288         return i ? i : ret;
 289 }
 290
 291 int io_ringfd_unregister(struct io_ring_ctx *ctx, void __user *__arg,
 292                          unsigned nr_args)
 293 {
 294         struct io_uring_rsrc_update __user *arg = __arg;
 295         struct io_uring_task *tctx = current->io_uring;
 296         struct io_uring_rsrc_update reg;
 297         int ret = 0, i;
 298
 299         if (!nr_args || nr_args > IO_RINGFD_REG_MAX)
 300                 return -EINVAL;
 301         if (!tctx)
 302                 return 0;
 303
 304         for (i = 0; i < nr_args; i++) {
 305                 if (copy_from_user(&reg, &arg[i], sizeof(reg))) {
 306                         ret = -EFAULT;
 307                         break;
 308                 }
 309                 if (reg.resv || reg.data || reg.offset >= IO_RINGFD_REG_MAX) {
 310                         ret = -EINVAL;
 311                         break;
 312                 }
 313
 314                 reg.offset = array_index_nospec(reg.offset, IO_RINGFD_REG_MAX);
 315                 if (tctx->registered_rings[reg.offset]) {
 316                         fput(tctx->registered_rings[reg.offset]);
 317                         tctx->registered_rings[reg.offset] = NULL;
 318                 }
 319         }
 320
 321         return i ? i : ret;
 322 }