io_uring/filetable.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.h"
  13 #include "rsrc.h"
  14 #include "filetable.h"
  15
  16 static int io_file_bitmap_get(struct io_ring_ctx *ctx)
  17 {
  18         struct io_file_table *table = &ctx->file_table;
  19         unsigned long nr = ctx->file_alloc_end;
  20         int ret;
  21
  22         do {
  23                 ret = find_next_zero_bit(table->bitmap, nr, table->alloc_hint);
  24                 if (ret != nr)
  25                         return ret;
  26
  27                 if (table->alloc_hint == ctx->file_alloc_start)
  28                         break;
  29                 nr = table->alloc_hint;
  30                 table->alloc_hint = ctx->file_alloc_start;
  31         } while (1);
  32
  33         return -ENFILE;
  34 }
  35
  36 bool io_alloc_file_tables(struct io_file_table *table, unsigned nr_files)
  37 {
  38         table->files = kvcalloc(nr_files, sizeof(table->files[0]),
  39                                 GFP_KERNEL_ACCOUNT);
  40         if (unlikely(!table->files))
  41                 return false;
  42
  43         table->bitmap = bitmap_zalloc(nr_files, GFP_KERNEL_ACCOUNT);
  44         if (unlikely(!table->bitmap)) {
  45                 kvfree(table->files);
  46                 return false;
  47         }
  48
  49         return true;
  50 }
  51
  52 void io_free_file_tables(struct io_file_table *table)
  53 {
  54         kvfree(table->files);
  55         bitmap_free(table->bitmap);
  56         table->files = NULL;
  57         table->bitmap = NULL;
  58 }
  59
  60 static int io_install_fixed_file(struct io_ring_ctx *ctx, struct file *file,
  61                                  u32 slot_index)
  62         __must_hold(&req->ctx->uring_lock)
  63 {
  64         bool needs_switch = false;
  65         struct io_fixed_file *file_slot;
  66         int ret;
  67
  68         if (io_is_uring_fops(file))
  69                 return -EBADF;
  70         if (!ctx->file_data)
  71                 return -ENXIO;
  72         if (slot_index >= ctx->nr_user_files)
  73                 return -EINVAL;
  74
  75         slot_index = array_index_nospec(slot_index, ctx->nr_user_files);
  76         file_slot = io_fixed_file_slot(&ctx->file_table, slot_index);
  77
  78         if (file_slot->file_ptr) {
  79                 struct file *old_file;
  80
  81                 ret = io_rsrc_node_switch_start(ctx);
  82                 if (ret)
  83                         goto err;
  84
  85                 old_file = (struct file *)(file_slot->file_ptr & FFS_MASK);
  86                 ret = io_queue_rsrc_removal(ctx->file_data, slot_index,
  87                                             ctx->rsrc_node, old_file);
  88                 if (ret)
  89                         goto err;
  90                 file_slot->file_ptr = 0;
  91                 io_file_bitmap_clear(&ctx->file_table, slot_index);
  92                 needs_switch = true;
  93         }
  94
  95         ret = io_scm_file_account(ctx, file);
  96         if (!ret) {
  97                 *io_get_tag_slot(ctx->file_data, slot_index) = 0;
  98                 io_fixed_file_set(file_slot, file);
  99                 io_file_bitmap_set(&ctx->file_table, slot_index);
 100         }
 101 err:
 102         if (needs_switch)
 103                 io_rsrc_node_switch(ctx, ctx->file_data);
 104         return ret;
 105 }
 106
 107 int __io_fixed_fd_install(struct io_ring_ctx *ctx, struct file *file,
 108                           unsigned int file_slot)
 109 {
 110         bool alloc_slot = file_slot == IORING_FILE_INDEX_ALLOC;
 111         int ret;
 112
 113         if (alloc_slot) {
 114                 ret = io_file_bitmap_get(ctx);
 115                 if (unlikely(ret < 0))
 116                         return ret;
 117                 file_slot = ret;
 118         } else {
 119                 file_slot--;
 120         }
 121
 122         ret = io_install_fixed_file(ctx, file, file_slot);
 123         if (!ret && alloc_slot)
 124                 ret = file_slot;
 125         return ret;
 126 }
 127 /*
 128  * Note when io_fixed_fd_install() returns error value, it will ensure
 129  * fput() is called correspondingly.
 130  */
 131 int io_fixed_fd_install(struct io_kiocb *req, unsigned int issue_flags,
 132                         struct file *file, unsigned int file_slot)
 133 {
 134         struct io_ring_ctx *ctx = req->ctx;
 135         int ret;
 136
 137         io_ring_submit_lock(ctx, issue_flags);
 138         ret = __io_fixed_fd_install(ctx, file, file_slot);
 139         io_ring_submit_unlock(ctx, issue_flags);
 140
 141         if (unlikely(ret < 0))
 142                 fput(file);
 143         return ret;
 144 }
 145
 146 int io_fixed_fd_remove(struct io_ring_ctx *ctx, unsigned int offset)
 147 {
 148         struct io_fixed_file *file_slot;
 149         struct file *file;
 150         int ret;
 151
 152         if (unlikely(!ctx->file_data))
 153                 return -ENXIO;
 154         if (offset >= ctx->nr_user_files)
 155                 return -EINVAL;
 156         ret = io_rsrc_node_switch_start(ctx);
 157         if (ret)
 158                 return ret;
 159
 160         offset = array_index_nospec(offset, ctx->nr_user_files);
 161         file_slot = io_fixed_file_slot(&ctx->file_table, offset);
 162         if (!file_slot->file_ptr)
 163                 return -EBADF;
 164
 165         file = (struct file *)(file_slot->file_ptr & FFS_MASK);
 166         ret = io_queue_rsrc_removal(ctx->file_data, offset, ctx->rsrc_node, file);
 167         if (ret)
 168                 return ret;
 169
 170         file_slot->file_ptr = 0;
 171         io_file_bitmap_clear(&ctx->file_table, offset);
 172         io_rsrc_node_switch(ctx, ctx->file_data);
 173         return 0;
 174 }
 175
 176 int io_register_file_alloc_range(struct io_ring_ctx *ctx,
 177                                  struct io_uring_file_index_range __user *arg)
 178 {
 179         struct io_uring_file_index_range range;
 180         u32 end;
 181
 182         if (copy_from_user(&range, arg, sizeof(range)))
 183                 return -EFAULT;
 184         if (check_add_overflow(range.off, range.len, &end))
 185                 return -EOVERFLOW;
 186         if (range.resv || end > ctx->nr_user_files)
 187                 return -EINVAL;
 188
 189         io_file_table_set_alloc_range(ctx, range.off, range.len);
 190         return 0;
 191 }