io_uring/io_uring.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Shared application/kernel submission and completion ring pairs, for
   4  * supporting fast/efficient IO.
   5  *
   6  * A note on the read/write ordering memory barriers that are matched between
   7  * the application and kernel side.
   8  *
   9  * After the application reads the CQ ring tail, it must use an
  10  * appropriate smp_rmb() to pair with the smp_wmb() the kernel uses
  11  * before writing the tail (using smp_load_acquire to read the tail will
  12  * do). It also needs a smp_mb() before updating CQ head (ordering the
  13  * entry load(s) with the head store), pairing with an implicit barrier
  14  * through a control-dependency in io_get_cqe (smp_store_release to
  15  * store head will do). Failure to do so could lead to reading invalid
  16  * CQ entries.
  17  *
  18  * Likewise, the application must use an appropriate smp_wmb() before
  19  * writing the SQ tail (ordering SQ entry stores with the tail store),
  20  * which pairs with smp_load_acquire in io_get_sqring (smp_store_release
  21  * to store the tail will do). And it needs a barrier ordering the SQ
  22  * head load before writing new SQ entries (smp_load_acquire to read
  23  * head will do).
  24  *
  25  * When using the SQ poll thread (IORING_SETUP_SQPOLL), the application
  26  * needs to check the SQ flags for IORING_SQ_NEED_WAKEUP *after*
  27  * updating the SQ tail; a full memory barrier smp_mb() is needed
  28  * between.
  29  *
  30  * Also see the examples in the liburing library:
  31  *
  32  *      git://git.kernel.dk/liburing
  33  *
  34  * io_uring also uses READ/WRITE_ONCE() for _any_ store or load that happens
  35  * from data shared between the kernel and application. This is done both
  36  * for ordering purposes, but also to ensure that once a value is loaded from
  37  * data that the application could potentially modify, it remains stable.
  38  *
  39  * Copyright (C) 2018-2019 Jens Axboe
  40  * Copyright (c) 2018-2019 Christoph Hellwig
  41  */
  42 #include <linux/kernel.h>
  43 #include <linux/init.h>
  44 #include <linux/errno.h>
  45 #include <linux/syscalls.h>
  46 #include <net/compat.h>
  47 #include <linux/refcount.h>
  48 #include <linux/uio.h>
  49 #include <linux/bits.h>
  50
  51 #include <linux/sched/signal.h>
  52 #include <linux/fs.h>
  53 #include <linux/file.h>
  54 #include <linux/fdtable.h>
  55 #include <linux/mm.h>
  56 #include <linux/mman.h>
  57 #include <linux/percpu.h>
  58 #include <linux/slab.h>
  59 #include <linux/bvec.h>
  60 #include <linux/net.h>
  61 #include <net/sock.h>
  62 #include <net/af_unix.h>
  63 #include <net/scm.h>
  64 #include <linux/anon_inodes.h>
  65 #include <linux/sched/mm.h>
  66 #include <linux/uaccess.h>
  67 #include <linux/nospec.h>
  68 #include <linux/highmem.h>
  69 #include <linux/fsnotify.h>
  70 #include <linux/fadvise.h>
  71 #include <linux/task_work.h>
  72 #include <linux/io_uring.h>
  73 #include <linux/audit.h>
  74 #include <linux/security.h>
  75 #include <asm/shmparam.h>
  76
  77 #define CREATE_TRACE_POINTS
  78 #include <trace/events/io_uring.h>
  79
  80 #include <uapi/linux/io_uring.h>
  81
  82 #include "io-wq.h"
  83
  84 #include "io_uring.h"
  85 #include "opdef.h"
  86 #include "refs.h"
  87 #include "tctx.h"
  88 #include "sqpoll.h"
  89 #include "fdinfo.h"
  90 #include "kbuf.h"
  91 #include "rsrc.h"
  92 #include "cancel.h"
  93 #include "net.h"
  94 #include "notif.h"
  95
  96 #include "timeout.h"
  97 #include "poll.h"
  98 #include "rw.h"
  99 #include "alloc_cache.h"
 100
 101 #define IORING_MAX_ENTRIES      32768
 102 #define IORING_MAX_CQ_ENTRIES   (2 * IORING_MAX_ENTRIES)
 103
 104 #define IORING_MAX_RESTRICTIONS (IORING_RESTRICTION_LAST + \
 105                                  IORING_REGISTER_LAST + IORING_OP_LAST)
 106
 107 #define SQE_COMMON_FLAGS (IOSQE_FIXED_FILE | IOSQE_IO_LINK | \
 108                           IOSQE_IO_HARDLINK | IOSQE_ASYNC)
 109
 110 #define SQE_VALID_FLAGS (SQE_COMMON_FLAGS | IOSQE_BUFFER_SELECT | \
 111                         IOSQE_IO_DRAIN | IOSQE_CQE_SKIP_SUCCESS)
 112
 113 #define IO_REQ_CLEAN_FLAGS (REQ_F_BUFFER_SELECTED | REQ_F_NEED_CLEANUP | \
 114                                 REQ_F_POLLED | REQ_F_INFLIGHT | REQ_F_CREDS | \
 115                                 REQ_F_ASYNC_DATA)
 116
 117 #define IO_REQ_CLEAN_SLOW_FLAGS (REQ_F_REFCOUNT | REQ_F_LINK | REQ_F_HARDLINK |\
 118                                  IO_REQ_CLEAN_FLAGS)
 119
 120 #define IO_TCTX_REFS_CACHE_NR   (1U << 10)
 121
 122 #define IO_COMPL_BATCH                  32
 123 #define IO_REQ_ALLOC_BATCH              8
 124
 125 enum {
 126         IO_CHECK_CQ_OVERFLOW_BIT,
 127         IO_CHECK_CQ_DROPPED_BIT,
 128 };
 129
 130 enum {
 131         IO_EVENTFD_OP_SIGNAL_BIT,
 132         IO_EVENTFD_OP_FREE_BIT,
 133 };
 134
 135 struct io_defer_entry {
 136         struct list_head        list;
 137         struct io_kiocb         *req;
 138         u32                     seq;
 139 };
 140
 141 /* requests with any of those set should undergo io_disarm_next() */
 142 #define IO_DISARM_MASK (REQ_F_ARM_LTIMEOUT | REQ_F_LINK_TIMEOUT | REQ_F_FAIL)
 143 #define IO_REQ_LINK_FLAGS (REQ_F_LINK | REQ_F_HARDLINK)
 144
 145 static bool io_uring_try_cancel_requests(struct io_ring_ctx *ctx,
 146                                          struct task_struct *task,
 147                                          bool cancel_all);
 148
 149 static void io_queue_sqe(struct io_kiocb *req);
 150
 151 struct kmem_cache *req_cachep;
 152
 153 struct sock *io_uring_get_socket(struct file *file)
 154 {
 155 #if defined(CONFIG_UNIX)
 156         if (io_is_uring_fops(file)) {
 157                 struct io_ring_ctx *ctx = file->private_data;
 158
 159                 return ctx->ring_sock->sk;
 160         }
 161 #endif
 162         return NULL;
 163 }
 164 EXPORT_SYMBOL(io_uring_get_socket);
 165
 166 static inline void io_submit_flush_completions(struct io_ring_ctx *ctx)
 167 {
 168         if (!wq_list_empty(&ctx->submit_state.compl_reqs) ||
 169             ctx->submit_state.cqes_count)
 170                 __io_submit_flush_completions(ctx);
 171 }
 172
 173 static inline unsigned int __io_cqring_events(struct io_ring_ctx *ctx)
 174 {
 175         return ctx->cached_cq_tail - READ_ONCE(ctx->rings->cq.head);
 176 }
 177
 178 static inline unsigned int __io_cqring_events_user(struct io_ring_ctx *ctx)
 179 {
 180         return READ_ONCE(ctx->rings->cq.tail) - READ_ONCE(ctx->rings->cq.head);
 181 }
 182
 183 static bool io_match_linked(struct io_kiocb *head)
 184 {
 185         struct io_kiocb *req;
 186
 187         io_for_each_link(req, head) {
 188                 if (req->flags & REQ_F_INFLIGHT)
 189                         return true;
 190         }
 191         return false;
 192 }
 193
 194 /*
 195  * As io_match_task() but protected against racing with linked timeouts.
 196  * User must not hold timeout_lock.
 197  */
 198 bool io_match_task_safe(struct io_kiocb *head, struct task_struct *task,
 199                         bool cancel_all)
 200 {
 201         bool matched;
 202
 203         if (task && head->task != task)
 204                 return false;
 205         if (cancel_all)
 206                 return true;
 207
 208         if (head->flags & REQ_F_LINK_TIMEOUT) {
 209                 struct io_ring_ctx *ctx = head->ctx;
 210
 211                 /* protect against races with linked timeouts */
 212                 spin_lock_irq(&ctx->timeout_lock);
 213                 matched = io_match_linked(head);
 214                 spin_unlock_irq(&ctx->timeout_lock);
 215         } else {
 216                 matched = io_match_linked(head);
 217         }
 218         return matched;
 219 }
 220
 221 static inline void req_fail_link_node(struct io_kiocb *req, int res)
 222 {
 223         req_set_fail(req);
 224         io_req_set_res(req, res, 0);
 225 }
 226
 227 static inline void io_req_add_to_cache(struct io_kiocb *req, struct io_ring_ctx *ctx)
 228 {
 229         wq_stack_add_head(&req->comp_list, &ctx->submit_state.free_list);
 230 }
 231
 232 static __cold void io_ring_ctx_ref_free(struct percpu_ref *ref)
 233 {
 234         struct io_ring_ctx *ctx = container_of(ref, struct io_ring_ctx, refs);
 235
 236         complete(&ctx->ref_comp);
 237 }
 238
 239 static __cold void io_fallback_req_func(struct work_struct *work)
 240 {
 241         struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx,
 242                                                 fallback_work.work);
 243         struct llist_node *node = llist_del_all(&ctx->fallback_llist);
 244         struct io_kiocb *req, *tmp;
 245         struct io_tw_state ts = { .locked = true, };
 246
 247         mutex_lock(&ctx->uring_lock);
 248         llist_for_each_entry_safe(req, tmp, node, io_task_work.node)
 249                 req->io_task_work.func(req, &ts);
 250         if (WARN_ON_ONCE(!ts.locked))
 251                 return;
 252         io_submit_flush_completions(ctx);
 253         mutex_unlock(&ctx->uring_lock);
 254 }
 255
 256 static int io_alloc_hash_table(struct io_hash_table *table, unsigned bits)
 257 {
 258         unsigned hash_buckets = 1U << bits;
 259         size_t hash_size = hash_buckets * sizeof(table->hbs[0]);
 260
 261         table->hbs = kmalloc(hash_size, GFP_KERNEL);
 262         if (!table->hbs)
 263                 return -ENOMEM;
 264
 265         table->hash_bits = bits;
 266         init_hash_table(table, hash_buckets);
 267         return 0;
 268 }
 269
 270 static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
 271 {
 272         struct io_ring_ctx *ctx;
 273         int hash_bits;
 274
 275         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 276         if (!ctx)
 277                 return NULL;
 278
 279         xa_init(&ctx->io_bl_xa);
 280
 281         /*
 282          * Use 5 bits less than the max cq entries, that should give us around
 283          * 32 entries per hash list if totally full and uniformly spread, but
 284          * don't keep too many buckets to not overconsume memory.
 285          */
 286         hash_bits = ilog2(p->cq_entries) - 5;
 287         hash_bits = clamp(hash_bits, 1, 8);
 288         if (io_alloc_hash_table(&ctx->cancel_table, hash_bits))
 289                 goto err;
 290         if (io_alloc_hash_table(&ctx->cancel_table_locked, hash_bits))
 291                 goto err;
 292         if (percpu_ref_init(&ctx->refs, io_ring_ctx_ref_free,
 293                             0, GFP_KERNEL))
 294                 goto err;
 295
 296         ctx->flags = p->flags;
 297         init_waitqueue_head(&ctx->sqo_sq_wait);
 298         INIT_LIST_HEAD(&ctx->sqd_list);
 299         INIT_LIST_HEAD(&ctx->cq_overflow_list);
 300         INIT_LIST_HEAD(&ctx->io_buffers_cache);
 301         io_alloc_cache_init(&ctx->rsrc_node_cache, IO_NODE_ALLOC_CACHE_MAX,
 302                             sizeof(struct io_rsrc_node));
 303         io_alloc_cache_init(&ctx->apoll_cache, IO_ALLOC_CACHE_MAX,
 304                             sizeof(struct async_poll));
 305         io_alloc_cache_init(&ctx->netmsg_cache, IO_ALLOC_CACHE_MAX,
 306                             sizeof(struct io_async_msghdr));
 307         init_completion(&ctx->ref_comp);
 308         xa_init_flags(&ctx->personalities, XA_FLAGS_ALLOC1);
 309         mutex_init(&ctx->uring_lock);
 310         init_waitqueue_head(&ctx->cq_wait);
 311         init_waitqueue_head(&ctx->poll_wq);
 312         init_waitqueue_head(&ctx->rsrc_quiesce_wq);
 313         spin_lock_init(&ctx->completion_lock);
 314         spin_lock_init(&ctx->timeout_lock);
 315         INIT_WQ_LIST(&ctx->iopoll_list);
 316         INIT_LIST_HEAD(&ctx->io_buffers_pages);
 317         INIT_LIST_HEAD(&ctx->io_buffers_comp);
 318         INIT_LIST_HEAD(&ctx->defer_list);
 319         INIT_LIST_HEAD(&ctx->timeout_list);
 320         INIT_LIST_HEAD(&ctx->ltimeout_list);
 321         INIT_LIST_HEAD(&ctx->rsrc_ref_list);
 322         init_llist_head(&ctx->work_llist);
 323         INIT_LIST_HEAD(&ctx->tctx_list);
 324         ctx->submit_state.free_list.next = NULL;
 325         INIT_WQ_LIST(&ctx->locked_free_list);
 326         INIT_DELAYED_WORK(&ctx->fallback_work, io_fallback_req_func);
 327         INIT_WQ_LIST(&ctx->submit_state.compl_reqs);
 328         return ctx;
 329 err:
 330         kfree(ctx->cancel_table.hbs);
 331         kfree(ctx->cancel_table_locked.hbs);
 332         kfree(ctx->io_bl);
 333         xa_destroy(&ctx->io_bl_xa);
 334         kfree(ctx);
 335         return NULL;
 336 }
 337
 338 static void io_account_cq_overflow(struct io_ring_ctx *ctx)
 339 {
 340         struct io_rings *r = ctx->rings;
 341
 342         WRITE_ONCE(r->cq_overflow, READ_ONCE(r->cq_overflow) + 1);
 343         ctx->cq_extra--;
 344 }
 345
 346 static bool req_need_defer(struct io_kiocb *req, u32 seq)
 347 {
 348         if (unlikely(req->flags & REQ_F_IO_DRAIN)) {
 349                 struct io_ring_ctx *ctx = req->ctx;
 350
 351                 return seq + READ_ONCE(ctx->cq_extra) != ctx->cached_cq_tail;
 352         }
 353
 354         return false;
 355 }
 356
 357 static void io_clean_op(struct io_kiocb *req)
 358 {
 359         if (req->flags & REQ_F_BUFFER_SELECTED) {
 360                 spin_lock(&req->ctx->completion_lock);
 361                 io_put_kbuf_comp(req);
 362                 spin_unlock(&req->ctx->completion_lock);
 363         }
 364
 365         if (req->flags & REQ_F_NEED_CLEANUP) {
 366                 const struct io_cold_def *def = &io_cold_defs[req->opcode];
 367
 368                 if (def->cleanup)
 369                         def->cleanup(req);
 370         }
 371         if ((req->flags & REQ_F_POLLED) && req->apoll) {
 372                 kfree(req->apoll->double_poll);
 373                 kfree(req->apoll);
 374                 req->apoll = NULL;
 375         }
 376         if (req->flags & REQ_F_INFLIGHT) {
 377                 struct io_uring_task *tctx = req->task->io_uring;
 378
 379                 atomic_dec(&tctx->inflight_tracked);
 380         }
 381         if (req->flags & REQ_F_CREDS)
 382                 put_cred(req->creds);
 383         if (req->flags & REQ_F_ASYNC_DATA) {
 384                 kfree(req->async_data);
 385                 req->async_data = NULL;
 386         }
 387         req->flags &= ~IO_REQ_CLEAN_FLAGS;
 388 }
 389
 390 static inline void io_req_track_inflight(struct io_kiocb *req)
 391 {
 392         if (!(req->flags & REQ_F_INFLIGHT)) {
 393                 req->flags |= REQ_F_INFLIGHT;
 394                 atomic_inc(&req->task->io_uring->inflight_tracked);
 395         }
 396 }
 397
 398 static struct io_kiocb *__io_prep_linked_timeout(struct io_kiocb *req)
 399 {
 400         if (WARN_ON_ONCE(!req->link))
 401                 return NULL;
 402
 403         req->flags &= ~REQ_F_ARM_LTIMEOUT;
 404         req->flags |= REQ_F_LINK_TIMEOUT;
 405
 406         /* linked timeouts should have two refs once prep'ed */
 407         io_req_set_refcount(req);
 408         __io_req_set_refcount(req->link, 2);
 409         return req->link;
 410 }
 411
 412 static inline struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req)
 413 {
 414         if (likely(!(req->flags & REQ_F_ARM_LTIMEOUT)))
 415                 return NULL;
 416         return __io_prep_linked_timeout(req);
 417 }
 418
 419 static noinline void __io_arm_ltimeout(struct io_kiocb *req)
 420 {
 421         io_queue_linked_timeout(__io_prep_linked_timeout(req));
 422 }
 423
 424 static inline void io_arm_ltimeout(struct io_kiocb *req)
 425 {
 426         if (unlikely(req->flags & REQ_F_ARM_LTIMEOUT))
 427                 __io_arm_ltimeout(req);
 428 }
 429
 430 static void io_prep_async_work(struct io_kiocb *req)
 431 {
 432         const struct io_issue_def *def = &io_issue_defs[req->opcode];
 433         struct io_ring_ctx *ctx = req->ctx;
 434
 435         if (!(req->flags & REQ_F_CREDS)) {
 436                 req->flags |= REQ_F_CREDS;
 437                 req->creds = get_current_cred();
 438         }
 439
 440         req->work.list.next = NULL;
 441         req->work.flags = 0;
 442         req->work.cancel_seq = atomic_read(&ctx->cancel_seq);
 443         if (req->flags & REQ_F_FORCE_ASYNC)
 444                 req->work.flags |= IO_WQ_WORK_CONCURRENT;
 445
 446         if (req->file && !(req->flags & REQ_F_FIXED_FILE))
 447                 req->flags |= io_file_get_flags(req->file);
 448
 449         if (req->file && (req->flags & REQ_F_ISREG)) {
 450                 bool should_hash = def->hash_reg_file;
 451
 452                 /* don't serialize this request if the fs doesn't need it */
 453                 if (should_hash && (req->file->f_flags & O_DIRECT) &&
 454                     (req->file->f_mode & FMODE_DIO_PARALLEL_WRITE))
 455                         should_hash = false;
 456                 if (should_hash || (ctx->flags & IORING_SETUP_IOPOLL))
 457                         io_wq_hash_work(&req->work, file_inode(req->file));
 458         } else if (!req->file || !S_ISBLK(file_inode(req->file)->i_mode)) {
 459                 if (def->unbound_nonreg_file)
 460                         req->work.flags |= IO_WQ_WORK_UNBOUND;
 461         }
 462 }
 463
 464 static void io_prep_async_link(struct io_kiocb *req)
 465 {
 466         struct io_kiocb *cur;
 467
 468         if (req->flags & REQ_F_LINK_TIMEOUT) {
 469                 struct io_ring_ctx *ctx = req->ctx;
 470
 471                 spin_lock_irq(&ctx->timeout_lock);
 472                 io_for_each_link(cur, req)
 473                         io_prep_async_work(cur);
 474                 spin_unlock_irq(&ctx->timeout_lock);
 475         } else {
 476                 io_for_each_link(cur, req)
 477                         io_prep_async_work(cur);
 478         }
 479 }
 480
 481 void io_queue_iowq(struct io_kiocb *req, struct io_tw_state *ts_dont_use)
 482 {
 483         struct io_kiocb *link = io_prep_linked_timeout(req);
 484         struct io_uring_task *tctx = req->task->io_uring;
 485
 486         BUG_ON(!tctx);
 487         BUG_ON(!tctx->io_wq);
 488
 489         /* init ->work of the whole link before punting */
 490         io_prep_async_link(req);
 491
 492         /*
 493          * Not expected to happen, but if we do have a bug where this _can_
 494          * happen, catch it here and ensure the request is marked as
 495          * canceled. That will make io-wq go through the usual work cancel
 496          * procedure rather than attempt to run this request (or create a new
 497          * worker for it).
 498          */
 499         if (WARN_ON_ONCE(!same_thread_group(req->task, current)))
 500                 req->work.flags |= IO_WQ_WORK_CANCEL;
 501
 502         trace_io_uring_queue_async_work(req, io_wq_is_hashed(&req->work));
 503         io_wq_enqueue(tctx->io_wq, &req->work);
 504         if (link)
 505                 io_queue_linked_timeout(link);
 506 }
 507
 508 static __cold void io_queue_deferred(struct io_ring_ctx *ctx)
 509 {
 510         while (!list_empty(&ctx->defer_list)) {
 511                 struct io_defer_entry *de = list_first_entry(&ctx->defer_list,
 512                                                 struct io_defer_entry, list);
 513
 514                 if (req_need_defer(de->req, de->seq))
 515                         break;
 516                 list_del_init(&de->list);
 517                 io_req_task_queue(de->req);
 518                 kfree(de);
 519         }
 520 }
 521
 522
 523 static void io_eventfd_ops(struct rcu_head *rcu)
 524 {
 525         struct io_ev_fd *ev_fd = container_of(rcu, struct io_ev_fd, rcu);
 526         int ops = atomic_xchg(&ev_fd->ops, 0);
 527
 528         if (ops & BIT(IO_EVENTFD_OP_SIGNAL_BIT))
 529                 eventfd_signal_mask(ev_fd->cq_ev_fd, 1, EPOLL_URING_WAKE);
 530
 531         /* IO_EVENTFD_OP_FREE_BIT may not be set here depending on callback
 532          * ordering in a race but if references are 0 we know we have to free
 533          * it regardless.
 534          */
 535         if (atomic_dec_and_test(&ev_fd->refs)) {
 536                 eventfd_ctx_put(ev_fd->cq_ev_fd);
 537                 kfree(ev_fd);
 538         }
 539 }
 540
 541 static void io_eventfd_signal(struct io_ring_ctx *ctx)
 542 {
 543         struct io_ev_fd *ev_fd = NULL;
 544
 545         rcu_read_lock();
 546         /*
 547          * rcu_dereference ctx->io_ev_fd once and use it for both for checking
 548          * and eventfd_signal
 549          */
 550         ev_fd = rcu_dereference(ctx->io_ev_fd);
 551
 552         /*
 553          * Check again if ev_fd exists incase an io_eventfd_unregister call
 554          * completed between the NULL check of ctx->io_ev_fd at the start of
 555          * the function and rcu_read_lock.
 556          */
 557         if (unlikely(!ev_fd))
 558                 goto out;
 559         if (READ_ONCE(ctx->rings->cq_flags) & IORING_CQ_EVENTFD_DISABLED)
 560                 goto out;
 561         if (ev_fd->eventfd_async && !io_wq_current_is_worker())
 562                 goto out;
 563
 564         if (likely(eventfd_signal_allowed())) {
 565                 eventfd_signal_mask(ev_fd->cq_ev_fd, 1, EPOLL_URING_WAKE);
 566         } else {
 567                 atomic_inc(&ev_fd->refs);
 568                 if (!atomic_fetch_or(BIT(IO_EVENTFD_OP_SIGNAL_BIT), &ev_fd->ops))
 569                         call_rcu_hurry(&ev_fd->rcu, io_eventfd_ops);
 570                 else
 571                         atomic_dec(&ev_fd->refs);
 572         }
 573
 574 out:
 575         rcu_read_unlock();
 576 }
 577
 578 static void io_eventfd_flush_signal(struct io_ring_ctx *ctx)
 579 {
 580         bool skip;
 581
 582         spin_lock(&ctx->completion_lock);
 583
 584         /*
 585          * Eventfd should only get triggered when at least one event has been
 586          * posted. Some applications rely on the eventfd notification count
 587          * only changing IFF a new CQE has been added to the CQ ring. There's
 588          * no depedency on 1:1 relationship between how many times this
 589          * function is called (and hence the eventfd count) and number of CQEs
 590          * posted to the CQ ring.
 591          */
 592         skip = ctx->cached_cq_tail == ctx->evfd_last_cq_tail;
 593         ctx->evfd_last_cq_tail = ctx->cached_cq_tail;
 594         spin_unlock(&ctx->completion_lock);
 595         if (skip)
 596                 return;
 597
 598         io_eventfd_signal(ctx);
 599 }
 600
 601 void __io_commit_cqring_flush(struct io_ring_ctx *ctx)
 602 {
 603         if (ctx->poll_activated)
 604                 io_poll_wq_wake(ctx);
 605         if (ctx->off_timeout_used)
 606                 io_flush_timeouts(ctx);
 607         if (ctx->drain_active) {
 608                 spin_lock(&ctx->completion_lock);
 609                 io_queue_deferred(ctx);
 610                 spin_unlock(&ctx->completion_lock);
 611         }
 612         if (ctx->has_evfd)
 613                 io_eventfd_flush_signal(ctx);
 614 }
 615
 616 static inline void __io_cq_lock(struct io_ring_ctx *ctx)
 617 {
 618         if (!ctx->lockless_cq)
 619                 spin_lock(&ctx->completion_lock);
 620 }
 621
 622 static inline void io_cq_lock(struct io_ring_ctx *ctx)
 623         __acquires(ctx->completion_lock)
 624 {
 625         spin_lock(&ctx->completion_lock);
 626 }
 627
 628 static inline void __io_cq_unlock_post(struct io_ring_ctx *ctx)
 629 {
 630         io_commit_cqring(ctx);
 631         if (!ctx->task_complete) {
 632                 if (!ctx->lockless_cq)
 633                         spin_unlock(&ctx->completion_lock);
 634                 /* IOPOLL rings only need to wake up if it's also SQPOLL */
 635                 if (!ctx->syscall_iopoll)
 636                         io_cqring_wake(ctx);
 637         }
 638         io_commit_cqring_flush(ctx);
 639 }
 640
 641 static void io_cq_unlock_post(struct io_ring_ctx *ctx)
 642         __releases(ctx->completion_lock)
 643 {
 644         io_commit_cqring(ctx);
 645         spin_unlock(&ctx->completion_lock);
 646         io_cqring_wake(ctx);
 647         io_commit_cqring_flush(ctx);
 648 }
 649
 650 /* Returns true if there are no backlogged entries after the flush */
 651 static void io_cqring_overflow_kill(struct io_ring_ctx *ctx)
 652 {
 653         struct io_overflow_cqe *ocqe;
 654         LIST_HEAD(list);
 655
 656         spin_lock(&ctx->completion_lock);
 657         list_splice_init(&ctx->cq_overflow_list, &list);
 658         clear_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq);
 659         spin_unlock(&ctx->completion_lock);
 660
 661         while (!list_empty(&list)) {
 662                 ocqe = list_first_entry(&list, struct io_overflow_cqe, list);
 663                 list_del(&ocqe->list);
 664                 kfree(ocqe);
 665         }
 666 }
 667
 668 static void __io_cqring_overflow_flush(struct io_ring_ctx *ctx)
 669 {
 670         size_t cqe_size = sizeof(struct io_uring_cqe);
 671
 672         if (__io_cqring_events(ctx) == ctx->cq_entries)
 673                 return;
 674
 675         if (ctx->flags & IORING_SETUP_CQE32)
 676                 cqe_size <<= 1;
 677
 678         io_cq_lock(ctx);
 679         while (!list_empty(&ctx->cq_overflow_list)) {
 680                 struct io_uring_cqe *cqe;
 681                 struct io_overflow_cqe *ocqe;
 682
 683                 if (!io_get_cqe_overflow(ctx, &cqe, true))
 684                         break;
 685                 ocqe = list_first_entry(&ctx->cq_overflow_list,
 686                                         struct io_overflow_cqe, list);
 687                 memcpy(cqe, &ocqe->cqe, cqe_size);
 688                 list_del(&ocqe->list);
 689                 kfree(ocqe);
 690         }
 691
 692         if (list_empty(&ctx->cq_overflow_list)) {
 693                 clear_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq);
 694                 atomic_andnot(IORING_SQ_CQ_OVERFLOW, &ctx->rings->sq_flags);
 695         }
 696         io_cq_unlock_post(ctx);
 697 }
 698
 699 static void io_cqring_do_overflow_flush(struct io_ring_ctx *ctx)
 700 {
 701         /* iopoll syncs against uring_lock, not completion_lock */
 702         if (ctx->flags & IORING_SETUP_IOPOLL)
 703                 mutex_lock(&ctx->uring_lock);
 704         __io_cqring_overflow_flush(ctx);
 705         if (ctx->flags & IORING_SETUP_IOPOLL)
 706                 mutex_unlock(&ctx->uring_lock);
 707 }
 708
 709 static void io_cqring_overflow_flush(struct io_ring_ctx *ctx)
 710 {
 711         if (test_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq))
 712                 io_cqring_do_overflow_flush(ctx);
 713 }
 714
 715 /* can be called by any task */
 716 static void io_put_task_remote(struct task_struct *task)
 717 {
 718         struct io_uring_task *tctx = task->io_uring;
 719
 720         percpu_counter_sub(&tctx->inflight, 1);
 721         if (unlikely(atomic_read(&tctx->in_cancel)))
 722                 wake_up(&tctx->wait);
 723         put_task_struct(task);
 724 }
 725
 726 /* used by a task to put its own references */
 727 static void io_put_task_local(struct task_struct *task)
 728 {
 729         task->io_uring->cached_refs++;
 730 }
 731
 732 /* must to be called somewhat shortly after putting a request */
 733 static inline void io_put_task(struct task_struct *task)
 734 {
 735         if (likely(task == current))
 736                 io_put_task_local(task);
 737         else
 738                 io_put_task_remote(task);
 739 }
 740
 741 void io_task_refs_refill(struct io_uring_task *tctx)
 742 {
 743         unsigned int refill = -tctx->cached_refs + IO_TCTX_REFS_CACHE_NR;
 744
 745         percpu_counter_add(&tctx->inflight, refill);
 746         refcount_add(refill, &current->usage);
 747         tctx->cached_refs += refill;
 748 }
 749
 750 static __cold void io_uring_drop_tctx_refs(struct task_struct *task)
 751 {
 752         struct io_uring_task *tctx = task->io_uring;
 753         unsigned int refs = tctx->cached_refs;
 754
 755         if (refs) {
 756                 tctx->cached_refs = 0;
 757                 percpu_counter_sub(&tctx->inflight, refs);
 758                 put_task_struct_many(task, refs);
 759         }
 760 }
 761
 762 static bool io_cqring_event_overflow(struct io_ring_ctx *ctx, u64 user_data,
 763                                      s32 res, u32 cflags, u64 extra1, u64 extra2)
 764 {
 765         struct io_overflow_cqe *ocqe;
 766         size_t ocq_size = sizeof(struct io_overflow_cqe);
 767         bool is_cqe32 = (ctx->flags & IORING_SETUP_CQE32);
 768
 769         lockdep_assert_held(&ctx->completion_lock);
 770
 771         if (is_cqe32)
 772                 ocq_size += sizeof(struct io_uring_cqe);
 773
 774         ocqe = kmalloc(ocq_size, GFP_ATOMIC | __GFP_ACCOUNT);
 775         trace_io_uring_cqe_overflow(ctx, user_data, res, cflags, ocqe);
 776         if (!ocqe) {
 777                 /*
 778                  * If we're in ring overflow flush mode, or in task cancel mode,
 779                  * or cannot allocate an overflow entry, then we need to drop it
 780                  * on the floor.
 781                  */
 782                 io_account_cq_overflow(ctx);
 783                 set_bit(IO_CHECK_CQ_DROPPED_BIT, &ctx->check_cq);
 784                 return false;
 785         }
 786         if (list_empty(&ctx->cq_overflow_list)) {
 787                 set_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq);
 788                 atomic_or(IORING_SQ_CQ_OVERFLOW, &ctx->rings->sq_flags);
 789
 790         }
 791         ocqe->cqe.user_data = user_data;
 792         ocqe->cqe.res = res;
 793         ocqe->cqe.flags = cflags;
 794         if (is_cqe32) {
 795                 ocqe->cqe.big_cqe[0] = extra1;
 796                 ocqe->cqe.big_cqe[1] = extra2;
 797         }
 798         list_add_tail(&ocqe->list, &ctx->cq_overflow_list);
 799         return true;
 800 }
 801
 802 void io_req_cqe_overflow(struct io_kiocb *req)
 803 {
 804         io_cqring_event_overflow(req->ctx, req->cqe.user_data,
 805                                 req->cqe.res, req->cqe.flags,
 806                                 req->big_cqe.extra1, req->big_cqe.extra2);
 807         memset(&req->big_cqe, 0, sizeof(req->big_cqe));
 808 }
 809
 810 /*
 811  * writes to the cq entry need to come after reading head; the
 812  * control dependency is enough as we're using WRITE_ONCE to
 813  * fill the cq entry
 814  */
 815 bool io_cqe_cache_refill(struct io_ring_ctx *ctx, bool overflow)
 816 {
 817         struct io_rings *rings = ctx->rings;
 818         unsigned int off = ctx->cached_cq_tail & (ctx->cq_entries - 1);
 819         unsigned int free, queued, len;
 820
 821         /*
 822          * Posting into the CQ when there are pending overflowed CQEs may break
 823          * ordering guarantees, which will affect links, F_MORE users and more.
 824          * Force overflow the completion.
 825          */
 826         if (!overflow && (ctx->check_cq & BIT(IO_CHECK_CQ_OVERFLOW_BIT)))
 827                 return false;
 828
 829         /* userspace may cheat modifying the tail, be safe and do min */
 830         queued = min(__io_cqring_events(ctx), ctx->cq_entries);
 831         free = ctx->cq_entries - queued;
 832         /* we need a contiguous range, limit based on the current array offset */
 833         len = min(free, ctx->cq_entries - off);
 834         if (!len)
 835                 return false;
 836
 837         if (ctx->flags & IORING_SETUP_CQE32) {
 838                 off <<= 1;
 839                 len <<= 1;
 840         }
 841
 842         ctx->cqe_cached = &rings->cqes[off];
 843         ctx->cqe_sentinel = ctx->cqe_cached + len;
 844         return true;
 845 }
 846
 847 static bool io_fill_cqe_aux(struct io_ring_ctx *ctx, u64 user_data, s32 res,
 848                               u32 cflags)
 849 {
 850         struct io_uring_cqe *cqe;
 851
 852         ctx->cq_extra++;
 853
 854         /*
 855          * If we can't get a cq entry, userspace overflowed the
 856          * submission (by quite a lot). Increment the overflow count in
 857          * the ring.
 858          */
 859         if (likely(io_get_cqe(ctx, &cqe))) {
 860                 trace_io_uring_complete(ctx, NULL, user_data, res, cflags, 0, 0);
 861
 862                 WRITE_ONCE(cqe->user_data, user_data);
 863                 WRITE_ONCE(cqe->res, res);
 864                 WRITE_ONCE(cqe->flags, cflags);
 865
 866                 if (ctx->flags & IORING_SETUP_CQE32) {
 867                         WRITE_ONCE(cqe->big_cqe[0], 0);
 868                         WRITE_ONCE(cqe->big_cqe[1], 0);
 869                 }
 870                 return true;
 871         }
 872         return false;
 873 }
 874
 875 static void __io_flush_post_cqes(struct io_ring_ctx *ctx)
 876         __must_hold(&ctx->uring_lock)
 877 {
 878         struct io_submit_state *state = &ctx->submit_state;
 879         unsigned int i;
 880
 881         lockdep_assert_held(&ctx->uring_lock);
 882         for (i = 0; i < state->cqes_count; i++) {
 883                 struct io_uring_cqe *cqe = &state->cqes[i];
 884
 885                 if (!io_fill_cqe_aux(ctx, cqe->user_data, cqe->res, cqe->flags)) {
 886                         if (ctx->task_complete) {
 887                                 spin_lock(&ctx->completion_lock);
 888                                 io_cqring_event_overflow(ctx, cqe->user_data,
 889                                                         cqe->res, cqe->flags, 0, 0);
 890                                 spin_unlock(&ctx->completion_lock);
 891                         } else {
 892                                 io_cqring_event_overflow(ctx, cqe->user_data,
 893                                                         cqe->res, cqe->flags, 0, 0);
 894                         }
 895                 }
 896         }
 897         state->cqes_count = 0;
 898 }
 899
 900 static bool __io_post_aux_cqe(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 cflags,
 901                               bool allow_overflow)
 902 {
 903         bool filled;
 904
 905         io_cq_lock(ctx);
 906         filled = io_fill_cqe_aux(ctx, user_data, res, cflags);
 907         if (!filled && allow_overflow)
 908                 filled = io_cqring_event_overflow(ctx, user_data, res, cflags, 0, 0);
 909
 910         io_cq_unlock_post(ctx);
 911         return filled;
 912 }
 913
 914 bool io_post_aux_cqe(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 cflags)
 915 {
 916         return __io_post_aux_cqe(ctx, user_data, res, cflags, true);
 917 }
 918
 919 /*
 920  * A helper for multishot requests posting additional CQEs.
 921  * Should only be used from a task_work including IO_URING_F_MULTISHOT.
 922  */
 923 bool io_fill_cqe_req_aux(struct io_kiocb *req, bool defer, s32 res, u32 cflags)
 924 {
 925         struct io_ring_ctx *ctx = req->ctx;
 926         u64 user_data = req->cqe.user_data;
 927         struct io_uring_cqe *cqe;
 928
 929         if (!defer)
 930                 return __io_post_aux_cqe(ctx, user_data, res, cflags, false);
 931
 932         lockdep_assert_held(&ctx->uring_lock);
 933
 934         if (ctx->submit_state.cqes_count == ARRAY_SIZE(ctx->submit_state.cqes)) {
 935                 __io_cq_lock(ctx);
 936                 __io_flush_post_cqes(ctx);
 937                 /* no need to flush - flush is deferred */
 938                 __io_cq_unlock_post(ctx);
 939         }
 940
 941         /* For defered completions this is not as strict as it is otherwise,
 942          * however it's main job is to prevent unbounded posted completions,
 943          * and in that it works just as well.
 944          */
 945         if (test_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq))
 946                 return false;
 947
 948         cqe = &ctx->submit_state.cqes[ctx->submit_state.cqes_count++];
 949         cqe->user_data = user_data;
 950         cqe->res = res;
 951         cqe->flags = cflags;
 952         return true;
 953 }
 954
 955 static void __io_req_complete_post(struct io_kiocb *req, unsigned issue_flags)
 956 {
 957         struct io_ring_ctx *ctx = req->ctx;
 958         struct io_rsrc_node *rsrc_node = NULL;
 959
 960         io_cq_lock(ctx);
 961         if (!(req->flags & REQ_F_CQE_SKIP)) {
 962                 if (!io_fill_cqe_req(ctx, req))
 963                         io_req_cqe_overflow(req);
 964         }
 965
 966         /*
 967          * If we're the last reference to this request, add to our locked
 968          * free_list cache.
 969          */
 970         if (req_ref_put_and_test(req)) {
 971                 if (req->flags & IO_REQ_LINK_FLAGS) {
 972                         if (req->flags & IO_DISARM_MASK)
 973                                 io_disarm_next(req);
 974                         if (req->link) {
 975                                 io_req_task_queue(req->link);
 976                                 req->link = NULL;
 977                         }
 978                 }
 979                 io_put_kbuf_comp(req);
 980                 if (unlikely(req->flags & IO_REQ_CLEAN_FLAGS))
 981                         io_clean_op(req);
 982                 io_put_file(req);
 983
 984                 rsrc_node = req->rsrc_node;
 985                 /*
 986                  * Selected buffer deallocation in io_clean_op() assumes that
 987                  * we don't hold ->completion_lock. Clean them here to avoid
 988                  * deadlocks.
 989                  */
 990                 io_put_task_remote(req->task);
 991                 wq_list_add_head(&req->comp_list, &ctx->locked_free_list);
 992                 ctx->locked_free_nr++;
 993         }
 994         io_cq_unlock_post(ctx);
 995
 996         if (rsrc_node) {
 997                 io_ring_submit_lock(ctx, issue_flags);
 998                 io_put_rsrc_node(ctx, rsrc_node);
 999                 io_ring_submit_unlock(ctx, issue_flags);
1000         }
1001 }
1002
1003 void io_req_complete_post(struct io_kiocb *req, unsigned issue_flags)
1004 {
1005         if (req->ctx->task_complete && req->ctx->submitter_task != current) {
1006                 req->io_task_work.func = io_req_task_complete;
1007                 io_req_task_work_add(req);
1008         } else if (!(issue_flags & IO_URING_F_UNLOCKED) ||
1009                    !(req->ctx->flags & IORING_SETUP_IOPOLL)) {
1010                 __io_req_complete_post(req, issue_flags);
1011         } else {
1012                 struct io_ring_ctx *ctx = req->ctx;
1013
1014                 mutex_lock(&ctx->uring_lock);
1015                 __io_req_complete_post(req, issue_flags & ~IO_URING_F_UNLOCKED);
1016                 mutex_unlock(&ctx->uring_lock);
1017         }
1018 }
1019
1020 void io_req_defer_failed(struct io_kiocb *req, s32 res)
1021         __must_hold(&ctx->uring_lock)
1022 {
1023         const struct io_cold_def *def = &io_cold_defs[req->opcode];
1024
1025         lockdep_assert_held(&req->ctx->uring_lock);
1026
1027         req_set_fail(req);
1028         io_req_set_res(req, res, io_put_kbuf(req, IO_URING_F_UNLOCKED));
1029         if (def->fail)
1030                 def->fail(req);
1031         io_req_complete_defer(req);
1032 }
1033
1034 /*
1035  * Don't initialise the fields below on every allocation, but do that in
1036  * advance and keep them valid across allocations.
1037  */
1038 static void io_preinit_req(struct io_kiocb *req, struct io_ring_ctx *ctx)
1039 {
1040         req->ctx = ctx;
1041         req->link = NULL;
1042         req->async_data = NULL;
1043         /* not necessary, but safer to zero */
1044         memset(&req->cqe, 0, sizeof(req->cqe));
1045         memset(&req->big_cqe, 0, sizeof(req->big_cqe));
1046 }
1047
1048 static void io_flush_cached_locked_reqs(struct io_ring_ctx *ctx,
1049                                         struct io_submit_state *state)
1050 {
1051         spin_lock(&ctx->completion_lock);
1052         wq_list_splice(&ctx->locked_free_list, &state->free_list);
1053         ctx->locked_free_nr = 0;
1054         spin_unlock(&ctx->completion_lock);
1055 }
1056
1057 /*
1058  * A request might get retired back into the request caches even before opcode
1059  * handlers and io_issue_sqe() are done with it, e.g. inline completion path.
1060  * Because of that, io_alloc_req() should be called only under ->uring_lock
1061  * and with extra caution to not get a request that is still worked on.
1062  */
1063 __cold bool __io_alloc_req_refill(struct io_ring_ctx *ctx)
1064         __must_hold(&ctx->uring_lock)
1065 {
1066         gfp_t gfp = GFP_KERNEL | __GFP_NOWARN;
1067         void *reqs[IO_REQ_ALLOC_BATCH];
1068         int ret, i;
1069
1070         /*
1071          * If we have more than a batch's worth of requests in our IRQ side
1072          * locked cache, grab the lock and move them over to our submission
1073          * side cache.
1074          */
1075         if (data_race(ctx->locked_free_nr) > IO_COMPL_BATCH) {
1076                 io_flush_cached_locked_reqs(ctx, &ctx->submit_state);
1077                 if (!io_req_cache_empty(ctx))
1078                         return true;
1079         }
1080
1081         ret = kmem_cache_alloc_bulk(req_cachep, gfp, ARRAY_SIZE(reqs), reqs);
1082
1083         /*
1084          * Bulk alloc is all-or-nothing. If we fail to get a batch,
1085          * retry single alloc to be on the safe side.
1086          */
1087         if (unlikely(ret <= 0)) {
1088                 reqs[0] = kmem_cache_alloc(req_cachep, gfp);
1089                 if (!reqs[0])
1090                         return false;
1091                 ret = 1;
1092         }
1093
1094         percpu_ref_get_many(&ctx->refs, ret);
1095         for (i = 0; i < ret; i++) {
1096                 struct io_kiocb *req = reqs[i];
1097
1098                 io_preinit_req(req, ctx);
1099                 io_req_add_to_cache(req, ctx);
1100         }
1101         return true;
1102 }
1103
1104 __cold void io_free_req(struct io_kiocb *req)
1105 {
1106         /* refs were already put, restore them for io_req_task_complete() */
1107         req->flags &= ~REQ_F_REFCOUNT;
1108         /* we only want to free it, don't post CQEs */
1109         req->flags |= REQ_F_CQE_SKIP;
1110         req->io_task_work.func = io_req_task_complete;
1111         io_req_task_work_add(req);
1112 }
1113
1114 static void __io_req_find_next_prep(struct io_kiocb *req)
1115 {
1116         struct io_ring_ctx *ctx = req->ctx;
1117
1118         spin_lock(&ctx->completion_lock);
1119         io_disarm_next(req);
1120         spin_unlock(&ctx->completion_lock);
1121 }
1122
1123 static inline struct io_kiocb *io_req_find_next(struct io_kiocb *req)
1124 {
1125         struct io_kiocb *nxt;
1126
1127         /*
1128          * If LINK is set, we have dependent requests in this chain. If we
1129          * didn't fail this request, queue the first one up, moving any other
1130          * dependencies to the next request. In case of failure, fail the rest
1131          * of the chain.
1132          */
1133         if (unlikely(req->flags & IO_DISARM_MASK))
1134                 __io_req_find_next_prep(req);
1135         nxt = req->link;
1136         req->link = NULL;
1137         return nxt;
1138 }
1139
1140 static void ctx_flush_and_put(struct io_ring_ctx *ctx, struct io_tw_state *ts)
1141 {
1142         if (!ctx)
1143                 return;
1144         if (ctx->flags & IORING_SETUP_TASKRUN_FLAG)
1145                 atomic_andnot(IORING_SQ_TASKRUN, &ctx->rings->sq_flags);
1146         if (ts->locked) {
1147                 io_submit_flush_completions(ctx);
1148                 mutex_unlock(&ctx->uring_lock);
1149                 ts->locked = false;
1150         }
1151         percpu_ref_put(&ctx->refs);
1152 }
1153
1154 static unsigned int handle_tw_list(struct llist_node *node,
1155                                    struct io_ring_ctx **ctx,
1156                                    struct io_tw_state *ts,
1157                                    struct llist_node *last)
1158 {
1159         unsigned int count = 0;
1160
1161         while (node && node != last) {
1162                 struct llist_node *next = node->next;
1163                 struct io_kiocb *req = container_of(node, struct io_kiocb,
1164                                                     io_task_work.node);
1165
1166                 prefetch(container_of(next, struct io_kiocb, io_task_work.node));
1167
1168                 if (req->ctx != *ctx) {
1169                         ctx_flush_and_put(*ctx, ts);
1170                         *ctx = req->ctx;
1171                         /* if not contended, grab and improve batching */
1172                         ts->locked = mutex_trylock(&(*ctx)->uring_lock);
1173                         percpu_ref_get(&(*ctx)->refs);
1174                 }
1175                 INDIRECT_CALL_2(req->io_task_work.func,
1176                                 io_poll_task_func, io_req_rw_complete,
1177                                 req, ts);
1178                 node = next;
1179                 count++;
1180                 if (unlikely(need_resched())) {
1181                         ctx_flush_and_put(*ctx, ts);
1182                         *ctx = NULL;
1183                         cond_resched();
1184                 }
1185         }
1186
1187         return count;
1188 }
1189
1190 /**
1191  * io_llist_xchg - swap all entries in a lock-less list
1192  * @head:       the head of lock-less list to delete all entries
1193  * @new:        new entry as the head of the list
1194  *
1195  * If list is empty, return NULL, otherwise, return the pointer to the first entry.
1196  * The order of entries returned is from the newest to the oldest added one.
1197  */
1198 static inline struct llist_node *io_llist_xchg(struct llist_head *head,
1199                                                struct llist_node *new)
1200 {
1201         return xchg(&head->first, new);
1202 }
1203
1204 /**
1205  * io_llist_cmpxchg - possibly swap all entries in a lock-less list
1206  * @head:       the head of lock-less list to delete all entries
1207  * @old:        expected old value of the first entry of the list
1208  * @new:        new entry as the head of the list
1209  *
1210  * perform a cmpxchg on the first entry of the list.
1211  */
1212
1213 static inline struct llist_node *io_llist_cmpxchg(struct llist_head *head,
1214                                                   struct llist_node *old,
1215                                                   struct llist_node *new)
1216 {
1217         return cmpxchg(&head->first, old, new);
1218 }
1219
1220 static __cold void io_fallback_tw(struct io_uring_task *tctx, bool sync)
1221 {
1222         struct llist_node *node = llist_del_all(&tctx->task_list);
1223         struct io_ring_ctx *last_ctx = NULL;
1224         struct io_kiocb *req;
1225
1226         while (node) {
1227                 req = container_of(node, struct io_kiocb, io_task_work.node);
1228                 node = node->next;
1229                 if (sync && last_ctx != req->ctx) {
1230                         if (last_ctx) {
1231                                 flush_delayed_work(&last_ctx->fallback_work);
1232                                 percpu_ref_put(&last_ctx->refs);
1233                         }
1234                         last_ctx = req->ctx;
1235                         percpu_ref_get(&last_ctx->refs);
1236                 }
1237                 if (llist_add(&req->io_task_work.node,
1238                               &req->ctx->fallback_llist))
1239                         schedule_delayed_work(&req->ctx->fallback_work, 1);
1240         }
1241
1242         if (last_ctx) {
1243                 flush_delayed_work(&last_ctx->fallback_work);
1244                 percpu_ref_put(&last_ctx->refs);
1245         }
1246 }
1247
1248 void tctx_task_work(struct callback_head *cb)
1249 {
1250         struct io_tw_state ts = {};
1251         struct io_ring_ctx *ctx = NULL;
1252         struct io_uring_task *tctx = container_of(cb, struct io_uring_task,
1253                                                   task_work);
1254         struct llist_node fake = {};
1255         struct llist_node *node;
1256         unsigned int loops = 0;
1257         unsigned int count = 0;
1258
1259         if (unlikely(current->flags & PF_EXITING)) {
1260                 io_fallback_tw(tctx, true);
1261                 return;
1262         }
1263
1264         do {
1265                 loops++;
1266                 node = io_llist_xchg(&tctx->task_list, &fake);
1267                 count += handle_tw_list(node, &ctx, &ts, &fake);
1268
1269                 /* skip expensive cmpxchg if there are items in the list */
1270                 if (READ_ONCE(tctx->task_list.first) != &fake)
1271                         continue;
1272                 if (ts.locked && !wq_list_empty(&ctx->submit_state.compl_reqs)) {
1273                         io_submit_flush_completions(ctx);
1274                         if (READ_ONCE(tctx->task_list.first) != &fake)
1275                                 continue;
1276                 }
1277                 node = io_llist_cmpxchg(&tctx->task_list, &fake, NULL);
1278         } while (node != &fake);
1279
1280         ctx_flush_and_put(ctx, &ts);
1281
1282         /* relaxed read is enough as only the task itself sets ->in_cancel */
1283         if (unlikely(atomic_read(&tctx->in_cancel)))
1284                 io_uring_drop_tctx_refs(current);
1285
1286         trace_io_uring_task_work_run(tctx, count, loops);
1287 }
1288
1289 static inline void io_req_local_work_add(struct io_kiocb *req, unsigned flags)
1290 {
1291         struct io_ring_ctx *ctx = req->ctx;
1292         unsigned nr_wait, nr_tw, nr_tw_prev;
1293         struct llist_node *first;
1294
1295         if (req->flags & (REQ_F_LINK | REQ_F_HARDLINK))
1296                 flags &= ~IOU_F_TWQ_LAZY_WAKE;
1297
1298         first = READ_ONCE(ctx->work_llist.first);
1299         do {
1300                 nr_tw_prev = 0;
1301                 if (first) {
1302                         struct io_kiocb *first_req = container_of(first,
1303                                                         struct io_kiocb,
1304                                                         io_task_work.node);
1305                         /*
1306                          * Might be executed at any moment, rely on
1307                          * SLAB_TYPESAFE_BY_RCU to keep it alive.
1308                          */
1309                         nr_tw_prev = READ_ONCE(first_req->nr_tw);
1310                 }
1311                 nr_tw = nr_tw_prev + 1;
1312                 /* Large enough to fail the nr_wait comparison below */
1313                 if (!(flags & IOU_F_TWQ_LAZY_WAKE))
1314                         nr_tw = -1U;
1315
1316                 req->nr_tw = nr_tw;
1317                 req->io_task_work.node.next = first;
1318         } while (!try_cmpxchg(&ctx->work_llist.first, &first,
1319                               &req->io_task_work.node));
1320
1321         if (!first) {
1322                 if (ctx->flags & IORING_SETUP_TASKRUN_FLAG)
1323                         atomic_or(IORING_SQ_TASKRUN, &ctx->rings->sq_flags);
1324                 if (ctx->has_evfd)
1325                         io_eventfd_signal(ctx);
1326         }
1327
1328         nr_wait = atomic_read(&ctx->cq_wait_nr);
1329         /* no one is waiting */
1330         if (!nr_wait)
1331                 return;
1332         /* either not enough or the previous add has already woken it up */
1333         if (nr_wait > nr_tw || nr_tw_prev >= nr_wait)
1334                 return;
1335         /* pairs with set_current_state() in io_cqring_wait() */
1336         smp_mb__after_atomic();
1337         wake_up_state(ctx->submitter_task, TASK_INTERRUPTIBLE);
1338 }
1339
1340 static void io_req_normal_work_add(struct io_kiocb *req)
1341 {
1342         struct io_uring_task *tctx = req->task->io_uring;
1343         struct io_ring_ctx *ctx = req->ctx;
1344
1345         /* task_work already pending, we're done */
1346         if (!llist_add(&req->io_task_work.node, &tctx->task_list))
1347                 return;
1348
1349         if (ctx->flags & IORING_SETUP_TASKRUN_FLAG)
1350                 atomic_or(IORING_SQ_TASKRUN, &ctx->rings->sq_flags);
1351
1352         if (likely(!task_work_add(req->task, &tctx->task_work, ctx->notify_method)))
1353                 return;
1354
1355         io_fallback_tw(tctx, false);
1356 }
1357
1358 void __io_req_task_work_add(struct io_kiocb *req, unsigned flags)
1359 {
1360         if (req->ctx->flags & IORING_SETUP_DEFER_TASKRUN) {
1361                 rcu_read_lock();
1362                 io_req_local_work_add(req, flags);
1363                 rcu_read_unlock();
1364         } else {
1365                 io_req_normal_work_add(req);
1366         }
1367 }
1368
1369 static void __cold io_move_task_work_from_local(struct io_ring_ctx *ctx)
1370 {
1371         struct llist_node *node;
1372
1373         node = llist_del_all(&ctx->work_llist);
1374         while (node) {
1375                 struct io_kiocb *req = container_of(node, struct io_kiocb,
1376                                                     io_task_work.node);
1377
1378                 node = node->next;
1379                 io_req_normal_work_add(req);
1380         }
1381 }
1382
1383 static int __io_run_local_work(struct io_ring_ctx *ctx, struct io_tw_state *ts)
1384 {
1385         struct llist_node *node;
1386         unsigned int loops = 0;
1387         int ret = 0;
1388
1389         if (WARN_ON_ONCE(ctx->submitter_task != current))
1390                 return -EEXIST;
1391         if (ctx->flags & IORING_SETUP_TASKRUN_FLAG)
1392                 atomic_andnot(IORING_SQ_TASKRUN, &ctx->rings->sq_flags);
1393 again:
1394         /*
1395          * llists are in reverse order, flip it back the right way before
1396          * running the pending items.
1397          */
1398         node = llist_reverse_order(io_llist_xchg(&ctx->work_llist, NULL));
1399         while (node) {
1400                 struct llist_node *next = node->next;
1401                 struct io_kiocb *req = container_of(node, struct io_kiocb,
1402                                                     io_task_work.node);
1403                 prefetch(container_of(next, struct io_kiocb, io_task_work.node));
1404                 INDIRECT_CALL_2(req->io_task_work.func,
1405                                 io_poll_task_func, io_req_rw_complete,
1406                                 req, ts);
1407                 ret++;
1408                 node = next;
1409         }
1410         loops++;
1411
1412         if (!llist_empty(&ctx->work_llist))
1413                 goto again;
1414         if (ts->locked) {
1415                 io_submit_flush_completions(ctx);
1416                 if (!llist_empty(&ctx->work_llist))
1417                         goto again;
1418         }
1419         trace_io_uring_local_work_run(ctx, ret, loops);
1420         return ret;
1421 }
1422
1423 static inline int io_run_local_work_locked(struct io_ring_ctx *ctx)
1424 {
1425         struct io_tw_state ts = { .locked = true, };
1426         int ret;
1427
1428         if (llist_empty(&ctx->work_llist))
1429                 return 0;
1430
1431         ret = __io_run_local_work(ctx, &ts);
1432         /* shouldn't happen! */
1433         if (WARN_ON_ONCE(!ts.locked))
1434                 mutex_lock(&ctx->uring_lock);
1435         return ret;
1436 }
1437
1438 static int io_run_local_work(struct io_ring_ctx *ctx)
1439 {
1440         struct io_tw_state ts = {};
1441         int ret;
1442
1443         ts.locked = mutex_trylock(&ctx->uring_lock);
1444         ret = __io_run_local_work(ctx, &ts);
1445         if (ts.locked)
1446                 mutex_unlock(&ctx->uring_lock);
1447
1448         return ret;
1449 }
1450
1451 static void io_req_task_cancel(struct io_kiocb *req, struct io_tw_state *ts)
1452 {
1453         io_tw_lock(req->ctx, ts);
1454         io_req_defer_failed(req, req->cqe.res);
1455 }
1456
1457 void io_req_task_submit(struct io_kiocb *req, struct io_tw_state *ts)
1458 {
1459         io_tw_lock(req->ctx, ts);
1460         /* req->task == current here, checking PF_EXITING is safe */
1461         if (unlikely(req->task->flags & PF_EXITING))
1462                 io_req_defer_failed(req, -EFAULT);
1463         else if (req->flags & REQ_F_FORCE_ASYNC)
1464                 io_queue_iowq(req, ts);
1465         else
1466                 io_queue_sqe(req);
1467 }
1468
1469 void io_req_task_queue_fail(struct io_kiocb *req, int ret)
1470 {
1471         io_req_set_res(req, ret, 0);
1472         req->io_task_work.func = io_req_task_cancel;
1473         io_req_task_work_add(req);
1474 }
1475
1476 void io_req_task_queue(struct io_kiocb *req)
1477 {
1478         req->io_task_work.func = io_req_task_submit;
1479         io_req_task_work_add(req);
1480 }
1481
1482 void io_queue_next(struct io_kiocb *req)
1483 {
1484         struct io_kiocb *nxt = io_req_find_next(req);
1485
1486         if (nxt)
1487                 io_req_task_queue(nxt);
1488 }
1489
1490 static void io_free_batch_list(struct io_ring_ctx *ctx,
1491                                struct io_wq_work_node *node)
1492         __must_hold(&ctx->uring_lock)
1493 {
1494         do {
1495                 struct io_kiocb *req = container_of(node, struct io_kiocb,
1496                                                     comp_list);
1497
1498                 if (unlikely(req->flags & IO_REQ_CLEAN_SLOW_FLAGS)) {
1499                         if (req->flags & REQ_F_REFCOUNT) {
1500                                 node = req->comp_list.next;
1501                                 if (!req_ref_put_and_test(req))
1502                                         continue;
1503                         }
1504                         if ((req->flags & REQ_F_POLLED) && req->apoll) {
1505                                 struct async_poll *apoll = req->apoll;
1506
1507                                 if (apoll->double_poll)
1508                                         kfree(apoll->double_poll);
1509                                 if (!io_alloc_cache_put(&ctx->apoll_cache, &apoll->cache))
1510                                         kfree(apoll);
1511                                 req->flags &= ~REQ_F_POLLED;
1512                         }
1513                         if (req->flags & IO_REQ_LINK_FLAGS)
1514                                 io_queue_next(req);
1515                         if (unlikely(req->flags & IO_REQ_CLEAN_FLAGS))
1516                                 io_clean_op(req);
1517                 }
1518                 io_put_file(req);
1519
1520                 io_req_put_rsrc_locked(req, ctx);
1521
1522                 io_put_task(req->task);
1523                 node = req->comp_list.next;
1524                 io_req_add_to_cache(req, ctx);
1525         } while (node);
1526 }
1527
1528 void __io_submit_flush_completions(struct io_ring_ctx *ctx)
1529         __must_hold(&ctx->uring_lock)
1530 {
1531         struct io_submit_state *state = &ctx->submit_state;
1532         struct io_wq_work_node *node;
1533
1534         __io_cq_lock(ctx);
1535         /* must come first to preserve CQE ordering in failure cases */
1536         if (state->cqes_count)
1537                 __io_flush_post_cqes(ctx);
1538         __wq_list_for_each(node, &state->compl_reqs) {
1539                 struct io_kiocb *req = container_of(node, struct io_kiocb,
1540                                             comp_list);
1541
1542                 if (!(req->flags & REQ_F_CQE_SKIP) &&
1543                     unlikely(!io_fill_cqe_req(ctx, req))) {
1544                         if (ctx->task_complete) {
1545                                 spin_lock(&ctx->completion_lock);
1546                                 io_req_cqe_overflow(req);
1547                                 spin_unlock(&ctx->completion_lock);
1548                         } else {
1549                                 io_req_cqe_overflow(req);
1550                         }
1551                 }
1552         }
1553         __io_cq_unlock_post(ctx);
1554
1555         if (!wq_list_empty(&ctx->submit_state.compl_reqs)) {
1556                 io_free_batch_list(ctx, state->compl_reqs.first);
1557                 INIT_WQ_LIST(&state->compl_reqs);
1558         }
1559 }
1560
1561 static unsigned io_cqring_events(struct io_ring_ctx *ctx)
1562 {
1563         /* See comment at the top of this file */
1564         smp_rmb();
1565         return __io_cqring_events(ctx);
1566 }
1567
1568 /*
1569  * We can't just wait for polled events to come to us, we have to actively
1570  * find and complete them.
1571  */
1572 static __cold void io_iopoll_try_reap_events(struct io_ring_ctx *ctx)
1573 {
1574         if (!(ctx->flags & IORING_SETUP_IOPOLL))
1575                 return;
1576
1577         mutex_lock(&ctx->uring_lock);
1578         while (!wq_list_empty(&ctx->iopoll_list)) {
1579                 /* let it sleep and repeat later if can't complete a request */
1580                 if (io_do_iopoll(ctx, true) == 0)
1581                         break;
1582                 /*
1583                  * Ensure we allow local-to-the-cpu processing to take place,
1584                  * in this case we need to ensure that we reap all events.
1585                  * Also let task_work, etc. to progress by releasing the mutex
1586                  */
1587                 if (need_resched()) {
1588                         mutex_unlock(&ctx->uring_lock);
1589                         cond_resched();
1590                         mutex_lock(&ctx->uring_lock);
1591                 }
1592         }
1593         mutex_unlock(&ctx->uring_lock);
1594 }
1595
1596 static int io_iopoll_check(struct io_ring_ctx *ctx, long min)
1597 {
1598         unsigned int nr_events = 0;
1599         unsigned long check_cq;
1600
1601         if (!io_allowed_run_tw(ctx))
1602                 return -EEXIST;
1603
1604         check_cq = READ_ONCE(ctx->check_cq);
1605         if (unlikely(check_cq)) {
1606                 if (check_cq & BIT(IO_CHECK_CQ_OVERFLOW_BIT))
1607                         __io_cqring_overflow_flush(ctx);
1608                 /*
1609                  * Similarly do not spin if we have not informed the user of any
1610                  * dropped CQE.
1611                  */
1612                 if (check_cq & BIT(IO_CHECK_CQ_DROPPED_BIT))
1613                         return -EBADR;
1614         }
1615         /*
1616          * Don't enter poll loop if we already have events pending.
1617          * If we do, we can potentially be spinning for commands that
1618          * already triggered a CQE (eg in error).
1619          */
1620         if (io_cqring_events(ctx))
1621                 return 0;
1622
1623         do {
1624                 int ret = 0;
1625
1626                 /*
1627                  * If a submit got punted to a workqueue, we can have the
1628                  * application entering polling for a command before it gets
1629                  * issued. That app will hold the uring_lock for the duration
1630                  * of the poll right here, so we need to take a breather every
1631                  * now and then to ensure that the issue has a chance to add
1632                  * the poll to the issued list. Otherwise we can spin here
1633                  * forever, while the workqueue is stuck trying to acquire the
1634                  * very same mutex.
1635                  */
1636                 if (wq_list_empty(&ctx->iopoll_list) ||
1637                     io_task_work_pending(ctx)) {
1638                         u32 tail = ctx->cached_cq_tail;
1639
1640                         (void) io_run_local_work_locked(ctx);
1641
1642                         if (task_work_pending(current) ||
1643                             wq_list_empty(&ctx->iopoll_list)) {
1644                                 mutex_unlock(&ctx->uring_lock);
1645                                 io_run_task_work();
1646                                 mutex_lock(&ctx->uring_lock);
1647                         }
1648                         /* some requests don't go through iopoll_list */
1649                         if (tail != ctx->cached_cq_tail ||
1650                             wq_list_empty(&ctx->iopoll_list))
1651                                 break;
1652                 }
1653                 ret = io_do_iopoll(ctx, !min);
1654                 if (unlikely(ret < 0))
1655                         return ret;
1656
1657                 if (task_sigpending(current))
1658                         return -EINTR;
1659                 if (need_resched())
1660                         break;
1661
1662                 nr_events += ret;
1663         } while (nr_events < min);
1664
1665         return 0;
1666 }
1667
1668 void io_req_task_complete(struct io_kiocb *req, struct io_tw_state *ts)
1669 {
1670         if (ts->locked)
1671                 io_req_complete_defer(req);
1672         else
1673                 io_req_complete_post(req, IO_URING_F_UNLOCKED);
1674 }
1675
1676 /*
1677  * After the iocb has been issued, it's safe to be found on the poll list.
1678  * Adding the kiocb to the list AFTER submission ensures that we don't
1679  * find it from a io_do_iopoll() thread before the issuer is done
1680  * accessing the kiocb cookie.
1681  */
1682 static void io_iopoll_req_issued(struct io_kiocb *req, unsigned int issue_flags)
1683 {
1684         struct io_ring_ctx *ctx = req->ctx;
1685         const bool needs_lock = issue_flags & IO_URING_F_UNLOCKED;
1686
1687         /* workqueue context doesn't hold uring_lock, grab it now */
1688         if (unlikely(needs_lock))
1689                 mutex_lock(&ctx->uring_lock);
1690
1691         /*
1692          * Track whether we have multiple files in our lists. This will impact
1693          * how we do polling eventually, not spinning if we're on potentially
1694          * different devices.
1695          */
1696         if (wq_list_empty(&ctx->iopoll_list)) {
1697                 ctx->poll_multi_queue = false;
1698         } else if (!ctx->poll_multi_queue) {
1699                 struct io_kiocb *list_req;
1700
1701                 list_req = container_of(ctx->iopoll_list.first, struct io_kiocb,
1702                                         comp_list);
1703                 if (list_req->file != req->file)
1704                         ctx->poll_multi_queue = true;
1705         }
1706
1707         /*
1708          * For fast devices, IO may have already completed. If it has, add
1709          * it to the front so we find it first.
1710          */
1711         if (READ_ONCE(req->iopoll_completed))
1712                 wq_list_add_head(&req->comp_list, &ctx->iopoll_list);
1713         else
1714                 wq_list_add_tail(&req->comp_list, &ctx->iopoll_list);
1715
1716         if (unlikely(needs_lock)) {
1717                 /*
1718                  * If IORING_SETUP_SQPOLL is enabled, sqes are either handle
1719                  * in sq thread task context or in io worker task context. If
1720                  * current task context is sq thread, we don't need to check
1721                  * whether should wake up sq thread.
1722                  */
1723                 if ((ctx->flags & IORING_SETUP_SQPOLL) &&
1724                     wq_has_sleeper(&ctx->sq_data->wait))
1725                         wake_up(&ctx->sq_data->wait);
1726
1727                 mutex_unlock(&ctx->uring_lock);
1728         }
1729 }
1730
1731 unsigned int io_file_get_flags(struct file *file)
1732 {
1733         unsigned int res = 0;
1734
1735         if (S_ISREG(file_inode(file)->i_mode))
1736                 res |= REQ_F_ISREG;
1737         if ((file->f_flags & O_NONBLOCK) || (file->f_mode & FMODE_NOWAIT))
1738                 res |= REQ_F_SUPPORT_NOWAIT;
1739         return res;
1740 }
1741
1742 bool io_alloc_async_data(struct io_kiocb *req)
1743 {
1744         WARN_ON_ONCE(!io_cold_defs[req->opcode].async_size);
1745         req->async_data = kmalloc(io_cold_defs[req->opcode].async_size, GFP_KERNEL);
1746         if (req->async_data) {
1747                 req->flags |= REQ_F_ASYNC_DATA;
1748                 return false;
1749         }
1750         return true;
1751 }
1752
1753 int io_req_prep_async(struct io_kiocb *req)
1754 {
1755         const struct io_cold_def *cdef = &io_cold_defs[req->opcode];
1756         const struct io_issue_def *def = &io_issue_defs[req->opcode];
1757
1758         /* assign early for deferred execution for non-fixed file */
1759         if (def->needs_file && !(req->flags & REQ_F_FIXED_FILE) && !req->file)
1760                 req->file = io_file_get_normal(req, req->cqe.fd);
1761         if (!cdef->prep_async)
1762                 return 0;
1763         if (WARN_ON_ONCE(req_has_async_data(req)))
1764                 return -EFAULT;
1765         if (!def->manual_alloc) {
1766                 if (io_alloc_async_data(req))
1767                         return -EAGAIN;
1768         }
1769         return cdef->prep_async(req);
1770 }
1771
1772 static u32 io_get_sequence(struct io_kiocb *req)
1773 {
1774         u32 seq = req->ctx->cached_sq_head;
1775         struct io_kiocb *cur;
1776
1777         /* need original cached_sq_head, but it was increased for each req */
1778         io_for_each_link(cur, req)
1779                 seq--;
1780         return seq;
1781 }
1782
1783 static __cold void io_drain_req(struct io_kiocb *req)
1784         __must_hold(&ctx->uring_lock)
1785 {
1786         struct io_ring_ctx *ctx = req->ctx;
1787         struct io_defer_entry *de;
1788         int ret;
1789         u32 seq = io_get_sequence(req);
1790
1791         /* Still need defer if there is pending req in defer list. */
1792         spin_lock(&ctx->completion_lock);
1793         if (!req_need_defer(req, seq) && list_empty_careful(&ctx->defer_list)) {
1794                 spin_unlock(&ctx->completion_lock);
1795 queue:
1796                 ctx->drain_active = false;
1797                 io_req_task_queue(req);
1798                 return;
1799         }
1800         spin_unlock(&ctx->completion_lock);
1801
1802         io_prep_async_link(req);
1803         de = kmalloc(sizeof(*de), GFP_KERNEL);
1804         if (!de) {
1805                 ret = -ENOMEM;
1806                 io_req_defer_failed(req, ret);
1807                 return;
1808         }
1809
1810         spin_lock(&ctx->completion_lock);
1811         if (!req_need_defer(req, seq) && list_empty(&ctx->defer_list)) {
1812                 spin_unlock(&ctx->completion_lock);
1813                 kfree(de);
1814                 goto queue;
1815         }
1816
1817         trace_io_uring_defer(req);
1818         de->req = req;
1819         de->seq = seq;
1820         list_add_tail(&de->list, &ctx->defer_list);
1821         spin_unlock(&ctx->completion_lock);
1822 }
1823
1824 static bool io_assign_file(struct io_kiocb *req, const struct io_issue_def *def,
1825                            unsigned int issue_flags)
1826 {
1827         if (req->file || !def->needs_file)
1828                 return true;
1829
1830         if (req->flags & REQ_F_FIXED_FILE)
1831                 req->file = io_file_get_fixed(req, req->cqe.fd, issue_flags);
1832         else
1833                 req->file = io_file_get_normal(req, req->cqe.fd);
1834
1835         return !!req->file;
1836 }
1837
1838 static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
1839 {
1840         const struct io_issue_def *def = &io_issue_defs[req->opcode];
1841         const struct cred *creds = NULL;
1842         int ret;
1843
1844         if (unlikely(!io_assign_file(req, def, issue_flags)))
1845                 return -EBADF;
1846
1847         if (unlikely((req->flags & REQ_F_CREDS) && req->creds != current_cred()))
1848                 creds = override_creds(req->creds);
1849
1850         if (!def->audit_skip)
1851                 audit_uring_entry(req->opcode);
1852
1853         ret = def->issue(req, issue_flags);
1854
1855         if (!def->audit_skip)
1856                 audit_uring_exit(!ret, ret);
1857
1858         if (creds)
1859                 revert_creds(creds);
1860
1861         if (ret == IOU_OK) {
1862                 if (issue_flags & IO_URING_F_COMPLETE_DEFER)
1863                         io_req_complete_defer(req);
1864                 else
1865                         io_req_complete_post(req, issue_flags);
1866         } else if (ret != IOU_ISSUE_SKIP_COMPLETE)
1867                 return ret;
1868
1869         /* If the op doesn't have a file, we're not polling for it */
1870         if ((req->ctx->flags & IORING_SETUP_IOPOLL) && def->iopoll_queue)
1871                 io_iopoll_req_issued(req, issue_flags);
1872
1873         return 0;
1874 }
1875
1876 int io_poll_issue(struct io_kiocb *req, struct io_tw_state *ts)
1877 {
1878         io_tw_lock(req->ctx, ts);
1879         return io_issue_sqe(req, IO_URING_F_NONBLOCK|IO_URING_F_MULTISHOT|
1880                                  IO_URING_F_COMPLETE_DEFER);
1881 }
1882
1883 struct io_wq_work *io_wq_free_work(struct io_wq_work *work)
1884 {
1885         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
1886         struct io_kiocb *nxt = NULL;
1887
1888         if (req_ref_put_and_test(req)) {
1889                 if (req->flags & IO_REQ_LINK_FLAGS)
1890                         nxt = io_req_find_next(req);
1891                 io_free_req(req);
1892         }
1893         return nxt ? &nxt->work : NULL;
1894 }
1895
1896 void io_wq_submit_work(struct io_wq_work *work)
1897 {
1898         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
1899         const struct io_issue_def *def = &io_issue_defs[req->opcode];
1900         unsigned int issue_flags = IO_URING_F_UNLOCKED | IO_URING_F_IOWQ;
1901         bool needs_poll = false;
1902         int ret = 0, err = -ECANCELED;
1903
1904         /* one will be dropped by ->io_wq_free_work() after returning to io-wq */
1905         if (!(req->flags & REQ_F_REFCOUNT))
1906                 __io_req_set_refcount(req, 2);
1907         else
1908                 req_ref_get(req);
1909
1910         io_arm_ltimeout(req);
1911
1912         /* either cancelled or io-wq is dying, so don't touch tctx->iowq */
1913         if (work->flags & IO_WQ_WORK_CANCEL) {
1914 fail:
1915                 io_req_task_queue_fail(req, err);
1916                 return;
1917         }
1918         if (!io_assign_file(req, def, issue_flags)) {
1919                 err = -EBADF;
1920                 work->flags |= IO_WQ_WORK_CANCEL;
1921                 goto fail;
1922         }
1923
1924         if (req->flags & REQ_F_FORCE_ASYNC) {
1925                 bool opcode_poll = def->pollin || def->pollout;
1926
1927                 if (opcode_poll && file_can_poll(req->file)) {
1928                         needs_poll = true;
1929                         issue_flags |= IO_URING_F_NONBLOCK;
1930                 }
1931         }
1932
1933         do {
1934                 ret = io_issue_sqe(req, issue_flags);
1935                 if (ret != -EAGAIN)
1936                         break;
1937                 /*
1938                  * We can get EAGAIN for iopolled IO even though we're
1939                  * forcing a sync submission from here, since we can't
1940                  * wait for request slots on the block side.
1941                  */
1942                 if (!needs_poll) {
1943                         if (!(req->ctx->flags & IORING_SETUP_IOPOLL))
1944                                 break;
1945                         cond_resched();
1946                         continue;
1947                 }
1948
1949                 if (io_arm_poll_handler(req, issue_flags) == IO_APOLL_OK)
1950                         return;
1951                 /* aborted or ready, in either case retry blocking */
1952                 needs_poll = false;
1953                 issue_flags &= ~IO_URING_F_NONBLOCK;
1954         } while (1);
1955
1956         /* avoid locking problems by failing it from a clean context */
1957         if (ret < 0)
1958                 io_req_task_queue_fail(req, ret);
1959 }
1960
1961 inline struct file *io_file_get_fixed(struct io_kiocb *req, int fd,
1962                                       unsigned int issue_flags)
1963 {
1964         struct io_ring_ctx *ctx = req->ctx;
1965         struct io_fixed_file *slot;
1966         struct file *file = NULL;
1967
1968         io_ring_submit_lock(ctx, issue_flags);
1969
1970         if (unlikely((unsigned int)fd >= ctx->nr_user_files))
1971                 goto out;
1972         fd = array_index_nospec(fd, ctx->nr_user_files);
1973         slot = io_fixed_file_slot(&ctx->file_table, fd);
1974         file = io_slot_file(slot);
1975         req->flags |= io_slot_flags(slot);
1976         io_req_set_rsrc_node(req, ctx, 0);
1977 out:
1978         io_ring_submit_unlock(ctx, issue_flags);
1979         return file;
1980 }
1981
1982 struct file *io_file_get_normal(struct io_kiocb *req, int fd)
1983 {
1984         struct file *file = fget(fd);
1985
1986         trace_io_uring_file_get(req, fd);
1987
1988         /* we don't allow fixed io_uring files */
1989         if (file && io_is_uring_fops(file))
1990                 io_req_track_inflight(req);
1991         return file;
1992 }
1993
1994 static void io_queue_async(struct io_kiocb *req, int ret)
1995         __must_hold(&req->ctx->uring_lock)
1996 {
1997         struct io_kiocb *linked_timeout;
1998
1999         if (ret != -EAGAIN || (req->flags & REQ_F_NOWAIT)) {
2000                 io_req_defer_failed(req, ret);
2001                 return;
2002         }
2003
2004         linked_timeout = io_prep_linked_timeout(req);
2005
2006         switch (io_arm_poll_handler(req, 0)) {
2007         case IO_APOLL_READY:
2008                 io_kbuf_recycle(req, 0);
2009                 io_req_task_queue(req);
2010                 break;
2011         case IO_APOLL_ABORTED:
2012                 io_kbuf_recycle(req, 0);
2013                 io_queue_iowq(req, NULL);
2014                 break;
2015         case IO_APOLL_OK:
2016                 break;
2017         }
2018
2019         if (linked_timeout)
2020                 io_queue_linked_timeout(linked_timeout);
2021 }
2022
2023 static inline void io_queue_sqe(struct io_kiocb *req)
2024         __must_hold(&req->ctx->uring_lock)
2025 {
2026         int ret;
2027
2028         ret = io_issue_sqe(req, IO_URING_F_NONBLOCK|IO_URING_F_COMPLETE_DEFER);
2029
2030         /*
2031          * We async punt it if the file wasn't marked NOWAIT, or if the file
2032          * doesn't support non-blocking read/write attempts
2033          */
2034         if (likely(!ret))
2035                 io_arm_ltimeout(req);
2036         else
2037                 io_queue_async(req, ret);
2038 }
2039
2040 static void io_queue_sqe_fallback(struct io_kiocb *req)
2041         __must_hold(&req->ctx->uring_lock)
2042 {
2043         if (unlikely(req->flags & REQ_F_FAIL)) {
2044                 /*
2045                  * We don't submit, fail them all, for that replace hardlinks
2046                  * with normal links. Extra REQ_F_LINK is tolerated.
2047                  */
2048                 req->flags &= ~REQ_F_HARDLINK;
2049                 req->flags |= REQ_F_LINK;
2050                 io_req_defer_failed(req, req->cqe.res);
2051         } else {
2052                 int ret = io_req_prep_async(req);
2053
2054                 if (unlikely(ret)) {
2055                         io_req_defer_failed(req, ret);
2056                         return;
2057                 }
2058
2059                 if (unlikely(req->ctx->drain_active))
2060                         io_drain_req(req);
2061                 else
2062                         io_queue_iowq(req, NULL);
2063         }
2064 }
2065
2066 /*
2067  * Check SQE restrictions (opcode and flags).
2068  *
2069  * Returns 'true' if SQE is allowed, 'false' otherwise.
2070  */
2071 static inline bool io_check_restriction(struct io_ring_ctx *ctx,
2072                                         struct io_kiocb *req,
2073                                         unsigned int sqe_flags)
2074 {
2075         if (!test_bit(req->opcode, ctx->restrictions.sqe_op))
2076                 return false;
2077
2078         if ((sqe_flags & ctx->restrictions.sqe_flags_required) !=
2079             ctx->restrictions.sqe_flags_required)
2080                 return false;
2081
2082         if (sqe_flags & ~(ctx->restrictions.sqe_flags_allowed |
2083                           ctx->restrictions.sqe_flags_required))
2084                 return false;
2085
2086         return true;
2087 }
2088
2089 static void io_init_req_drain(struct io_kiocb *req)
2090 {
2091         struct io_ring_ctx *ctx = req->ctx;
2092         struct io_kiocb *head = ctx->submit_state.link.head;
2093
2094         ctx->drain_active = true;
2095         if (head) {
2096                 /*
2097                  * If we need to drain a request in the middle of a link, drain
2098                  * the head request and the next request/link after the current
2099                  * link. Considering sequential execution of links,
2100                  * REQ_F_IO_DRAIN will be maintained for every request of our
2101                  * link.
2102                  */
2103                 head->flags |= REQ_F_IO_DRAIN | REQ_F_FORCE_ASYNC;
2104                 ctx->drain_next = true;
2105         }
2106 }
2107
2108 static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req,
2109                        const struct io_uring_sqe *sqe)
2110         __must_hold(&ctx->uring_lock)
2111 {
2112         const struct io_issue_def *def;
2113         unsigned int sqe_flags;
2114         int personality;
2115         u8 opcode;
2116
2117         /* req is partially pre-initialised, see io_preinit_req() */
2118         req->opcode = opcode = READ_ONCE(sqe->opcode);
2119         /* same numerical values with corresponding REQ_F_*, safe to copy */
2120         req->flags = sqe_flags = READ_ONCE(sqe->flags);
2121         req->cqe.user_data = READ_ONCE(sqe->user_data);
2122         req->file = NULL;
2123         req->rsrc_node = NULL;
2124         req->task = current;
2125
2126         if (unlikely(opcode >= IORING_OP_LAST)) {
2127                 req->opcode = 0;
2128                 return -EINVAL;
2129         }
2130         def = &io_issue_defs[opcode];
2131         if (unlikely(sqe_flags & ~SQE_COMMON_FLAGS)) {
2132                 /* enforce forwards compatibility on users */
2133                 if (sqe_flags & ~SQE_VALID_FLAGS)
2134                         return -EINVAL;
2135                 if (sqe_flags & IOSQE_BUFFER_SELECT) {
2136                         if (!def->buffer_select)
2137                                 return -EOPNOTSUPP;
2138                         req->buf_index = READ_ONCE(sqe->buf_group);
2139                 }
2140                 if (sqe_flags & IOSQE_CQE_SKIP_SUCCESS)
2141                         ctx->drain_disabled = true;
2142                 if (sqe_flags & IOSQE_IO_DRAIN) {
2143                         if (ctx->drain_disabled)
2144                                 return -EOPNOTSUPP;
2145                         io_init_req_drain(req);
2146                 }
2147         }
2148         if (unlikely(ctx->restricted || ctx->drain_active || ctx->drain_next)) {
2149                 if (ctx->restricted && !io_check_restriction(ctx, req, sqe_flags))
2150                         return -EACCES;
2151                 /* knock it to the slow queue path, will be drained there */
2152                 if (ctx->drain_active)
2153                         req->flags |= REQ_F_FORCE_ASYNC;
2154                 /* if there is no link, we're at "next" request and need to drain */
2155                 if (unlikely(ctx->drain_next) && !ctx->submit_state.link.head) {
2156                         ctx->drain_next = false;
2157                         ctx->drain_active = true;
2158                         req->flags |= REQ_F_IO_DRAIN | REQ_F_FORCE_ASYNC;
2159                 }
2160         }
2161
2162         if (!def->ioprio && sqe->ioprio)
2163                 return -EINVAL;
2164         if (!def->iopoll && (ctx->flags & IORING_SETUP_IOPOLL))
2165                 return -EINVAL;
2166
2167         if (def->needs_file) {
2168                 struct io_submit_state *state = &ctx->submit_state;
2169
2170                 req->cqe.fd = READ_ONCE(sqe->fd);
2171
2172                 /*
2173                  * Plug now if we have more than 2 IO left after this, and the
2174                  * target is potentially a read/write to block based storage.
2175                  */
2176                 if (state->need_plug && def->plug) {
2177                         state->plug_started = true;
2178                         state->need_plug = false;
2179                         blk_start_plug_nr_ios(&state->plug, state->submit_nr);
2180                 }
2181         }
2182
2183         personality = READ_ONCE(sqe->personality);
2184         if (personality) {
2185                 int ret;
2186
2187                 req->creds = xa_load(&ctx->personalities, personality);
2188                 if (!req->creds)
2189                         return -EINVAL;
2190                 get_cred(req->creds);
2191                 ret = security_uring_override_creds(req->creds);
2192                 if (ret) {
2193                         put_cred(req->creds);
2194                         return ret;
2195                 }
2196                 req->flags |= REQ_F_CREDS;
2197         }
2198
2199         return def->prep(req, sqe);
2200 }
2201
2202 static __cold int io_submit_fail_init(const struct io_uring_sqe *sqe,
2203                                       struct io_kiocb *req, int ret)
2204 {
2205         struct io_ring_ctx *ctx = req->ctx;
2206         struct io_submit_link *link = &ctx->submit_state.link;
2207         struct io_kiocb *head = link->head;
2208
2209         trace_io_uring_req_failed(sqe, req, ret);
2210
2211         /*
2212          * Avoid breaking links in the middle as it renders links with SQPOLL
2213          * unusable. Instead of failing eagerly, continue assembling the link if
2214          * applicable and mark the head with REQ_F_FAIL. The link flushing code
2215          * should find the flag and handle the rest.
2216          */
2217         req_fail_link_node(req, ret);
2218         if (head && !(head->flags & REQ_F_FAIL))
2219                 req_fail_link_node(head, -ECANCELED);
2220
2221         if (!(req->flags & IO_REQ_LINK_FLAGS)) {
2222                 if (head) {
2223                         link->last->link = req;
2224                         link->head = NULL;
2225                         req = head;
2226                 }
2227                 io_queue_sqe_fallback(req);
2228                 return ret;
2229         }
2230
2231         if (head)
2232                 link->last->link = req;
2233         else
2234                 link->head = req;
2235         link->last = req;
2236         return 0;
2237 }
2238
2239 static inline int io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
2240                          const struct io_uring_sqe *sqe)
2241         __must_hold(&ctx->uring_lock)
2242 {
2243         struct io_submit_link *link = &ctx->submit_state.link;
2244         int ret;
2245
2246         ret = io_init_req(ctx, req, sqe);
2247         if (unlikely(ret))
2248                 return io_submit_fail_init(sqe, req, ret);
2249
2250         trace_io_uring_submit_req(req);
2251
2252         /*
2253          * If we already have a head request, queue this one for async
2254          * submittal once the head completes. If we don't have a head but
2255          * IOSQE_IO_LINK is set in the sqe, start a new head. This one will be
2256          * submitted sync once the chain is complete. If none of those
2257          * conditions are true (normal request), then just queue it.
2258          */
2259         if (unlikely(link->head)) {
2260                 ret = io_req_prep_async(req);
2261                 if (unlikely(ret))
2262                         return io_submit_fail_init(sqe, req, ret);
2263
2264                 trace_io_uring_link(req, link->head);
2265                 link->last->link = req;
2266                 link->last = req;
2267
2268                 if (req->flags & IO_REQ_LINK_FLAGS)
2269                         return 0;
2270                 /* last request of the link, flush it */
2271                 req = link->head;
2272                 link->head = NULL;
2273                 if (req->flags & (REQ_F_FORCE_ASYNC | REQ_F_FAIL))
2274                         goto fallback;
2275
2276         } else if (unlikely(req->flags & (IO_REQ_LINK_FLAGS |
2277                                           REQ_F_FORCE_ASYNC | REQ_F_FAIL))) {
2278                 if (req->flags & IO_REQ_LINK_FLAGS) {
2279                         link->head = req;
2280                         link->last = req;
2281                 } else {
2282 fallback:
2283                         io_queue_sqe_fallback(req);
2284                 }
2285                 return 0;
2286         }
2287
2288         io_queue_sqe(req);
2289         return 0;
2290 }
2291
2292 /*
2293  * Batched submission is done, ensure local IO is flushed out.
2294  */
2295 static void io_submit_state_end(struct io_ring_ctx *ctx)
2296 {
2297         struct io_submit_state *state = &ctx->submit_state;
2298
2299         if (unlikely(state->link.head))
2300                 io_queue_sqe_fallback(state->link.head);
2301         /* flush only after queuing links as they can generate completions */
2302         io_submit_flush_completions(ctx);
2303         if (state->plug_started)
2304                 blk_finish_plug(&state->plug);
2305 }
2306
2307 /*
2308  * Start submission side cache.
2309  */
2310 static void io_submit_state_start(struct io_submit_state *state,
2311                                   unsigned int max_ios)
2312 {
2313         state->plug_started = false;
2314         state->need_plug = max_ios > 2;
2315         state->submit_nr = max_ios;
2316         /* set only head, no need to init link_last in advance */
2317         state->link.head = NULL;
2318 }
2319
2320 static void io_commit_sqring(struct io_ring_ctx *ctx)
2321 {
2322         struct io_rings *rings = ctx->rings;
2323
2324         /*
2325          * Ensure any loads from the SQEs are done at this point,
2326          * since once we write the new head, the application could
2327          * write new data to them.
2328          */
2329         smp_store_release(&rings->sq.head, ctx->cached_sq_head);
2330 }
2331
2332 /*
2333  * Fetch an sqe, if one is available. Note this returns a pointer to memory
2334  * that is mapped by userspace. This means that care needs to be taken to
2335  * ensure that reads are stable, as we cannot rely on userspace always
2336  * being a good citizen. If members of the sqe are validated and then later
2337  * used, it's important that those reads are done through READ_ONCE() to
2338  * prevent a re-load down the line.
2339  */
2340 static bool io_get_sqe(struct io_ring_ctx *ctx, const struct io_uring_sqe **sqe)
2341 {
2342         unsigned head, mask = ctx->sq_entries - 1;
2343         unsigned sq_idx = ctx->cached_sq_head++ & mask;
2344
2345         /*
2346          * The cached sq head (or cq tail) serves two purposes:
2347          *
2348          * 1) allows us to batch the cost of updating the user visible
2349          *    head updates.
2350          * 2) allows the kernel side to track the head on its own, even
2351          *    though the application is the one updating it.
2352          */
2353         head = READ_ONCE(ctx->sq_array[sq_idx]);
2354         if (likely(head < ctx->sq_entries)) {
2355                 /* double index for 128-byte SQEs, twice as long */
2356                 if (ctx->flags & IORING_SETUP_SQE128)
2357                         head <<= 1;
2358                 *sqe = &ctx->sq_sqes[head];
2359                 return true;
2360         }
2361
2362         /* drop invalid entries */
2363         spin_lock(&ctx->completion_lock);
2364         ctx->cq_extra--;
2365         spin_unlock(&ctx->completion_lock);
2366         WRITE_ONCE(ctx->rings->sq_dropped,
2367                    READ_ONCE(ctx->rings->sq_dropped) + 1);
2368         return false;
2369 }
2370
2371 int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr)
2372         __must_hold(&ctx->uring_lock)
2373 {
2374         unsigned int entries = io_sqring_entries(ctx);
2375         unsigned int left;
2376         int ret;
2377
2378         if (unlikely(!entries))
2379                 return 0;
2380         /* make sure SQ entry isn't read before tail */
2381         ret = left = min(nr, entries);
2382         io_get_task_refs(left);
2383         io_submit_state_start(&ctx->submit_state, left);
2384
2385         do {
2386                 const struct io_uring_sqe *sqe;
2387                 struct io_kiocb *req;
2388
2389                 if (unlikely(!io_alloc_req(ctx, &req)))
2390                         break;
2391                 if (unlikely(!io_get_sqe(ctx, &sqe))) {
2392                         io_req_add_to_cache(req, ctx);
2393                         break;
2394                 }
2395
2396                 /*
2397                  * Continue submitting even for sqe failure if the
2398                  * ring was setup with IORING_SETUP_SUBMIT_ALL
2399                  */
2400                 if (unlikely(io_submit_sqe(ctx, req, sqe)) &&
2401                     !(ctx->flags & IORING_SETUP_SUBMIT_ALL)) {
2402                         left--;
2403                         break;
2404                 }
2405         } while (--left);
2406
2407         if (unlikely(left)) {
2408                 ret -= left;
2409                 /* try again if it submitted nothing and can't allocate a req */
2410                 if (!ret && io_req_cache_empty(ctx))
2411                         ret = -EAGAIN;
2412                 current->io_uring->cached_refs += left;
2413         }
2414
2415         io_submit_state_end(ctx);
2416          /* Commit SQ ring head once we've consumed and submitted all SQEs */
2417         io_commit_sqring(ctx);
2418         return ret;
2419 }
2420
2421 struct io_wait_queue {
2422         struct wait_queue_entry wq;
2423         struct io_ring_ctx *ctx;
2424         unsigned cq_tail;
2425         unsigned nr_timeouts;
2426         ktime_t timeout;
2427 };
2428
2429 static inline bool io_has_work(struct io_ring_ctx *ctx)
2430 {
2431         return test_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq) ||
2432                !llist_empty(&ctx->work_llist);
2433 }
2434
2435 static inline bool io_should_wake(struct io_wait_queue *iowq)
2436 {
2437         struct io_ring_ctx *ctx = iowq->ctx;
2438         int dist = READ_ONCE(ctx->rings->cq.tail) - (int) iowq->cq_tail;
2439
2440         /*
2441          * Wake up if we have enough events, or if a timeout occurred since we
2442          * started waiting. For timeouts, we always want to return to userspace,
2443          * regardless of event count.
2444          */
2445         return dist >= 0 || atomic_read(&ctx->cq_timeouts) != iowq->nr_timeouts;
2446 }
2447
2448 static int io_wake_function(struct wait_queue_entry *curr, unsigned int mode,
2449                             int wake_flags, void *key)
2450 {
2451         struct io_wait_queue *iowq = container_of(curr, struct io_wait_queue, wq);
2452
2453         /*
2454          * Cannot safely flush overflowed CQEs from here, ensure we wake up
2455          * the task, and the next invocation will do it.
2456          */
2457         if (io_should_wake(iowq) || io_has_work(iowq->ctx))
2458                 return autoremove_wake_function(curr, mode, wake_flags, key);
2459         return -1;
2460 }
2461
2462 int io_run_task_work_sig(struct io_ring_ctx *ctx)
2463 {
2464         if (!llist_empty(&ctx->work_llist)) {
2465                 __set_current_state(TASK_RUNNING);
2466                 if (io_run_local_work(ctx) > 0)
2467                         return 0;
2468         }
2469         if (io_run_task_work() > 0)
2470                 return 0;
2471         if (task_sigpending(current))
2472                 return -EINTR;
2473         return 0;
2474 }
2475
2476 /* when returns >0, the caller should retry */
2477 static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx,
2478                                           struct io_wait_queue *iowq)
2479 {
2480         int token, ret;
2481
2482         if (unlikely(READ_ONCE(ctx->check_cq)))
2483                 return 1;
2484         if (unlikely(!llist_empty(&ctx->work_llist)))
2485                 return 1;
2486         if (unlikely(test_thread_flag(TIF_NOTIFY_SIGNAL)))
2487                 return 1;
2488         if (unlikely(task_sigpending(current)))
2489                 return -EINTR;
2490         if (unlikely(io_should_wake(iowq)))
2491                 return 0;
2492
2493         /*
2494          * Use io_schedule_prepare/finish, so cpufreq can take into account
2495          * that the task is waiting for IO - turns out to be important for low
2496          * QD IO.
2497          */
2498         token = io_schedule_prepare();
2499         ret = 0;
2500         if (iowq->timeout == KTIME_MAX)
2501                 schedule();
2502         else if (!schedule_hrtimeout(&iowq->timeout, HRTIMER_MODE_ABS))
2503                 ret = -ETIME;
2504         io_schedule_finish(token);
2505         return ret;
2506 }
2507
2508 /*
2509  * Wait until events become available, if we don't already have some. The
2510  * application must reap them itself, as they reside on the shared cq ring.
2511  */
2512 static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
2513                           const sigset_t __user *sig, size_t sigsz,
2514                           struct __kernel_timespec __user *uts)
2515 {
2516         struct io_wait_queue iowq;
2517         struct io_rings *rings = ctx->rings;
2518         int ret;
2519
2520         if (!io_allowed_run_tw(ctx))
2521                 return -EEXIST;
2522         if (!llist_empty(&ctx->work_llist))
2523                 io_run_local_work(ctx);
2524         io_run_task_work();
2525         io_cqring_overflow_flush(ctx);
2526         /* if user messes with these they will just get an early return */
2527         if (__io_cqring_events_user(ctx) >= min_events)
2528                 return 0;
2529
2530         if (sig) {
2531 #ifdef CONFIG_COMPAT
2532                 if (in_compat_syscall())
2533                         ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
2534                                                       sigsz);
2535                 else
2536 #endif
2537                         ret = set_user_sigmask(sig, sigsz);
2538
2539                 if (ret)
2540                         return ret;
2541         }
2542
2543         init_waitqueue_func_entry(&iowq.wq, io_wake_function);
2544         iowq.wq.private = current;
2545         INIT_LIST_HEAD(&iowq.wq.entry);
2546         iowq.ctx = ctx;
2547         iowq.nr_timeouts = atomic_read(&ctx->cq_timeouts);
2548         iowq.cq_tail = READ_ONCE(ctx->rings->cq.head) + min_events;
2549         iowq.timeout = KTIME_MAX;
2550
2551         if (uts) {
2552                 struct timespec64 ts;
2553
2554                 if (get_timespec64(&ts, uts))
2555                         return -EFAULT;
2556                 iowq.timeout = ktime_add_ns(timespec64_to_ktime(ts), ktime_get_ns());
2557         }
2558
2559         trace_io_uring_cqring_wait(ctx, min_events);
2560         do {
2561                 unsigned long check_cq;
2562
2563                 if (ctx->flags & IORING_SETUP_DEFER_TASKRUN) {
2564                         int nr_wait = (int) iowq.cq_tail - READ_ONCE(ctx->rings->cq.tail);
2565
2566                         atomic_set(&ctx->cq_wait_nr, nr_wait);
2567                         set_current_state(TASK_INTERRUPTIBLE);
2568                 } else {
2569                         prepare_to_wait_exclusive(&ctx->cq_wait, &iowq.wq,
2570                                                         TASK_INTERRUPTIBLE);
2571                 }
2572
2573                 ret = io_cqring_wait_schedule(ctx, &iowq);
2574                 __set_current_state(TASK_RUNNING);
2575                 atomic_set(&ctx->cq_wait_nr, 0);
2576
2577                 if (ret < 0)
2578                         break;
2579                 /*
2580                  * Run task_work after scheduling and before io_should_wake().
2581                  * If we got woken because of task_work being processed, run it
2582                  * now rather than let the caller do another wait loop.
2583                  */
2584                 io_run_task_work();
2585                 if (!llist_empty(&ctx->work_llist))
2586                         io_run_local_work(ctx);
2587
2588                 check_cq = READ_ONCE(ctx->check_cq);
2589                 if (unlikely(check_cq)) {
2590                         /* let the caller flush overflows, retry */
2591                         if (check_cq & BIT(IO_CHECK_CQ_OVERFLOW_BIT))
2592                                 io_cqring_do_overflow_flush(ctx);
2593                         if (check_cq & BIT(IO_CHECK_CQ_DROPPED_BIT)) {
2594                                 ret = -EBADR;
2595                                 break;
2596                         }
2597                 }
2598
2599                 if (io_should_wake(&iowq)) {
2600                         ret = 0;
2601                         break;
2602                 }
2603                 cond_resched();
2604         } while (1);
2605
2606         if (!(ctx->flags & IORING_SETUP_DEFER_TASKRUN))
2607                 finish_wait(&ctx->cq_wait, &iowq.wq);
2608         restore_saved_sigmask_unless(ret == -EINTR);
2609
2610         return READ_ONCE(rings->cq.head) == READ_ONCE(rings->cq.tail) ? ret : 0;
2611 }
2612
2613 static void io_mem_free(void *ptr)
2614 {
2615         struct page *page;
2616
2617         if (!ptr)
2618                 return;
2619
2620         page = virt_to_head_page(ptr);
2621         if (put_page_testzero(page))
2622                 free_compound_page(page);
2623 }
2624
2625 static void io_pages_free(struct page ***pages, int npages)
2626 {
2627         struct page **page_array;
2628         int i;
2629
2630         if (!pages)
2631                 return;
2632         page_array = *pages;
2633         for (i = 0; i < npages; i++)
2634                 unpin_user_page(page_array[i]);
2635         kvfree(page_array);
2636         *pages = NULL;
2637 }
2638
2639 static void *__io_uaddr_map(struct page ***pages, unsigned short *npages,
2640                             unsigned long uaddr, size_t size)
2641 {
2642         struct page **page_array;
2643         unsigned int nr_pages;
2644         int ret;
2645
2646         *npages = 0;
2647
2648         if (uaddr & (PAGE_SIZE - 1) || !size)
2649                 return ERR_PTR(-EINVAL);
2650
2651         nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
2652         if (nr_pages > USHRT_MAX)
2653                 return ERR_PTR(-EINVAL);
2654         page_array = kvmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL);
2655         if (!page_array)
2656                 return ERR_PTR(-ENOMEM);
2657
2658         ret = pin_user_pages_fast(uaddr, nr_pages, FOLL_WRITE | FOLL_LONGTERM,
2659                                         page_array);
2660         if (ret != nr_pages) {
2661 err:
2662                 io_pages_free(&page_array, ret > 0 ? ret : 0);
2663                 return ret < 0 ? ERR_PTR(ret) : ERR_PTR(-EFAULT);
2664         }
2665         /*
2666          * Should be a single page. If the ring is small enough that we can
2667          * use a normal page, that is fine. If we need multiple pages, then
2668          * userspace should use a huge page. That's the only way to guarantee
2669          * that we get contigious memory, outside of just being lucky or
2670          * (currently) having low memory fragmentation.
2671          */
2672         if (page_array[0] != page_array[ret - 1])
2673                 goto err;
2674         *pages = page_array;
2675         *npages = nr_pages;
2676         return page_to_virt(page_array[0]);
2677 }
2678
2679 static void *io_rings_map(struct io_ring_ctx *ctx, unsigned long uaddr,
2680                           size_t size)
2681 {
2682         return __io_uaddr_map(&ctx->ring_pages, &ctx->n_ring_pages, uaddr,
2683                                 size);
2684 }
2685
2686 static void *io_sqes_map(struct io_ring_ctx *ctx, unsigned long uaddr,
2687                          size_t size)
2688 {
2689         return __io_uaddr_map(&ctx->sqe_pages, &ctx->n_sqe_pages, uaddr,
2690                                 size);
2691 }
2692
2693 static void io_rings_free(struct io_ring_ctx *ctx)
2694 {
2695         if (!(ctx->flags & IORING_SETUP_NO_MMAP)) {
2696                 io_mem_free(ctx->rings);
2697                 io_mem_free(ctx->sq_sqes);
2698                 ctx->rings = NULL;
2699                 ctx->sq_sqes = NULL;
2700         } else {
2701                 io_pages_free(&ctx->ring_pages, ctx->n_ring_pages);
2702                 io_pages_free(&ctx->sqe_pages, ctx->n_sqe_pages);
2703         }
2704 }
2705
2706 static void *io_mem_alloc(size_t size)
2707 {
2708         gfp_t gfp = GFP_KERNEL_ACCOUNT | __GFP_ZERO | __GFP_NOWARN | __GFP_COMP;
2709         void *ret;
2710
2711         ret = (void *) __get_free_pages(gfp, get_order(size));
2712         if (ret)
2713                 return ret;
2714         return ERR_PTR(-ENOMEM);
2715 }
2716
2717 static unsigned long rings_size(struct io_ring_ctx *ctx, unsigned int sq_entries,
2718                                 unsigned int cq_entries, size_t *sq_offset)
2719 {
2720         struct io_rings *rings;
2721         size_t off, sq_array_size;
2722
2723         off = struct_size(rings, cqes, cq_entries);
2724         if (off == SIZE_MAX)
2725                 return SIZE_MAX;
2726         if (ctx->flags & IORING_SETUP_CQE32) {
2727                 if (check_shl_overflow(off, 1, &off))
2728                         return SIZE_MAX;
2729         }
2730
2731 #ifdef CONFIG_SMP
2732         off = ALIGN(off, SMP_CACHE_BYTES);
2733         if (off == 0)
2734                 return SIZE_MAX;
2735 #endif
2736
2737         if (sq_offset)
2738                 *sq_offset = off;
2739
2740         sq_array_size = array_size(sizeof(u32), sq_entries);
2741         if (sq_array_size == SIZE_MAX)
2742                 return SIZE_MAX;
2743
2744         if (check_add_overflow(off, sq_array_size, &off))
2745                 return SIZE_MAX;
2746
2747         return off;
2748 }
2749
2750 static int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg,
2751                                unsigned int eventfd_async)
2752 {
2753         struct io_ev_fd *ev_fd;
2754         __s32 __user *fds = arg;
2755         int fd;
2756
2757         ev_fd = rcu_dereference_protected(ctx->io_ev_fd,
2758                                         lockdep_is_held(&ctx->uring_lock));
2759         if (ev_fd)
2760                 return -EBUSY;
2761
2762         if (copy_from_user(&fd, fds, sizeof(*fds)))
2763                 return -EFAULT;
2764
2765         ev_fd = kmalloc(sizeof(*ev_fd), GFP_KERNEL);
2766         if (!ev_fd)
2767                 return -ENOMEM;
2768
2769         ev_fd->cq_ev_fd = eventfd_ctx_fdget(fd);
2770         if (IS_ERR(ev_fd->cq_ev_fd)) {
2771                 int ret = PTR_ERR(ev_fd->cq_ev_fd);
2772                 kfree(ev_fd);
2773                 return ret;
2774         }
2775
2776         spin_lock(&ctx->completion_lock);
2777         ctx->evfd_last_cq_tail = ctx->cached_cq_tail;
2778         spin_unlock(&ctx->completion_lock);
2779
2780         ev_fd->eventfd_async = eventfd_async;
2781         ctx->has_evfd = true;
2782         rcu_assign_pointer(ctx->io_ev_fd, ev_fd);
2783         atomic_set(&ev_fd->refs, 1);
2784         atomic_set(&ev_fd->ops, 0);
2785         return 0;
2786 }
2787
2788 static int io_eventfd_unregister(struct io_ring_ctx *ctx)
2789 {
2790         struct io_ev_fd *ev_fd;
2791
2792         ev_fd = rcu_dereference_protected(ctx->io_ev_fd,
2793                                         lockdep_is_held(&ctx->uring_lock));
2794         if (ev_fd) {
2795                 ctx->has_evfd = false;
2796                 rcu_assign_pointer(ctx->io_ev_fd, NULL);
2797                 if (!atomic_fetch_or(BIT(IO_EVENTFD_OP_FREE_BIT), &ev_fd->ops))
2798                         call_rcu(&ev_fd->rcu, io_eventfd_ops);
2799                 return 0;
2800         }
2801
2802         return -ENXIO;
2803 }
2804
2805 static void io_req_caches_free(struct io_ring_ctx *ctx)
2806 {
2807         struct io_kiocb *req;
2808         int nr = 0;
2809
2810         mutex_lock(&ctx->uring_lock);
2811         io_flush_cached_locked_reqs(ctx, &ctx->submit_state);
2812
2813         while (!io_req_cache_empty(ctx)) {
2814                 req = io_extract_req(ctx);
2815                 kmem_cache_free(req_cachep, req);
2816                 nr++;
2817         }
2818         if (nr)
2819                 percpu_ref_put_many(&ctx->refs, nr);
2820         mutex_unlock(&ctx->uring_lock);
2821 }
2822
2823 static void io_rsrc_node_cache_free(struct io_cache_entry *entry)
2824 {
2825         kfree(container_of(entry, struct io_rsrc_node, cache));
2826 }
2827
2828 static __cold void io_ring_ctx_free(struct io_ring_ctx *ctx)
2829 {
2830         io_sq_thread_finish(ctx);
2831         /* __io_rsrc_put_work() may need uring_lock to progress, wait w/o it */
2832         if (WARN_ON_ONCE(!list_empty(&ctx->rsrc_ref_list)))
2833                 return;
2834
2835         mutex_lock(&ctx->uring_lock);
2836         if (ctx->buf_data)
2837                 __io_sqe_buffers_unregister(ctx);
2838         if (ctx->file_data)
2839                 __io_sqe_files_unregister(ctx);
2840         io_cqring_overflow_kill(ctx);
2841         io_eventfd_unregister(ctx);
2842         io_alloc_cache_free(&ctx->apoll_cache, io_apoll_cache_free);
2843         io_alloc_cache_free(&ctx->netmsg_cache, io_netmsg_cache_free);
2844         io_destroy_buffers(ctx);
2845         mutex_unlock(&ctx->uring_lock);
2846         if (ctx->sq_creds)
2847                 put_cred(ctx->sq_creds);
2848         if (ctx->submitter_task)
2849                 put_task_struct(ctx->submitter_task);
2850
2851         /* there are no registered resources left, nobody uses it */
2852         if (ctx->rsrc_node)
2853                 io_rsrc_node_destroy(ctx, ctx->rsrc_node);
2854
2855         WARN_ON_ONCE(!list_empty(&ctx->rsrc_ref_list));
2856
2857 #if defined(CONFIG_UNIX)
2858         if (ctx->ring_sock) {
2859                 ctx->ring_sock->file = NULL; /* so that iput() is called */
2860                 sock_release(ctx->ring_sock);
2861         }
2862 #endif
2863         WARN_ON_ONCE(!list_empty(&ctx->ltimeout_list));
2864
2865         io_alloc_cache_free(&ctx->rsrc_node_cache, io_rsrc_node_cache_free);
2866         if (ctx->mm_account) {
2867                 mmdrop(ctx->mm_account);
2868                 ctx->mm_account = NULL;
2869         }
2870         io_rings_free(ctx);
2871
2872         percpu_ref_exit(&ctx->refs);
2873         free_uid(ctx->user);
2874         io_req_caches_free(ctx);
2875         if (ctx->hash_map)
2876                 io_wq_put_hash(ctx->hash_map);
2877         kfree(ctx->cancel_table.hbs);
2878         kfree(ctx->cancel_table_locked.hbs);
2879         kfree(ctx->io_bl);
2880         xa_destroy(&ctx->io_bl_xa);
2881         kfree(ctx);
2882 }
2883
2884 static __cold void io_activate_pollwq_cb(struct callback_head *cb)
2885 {
2886         struct io_ring_ctx *ctx = container_of(cb, struct io_ring_ctx,
2887                                                poll_wq_task_work);
2888
2889         mutex_lock(&ctx->uring_lock);
2890         ctx->poll_activated = true;
2891         mutex_unlock(&ctx->uring_lock);
2892
2893         /*
2894          * Wake ups for some events between start of polling and activation
2895          * might've been lost due to loose synchronisation.
2896          */
2897         wake_up_all(&ctx->poll_wq);
2898         percpu_ref_put(&ctx->refs);
2899 }
2900
2901 static __cold void io_activate_pollwq(struct io_ring_ctx *ctx)
2902 {
2903         spin_lock(&ctx->completion_lock);
2904         /* already activated or in progress */
2905         if (ctx->poll_activated || ctx->poll_wq_task_work.func)
2906                 goto out;
2907         if (WARN_ON_ONCE(!ctx->task_complete))
2908                 goto out;
2909         if (!ctx->submitter_task)
2910                 goto out;
2911         /*
2912          * with ->submitter_task only the submitter task completes requests, we
2913          * only need to sync with it, which is done by injecting a tw
2914          */
2915         init_task_work(&ctx->poll_wq_task_work, io_activate_pollwq_cb);
2916         percpu_ref_get(&ctx->refs);
2917         if (task_work_add(ctx->submitter_task, &ctx->poll_wq_task_work, TWA_SIGNAL))
2918                 percpu_ref_put(&ctx->refs);
2919 out:
2920         spin_unlock(&ctx->completion_lock);
2921 }
2922
2923 static __poll_t io_uring_poll(struct file *file, poll_table *wait)
2924 {
2925         struct io_ring_ctx *ctx = file->private_data;
2926         __poll_t mask = 0;
2927
2928         if (unlikely(!ctx->poll_activated))
2929                 io_activate_pollwq(ctx);
2930
2931         poll_wait(file, &ctx->poll_wq, wait);
2932         /*
2933          * synchronizes with barrier from wq_has_sleeper call in
2934          * io_commit_cqring
2935          */
2936         smp_rmb();
2937         if (!io_sqring_full(ctx))
2938                 mask |= EPOLLOUT | EPOLLWRNORM;
2939
2940         /*
2941          * Don't flush cqring overflow list here, just do a simple check.
2942          * Otherwise there could possible be ABBA deadlock:
2943          *      CPU0                    CPU1
2944          *      ----                    ----
2945          * lock(&ctx->uring_lock);
2946          *                              lock(&ep->mtx);
2947          *                              lock(&ctx->uring_lock);
2948          * lock(&ep->mtx);
2949          *
2950          * Users may get EPOLLIN meanwhile seeing nothing in cqring, this
2951          * pushes them to do the flush.
2952          */
2953
2954         if (__io_cqring_events_user(ctx) || io_has_work(ctx))
2955                 mask |= EPOLLIN | EPOLLRDNORM;
2956
2957         return mask;
2958 }
2959
2960 static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id)
2961 {
2962         const struct cred *creds;
2963
2964         creds = xa_erase(&ctx->personalities, id);
2965         if (creds) {
2966                 put_cred(creds);
2967                 return 0;
2968         }
2969
2970         return -EINVAL;
2971 }
2972
2973 struct io_tctx_exit {
2974         struct callback_head            task_work;
2975         struct completion               completion;
2976         struct io_ring_ctx              *ctx;
2977 };
2978
2979 static __cold void io_tctx_exit_cb(struct callback_head *cb)
2980 {
2981         struct io_uring_task *tctx = current->io_uring;
2982         struct io_tctx_exit *work;
2983
2984         work = container_of(cb, struct io_tctx_exit, task_work);
2985         /*
2986          * When @in_cancel, we're in cancellation and it's racy to remove the
2987          * node. It'll be removed by the end of cancellation, just ignore it.
2988          * tctx can be NULL if the queueing of this task_work raced with
2989          * work cancelation off the exec path.
2990          */
2991         if (tctx && !atomic_read(&tctx->in_cancel))
2992                 io_uring_del_tctx_node((unsigned long)work->ctx);
2993         complete(&work->completion);
2994 }
2995
2996 static __cold bool io_cancel_ctx_cb(struct io_wq_work *work, void *data)
2997 {
2998         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
2999
3000         return req->ctx == data;
3001 }
3002
3003 static __cold void io_ring_exit_work(struct work_struct *work)
3004 {
3005         struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx, exit_work);
3006         unsigned long timeout = jiffies + HZ * 60 * 5;
3007         unsigned long interval = HZ / 20;
3008         struct io_tctx_exit exit;
3009         struct io_tctx_node *node;
3010         int ret;
3011
3012         /*
3013          * If we're doing polled IO and end up having requests being
3014          * submitted async (out-of-line), then completions can come in while
3015          * we're waiting for refs to drop. We need to reap these manually,
3016          * as nobody else will be looking for them.
3017          */
3018         do {
3019                 if (test_bit(IO_CHECK_CQ_OVERFLOW_BIT, &ctx->check_cq)) {
3020                         mutex_lock(&ctx->uring_lock);
3021                         io_cqring_overflow_kill(ctx);
3022                         mutex_unlock(&ctx->uring_lock);
3023                 }
3024
3025                 if (ctx->flags & IORING_SETUP_DEFER_TASKRUN)
3026                         io_move_task_work_from_local(ctx);
3027
3028                 while (io_uring_try_cancel_requests(ctx, NULL, true))
3029                         cond_resched();
3030
3031                 if (ctx->sq_data) {
3032                         struct io_sq_data *sqd = ctx->sq_data;
3033                         struct task_struct *tsk;
3034
3035                         io_sq_thread_park(sqd);
3036                         tsk = sqd->thread;
3037                         if (tsk && tsk->io_uring && tsk->io_uring->io_wq)
3038                                 io_wq_cancel_cb(tsk->io_uring->io_wq,
3039                                                 io_cancel_ctx_cb, ctx, true);
3040                         io_sq_thread_unpark(sqd);
3041                 }
3042
3043                 io_req_caches_free(ctx);
3044
3045                 if (WARN_ON_ONCE(time_after(jiffies, timeout))) {
3046                         /* there is little hope left, don't run it too often */
3047                         interval = HZ * 60;
3048                 }
3049                 /*
3050                  * This is really an uninterruptible wait, as it has to be
3051                  * complete. But it's also run from a kworker, which doesn't
3052                  * take signals, so it's fine to make it interruptible. This
3053                  * avoids scenarios where we knowingly can wait much longer
3054                  * on completions, for example if someone does a SIGSTOP on
3055                  * a task that needs to finish task_work to make this loop
3056                  * complete. That's a synthetic situation that should not
3057                  * cause a stuck task backtrace, and hence a potential panic
3058                  * on stuck tasks if that is enabled.
3059                  */
3060         } while (!wait_for_completion_interruptible_timeout(&ctx->ref_comp, interval));
3061
3062         init_completion(&exit.completion);
3063         init_task_work(&exit.task_work, io_tctx_exit_cb);
3064         exit.ctx = ctx;
3065         /*
3066          * Some may use context even when all refs and requests have been put,
3067          * and they are free to do so while still holding uring_lock or
3068          * completion_lock, see io_req_task_submit(). Apart from other work,
3069          * this lock/unlock section also waits them to finish.
3070          */
3071         mutex_lock(&ctx->uring_lock);
3072         while (!list_empty(&ctx->tctx_list)) {
3073                 WARN_ON_ONCE(time_after(jiffies, timeout));
3074
3075                 node = list_first_entry(&ctx->tctx_list, struct io_tctx_node,
3076                                         ctx_node);
3077                 /* don't spin on a single task if cancellation failed */
3078                 list_rotate_left(&ctx->tctx_list);
3079                 ret = task_work_add(node->task, &exit.task_work, TWA_SIGNAL);
3080                 if (WARN_ON_ONCE(ret))
3081                         continue;
3082
3083                 mutex_unlock(&ctx->uring_lock);
3084                 /*
3085                  * See comment above for
3086                  * wait_for_completion_interruptible_timeout() on why this
3087                  * wait is marked as interruptible.
3088                  */
3089                 wait_for_completion_interruptible(&exit.completion);
3090                 mutex_lock(&ctx->uring_lock);
3091         }
3092         mutex_unlock(&ctx->uring_lock);
3093         spin_lock(&ctx->completion_lock);
3094         spin_unlock(&ctx->completion_lock);
3095
3096         /* pairs with RCU read section in io_req_local_work_add() */
3097         if (ctx->flags & IORING_SETUP_DEFER_TASKRUN)
3098                 synchronize_rcu();
3099
3100         io_ring_ctx_free(ctx);
3101 }
3102
3103 static __cold void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
3104 {
3105         unsigned long index;
3106         struct creds *creds;
3107
3108         mutex_lock(&ctx->uring_lock);
3109         percpu_ref_kill(&ctx->refs);
3110         xa_for_each(&ctx->personalities, index, creds)
3111                 io_unregister_personality(ctx, index);
3112         if (ctx->rings)
3113                 io_poll_remove_all(ctx, NULL, true);
3114         mutex_unlock(&ctx->uring_lock);
3115
3116         /*
3117          * If we failed setting up the ctx, we might not have any rings
3118          * and therefore did not submit any requests
3119          */
3120         if (ctx->rings)
3121                 io_kill_timeouts(ctx, NULL, true);
3122
3123         flush_delayed_work(&ctx->fallback_work);
3124
3125         INIT_WORK(&ctx->exit_work, io_ring_exit_work);
3126         /*
3127          * Use system_unbound_wq to avoid spawning tons of event kworkers
3128          * if we're exiting a ton of rings at the same time. It just adds
3129          * noise and overhead, there's no discernable change in runtime
3130          * over using system_wq.
3131          */
3132         queue_work(system_unbound_wq, &ctx->exit_work);
3133 }
3134
3135 static int io_uring_release(struct inode *inode, struct file *file)
3136 {
3137         struct io_ring_ctx *ctx = file->private_data;
3138
3139         file->private_data = NULL;
3140         io_ring_ctx_wait_and_kill(ctx);
3141         return 0;
3142 }
3143
3144 struct io_task_cancel {
3145         struct task_struct *task;
3146         bool all;
3147 };
3148
3149 static bool io_cancel_task_cb(struct io_wq_work *work, void *data)
3150 {
3151         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
3152         struct io_task_cancel *cancel = data;
3153
3154         return io_match_task_safe(req, cancel->task, cancel->all);
3155 }
3156
3157 static __cold bool io_cancel_defer_files(struct io_ring_ctx *ctx,
3158                                          struct task_struct *task,
3159                                          bool cancel_all)
3160 {
3161         struct io_defer_entry *de;
3162         LIST_HEAD(list);
3163
3164         spin_lock(&ctx->completion_lock);
3165         list_for_each_entry_reverse(de, &ctx->defer_list, list) {
3166                 if (io_match_task_safe(de->req, task, cancel_all)) {
3167                         list_cut_position(&list, &ctx->defer_list, &de->list);
3168                         break;
3169                 }
3170         }
3171         spin_unlock(&ctx->completion_lock);
3172         if (list_empty(&list))
3173                 return false;
3174
3175         while (!list_empty(&list)) {
3176                 de = list_first_entry(&list, struct io_defer_entry, list);
3177                 list_del_init(&de->list);
3178                 io_req_task_queue_fail(de->req, -ECANCELED);
3179                 kfree(de);
3180         }
3181         return true;
3182 }
3183
3184 static __cold bool io_uring_try_cancel_iowq(struct io_ring_ctx *ctx)
3185 {
3186         struct io_tctx_node *node;
3187         enum io_wq_cancel cret;
3188         bool ret = false;
3189
3190         mutex_lock(&ctx->uring_lock);
3191         list_for_each_entry(node, &ctx->tctx_list, ctx_node) {
3192                 struct io_uring_task *tctx = node->task->io_uring;
3193
3194                 /*
3195                  * io_wq will stay alive while we hold uring_lock, because it's
3196                  * killed after ctx nodes, which requires to take the lock.
3197                  */
3198                 if (!tctx || !tctx->io_wq)
3199                         continue;
3200                 cret = io_wq_cancel_cb(tctx->io_wq, io_cancel_ctx_cb, ctx, true);
3201                 ret |= (cret != IO_WQ_CANCEL_NOTFOUND);
3202         }
3203         mutex_unlock(&ctx->uring_lock);
3204
3205         return ret;
3206 }
3207
3208 static __cold bool io_uring_try_cancel_requests(struct io_ring_ctx *ctx,
3209                                                 struct task_struct *task,
3210                                                 bool cancel_all)
3211 {
3212         struct io_task_cancel cancel = { .task = task, .all = cancel_all, };
3213         struct io_uring_task *tctx = task ? task->io_uring : NULL;
3214         enum io_wq_cancel cret;
3215         bool ret = false;
3216
3217         /* set it so io_req_local_work_add() would wake us up */
3218         if (ctx->flags & IORING_SETUP_DEFER_TASKRUN) {
3219                 atomic_set(&ctx->cq_wait_nr, 1);
3220                 smp_mb();
3221         }
3222
3223         /* failed during ring init, it couldn't have issued any requests */
3224         if (!ctx->rings)
3225                 return false;
3226
3227         if (!task) {
3228                 ret |= io_uring_try_cancel_iowq(ctx);
3229         } else if (tctx && tctx->io_wq) {
3230                 /*
3231                  * Cancels requests of all rings, not only @ctx, but
3232                  * it's fine as the task is in exit/exec.
3233                  */
3234                 cret = io_wq_cancel_cb(tctx->io_wq, io_cancel_task_cb,
3235                                        &cancel, true);
3236                 ret |= (cret != IO_WQ_CANCEL_NOTFOUND);
3237         }
3238
3239         /* SQPOLL thread does its own polling */
3240         if ((!(ctx->flags & IORING_SETUP_SQPOLL) && cancel_all) ||
3241             (ctx->sq_data && ctx->sq_data->thread == current)) {
3242                 while (!wq_list_empty(&ctx->iopoll_list)) {
3243                         io_iopoll_try_reap_events(ctx);
3244                         ret = true;
3245                         cond_resched();
3246                 }
3247         }
3248
3249         if ((ctx->flags & IORING_SETUP_DEFER_TASKRUN) &&
3250             io_allowed_defer_tw_run(ctx))
3251                 ret |= io_run_local_work(ctx) > 0;
3252         ret |= io_cancel_defer_files(ctx, task, cancel_all);
3253         mutex_lock(&ctx->uring_lock);
3254         ret |= io_poll_remove_all(ctx, task, cancel_all);
3255         mutex_unlock(&ctx->uring_lock);
3256         ret |= io_kill_timeouts(ctx, task, cancel_all);
3257         if (task)
3258                 ret |= io_run_task_work() > 0;
3259         return ret;
3260 }
3261
3262 static s64 tctx_inflight(struct io_uring_task *tctx, bool tracked)
3263 {
3264         if (tracked)
3265                 return atomic_read(&tctx->inflight_tracked);
3266         return percpu_counter_sum(&tctx->inflight);
3267 }
3268
3269 /*
3270  * Find any io_uring ctx that this task has registered or done IO on, and cancel
3271  * requests. @sqd should be not-null IFF it's an SQPOLL thread cancellation.
3272  */
3273 __cold void io_uring_cancel_generic(bool cancel_all, struct io_sq_data *sqd)
3274 {
3275         struct io_uring_task *tctx = current->io_uring;
3276         struct io_ring_ctx *ctx;
3277         struct io_tctx_node *node;
3278         unsigned long index;
3279         s64 inflight;
3280         DEFINE_WAIT(wait);
3281
3282         WARN_ON_ONCE(sqd && sqd->thread != current);
3283
3284         if (!current->io_uring)
3285                 return;
3286         if (tctx->io_wq)
3287                 io_wq_exit_start(tctx->io_wq);
3288
3289         atomic_inc(&tctx->in_cancel);
3290         do {
3291                 bool loop = false;
3292
3293                 io_uring_drop_tctx_refs(current);
3294                 /* read completions before cancelations */
3295                 inflight = tctx_inflight(tctx, !cancel_all);
3296                 if (!inflight)
3297                         break;
3298
3299                 if (!sqd) {
3300                         xa_for_each(&tctx->xa, index, node) {
3301                                 /* sqpoll task will cancel all its requests */
3302                                 if (node->ctx->sq_data)
3303                                         continue;
3304                                 loop |= io_uring_try_cancel_requests(node->ctx,
3305                                                         current, cancel_all);
3306                         }
3307                 } else {
3308                         list_for_each_entry(ctx, &sqd->ctx_list, sqd_list)
3309                                 loop |= io_uring_try_cancel_requests(ctx,
3310                                                                      current,
3311                                                                      cancel_all);
3312                 }
3313
3314                 if (loop) {
3315                         cond_resched();
3316                         continue;
3317                 }
3318
3319                 prepare_to_wait(&tctx->wait, &wait, TASK_INTERRUPTIBLE);
3320                 io_run_task_work();
3321                 io_uring_drop_tctx_refs(current);
3322                 xa_for_each(&tctx->xa, index, node) {
3323                         if (!llist_empty(&node->ctx->work_llist)) {
3324                                 WARN_ON_ONCE(node->ctx->submitter_task &&
3325                                              node->ctx->submitter_task != current);
3326                                 goto end_wait;
3327                         }
3328                 }
3329                 /*
3330                  * If we've seen completions, retry without waiting. This
3331                  * avoids a race where a completion comes in before we did
3332                  * prepare_to_wait().
3333                  */
3334                 if (inflight == tctx_inflight(tctx, !cancel_all))
3335                         schedule();
3336 end_wait:
3337                 finish_wait(&tctx->wait, &wait);
3338         } while (1);
3339
3340         io_uring_clean_tctx(tctx);
3341         if (cancel_all) {
3342                 /*
3343                  * We shouldn't run task_works after cancel, so just leave
3344                  * ->in_cancel set for normal exit.
3345                  */
3346                 atomic_dec(&tctx->in_cancel);
3347                 /* for exec all current's requests should be gone, kill tctx */
3348                 __io_uring_free(current);
3349         }
3350 }
3351
3352 void __io_uring_cancel(bool cancel_all)
3353 {
3354         io_uring_cancel_generic(cancel_all, NULL);
3355 }
3356
3357 static void *io_uring_validate_mmap_request(struct file *file,
3358                                             loff_t pgoff, size_t sz)
3359 {
3360         struct io_ring_ctx *ctx = file->private_data;
3361         loff_t offset = pgoff << PAGE_SHIFT;
3362         struct page *page;
3363         void *ptr;
3364
3365         /* Don't allow mmap if the ring was setup without it */
3366         if (ctx->flags & IORING_SETUP_NO_MMAP)
3367                 return ERR_PTR(-EINVAL);
3368
3369         switch (offset & IORING_OFF_MMAP_MASK) {
3370         case IORING_OFF_SQ_RING:
3371         case IORING_OFF_CQ_RING:
3372                 ptr = ctx->rings;
3373                 break;
3374         case IORING_OFF_SQES:
3375                 ptr = ctx->sq_sqes;
3376                 break;
3377         case IORING_OFF_PBUF_RING: {
3378                 unsigned int bgid;
3379
3380                 bgid = (offset & ~IORING_OFF_MMAP_MASK) >> IORING_OFF_PBUF_SHIFT;
3381                 mutex_lock(&ctx->uring_lock);
3382                 ptr = io_pbuf_get_address(ctx, bgid);
3383                 mutex_unlock(&ctx->uring_lock);
3384                 if (!ptr)
3385                         return ERR_PTR(-EINVAL);
3386                 break;
3387                 }
3388         default:
3389                 return ERR_PTR(-EINVAL);
3390         }
3391
3392         page = virt_to_head_page(ptr);
3393         if (sz > page_size(page))
3394                 return ERR_PTR(-EINVAL);
3395
3396         return ptr;
3397 }
3398
3399 #ifdef CONFIG_MMU
3400
3401 static __cold int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
3402 {
3403         size_t sz = vma->vm_end - vma->vm_start;
3404         unsigned long pfn;
3405         void *ptr;
3406
3407         ptr = io_uring_validate_mmap_request(file, vma->vm_pgoff, sz);
3408         if (IS_ERR(ptr))
3409                 return PTR_ERR(ptr);
3410
3411         pfn = virt_to_phys(ptr) >> PAGE_SHIFT;
3412         return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
3413 }
3414
3415 static unsigned long io_uring_mmu_get_unmapped_area(struct file *filp,
3416                         unsigned long addr, unsigned long len,
3417                         unsigned long pgoff, unsigned long flags)
3418 {
3419         const unsigned long mmap_end = arch_get_mmap_end(addr, len, flags);
3420         struct vm_unmapped_area_info info;
3421         void *ptr;
3422
3423         /*
3424          * Do not allow to map to user-provided address to avoid breaking the
3425          * aliasing rules. Userspace is not able to guess the offset address of
3426          * kernel kmalloc()ed memory area.
3427          */
3428         if (addr)
3429                 return -EINVAL;
3430
3431         ptr = io_uring_validate_mmap_request(filp, pgoff, len);
3432         if (IS_ERR(ptr))
3433                 return -ENOMEM;
3434
3435         info.flags = VM_UNMAPPED_AREA_TOPDOWN;
3436         info.length = len;
3437         info.low_limit = max(PAGE_SIZE, mmap_min_addr);
3438         info.high_limit = arch_get_mmap_base(addr, current->mm->mmap_base);
3439 #ifdef SHM_COLOUR
3440         info.align_mask = PAGE_MASK & (SHM_COLOUR - 1UL);
3441 #else
3442         info.align_mask = PAGE_MASK & (SHMLBA - 1UL);
3443 #endif
3444         info.align_offset = (unsigned long) ptr;
3445
3446         /*
3447          * A failed mmap() very likely causes application failure,
3448          * so fall back to the bottom-up function here. This scenario
3449          * can happen with large stack limits and large mmap()
3450          * allocations.
3451          */
3452         addr = vm_unmapped_area(&info);
3453         if (offset_in_page(addr)) {
3454                 info.flags = 0;
3455                 info.low_limit = TASK_UNMAPPED_BASE;
3456                 info.high_limit = mmap_end;
3457                 addr = vm_unmapped_area(&info);
3458         }
3459
3460         return addr;
3461 }
3462
3463 #else /* !CONFIG_MMU */
3464
3465 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
3466 {
3467         return is_nommu_shared_mapping(vma->vm_flags) ? 0 : -EINVAL;
3468 }
3469
3470 static unsigned int io_uring_nommu_mmap_capabilities(struct file *file)
3471 {
3472         return NOMMU_MAP_DIRECT | NOMMU_MAP_READ | NOMMU_MAP_WRITE;
3473 }
3474
3475 static unsigned long io_uring_nommu_get_unmapped_area(struct file *file,
3476         unsigned long addr, unsigned long len,
3477         unsigned long pgoff, unsigned long flags)
3478 {
3479         void *ptr;
3480
3481         ptr = io_uring_validate_mmap_request(file, pgoff, len);
3482         if (IS_ERR(ptr))
3483                 return PTR_ERR(ptr);
3484
3485         return (unsigned long) ptr;
3486 }
3487
3488 #endif /* !CONFIG_MMU */
3489
3490 static int io_validate_ext_arg(unsigned flags, const void __user *argp, size_t argsz)
3491 {
3492         if (flags & IORING_ENTER_EXT_ARG) {
3493                 struct io_uring_getevents_arg arg;
3494
3495                 if (argsz != sizeof(arg))
3496                         return -EINVAL;
3497                 if (copy_from_user(&arg, argp, sizeof(arg)))
3498                         return -EFAULT;
3499         }
3500         return 0;
3501 }
3502
3503 static int io_get_ext_arg(unsigned flags, const void __user *argp, size_t *argsz,
3504                           struct __kernel_timespec __user **ts,
3505                           const sigset_t __user **sig)
3506 {
3507         struct io_uring_getevents_arg arg;
3508
3509         /*
3510          * If EXT_ARG isn't set, then we have no timespec and the argp pointer
3511          * is just a pointer to the sigset_t.
3512          */
3513         if (!(flags & IORING_ENTER_EXT_ARG)) {
3514                 *sig = (const sigset_t __user *) argp;
3515                 *ts = NULL;
3516                 return 0;
3517         }
3518
3519         /*
3520          * EXT_ARG is set - ensure we agree on the size of it and copy in our
3521          * timespec and sigset_t pointers if good.
3522          */
3523         if (*argsz != sizeof(arg))
3524                 return -EINVAL;
3525         if (copy_from_user(&arg, argp, sizeof(arg)))
3526                 return -EFAULT;
3527         if (arg.pad)
3528                 return -EINVAL;
3529         *sig = u64_to_user_ptr(arg.sigmask);
3530         *argsz = arg.sigmask_sz;
3531         *ts = u64_to_user_ptr(arg.ts);
3532         return 0;
3533 }
3534
3535 SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
3536                 u32, min_complete, u32, flags, const void __user *, argp,
3537                 size_t, argsz)
3538 {
3539         struct io_ring_ctx *ctx;
3540         struct fd f;
3541         long ret;
3542
3543         if (unlikely(flags & ~(IORING_ENTER_GETEVENTS | IORING_ENTER_SQ_WAKEUP |
3544                                IORING_ENTER_SQ_WAIT | IORING_ENTER_EXT_ARG |
3545                                IORING_ENTER_REGISTERED_RING)))
3546                 return -EINVAL;
3547
3548         /*
3549          * Ring fd has been registered via IORING_REGISTER_RING_FDS, we
3550          * need only dereference our task private array to find it.
3551          */
3552         if (flags & IORING_ENTER_REGISTERED_RING) {
3553                 struct io_uring_task *tctx = current->io_uring;
3554
3555                 if (unlikely(!tctx || fd >= IO_RINGFD_REG_MAX))
3556                         return -EINVAL;
3557                 fd = array_index_nospec(fd, IO_RINGFD_REG_MAX);
3558                 f.file = tctx->registered_rings[fd];
3559                 f.flags = 0;
3560                 if (unlikely(!f.file))
3561                         return -EBADF;
3562         } else {
3563                 f = fdget(fd);
3564                 if (unlikely(!f.file))
3565                         return -EBADF;
3566                 ret = -EOPNOTSUPP;
3567                 if (unlikely(!io_is_uring_fops(f.file)))
3568                         goto out;
3569         }
3570
3571         ctx = f.file->private_data;
3572         ret = -EBADFD;
3573         if (unlikely(ctx->flags & IORING_SETUP_R_DISABLED))
3574                 goto out;
3575
3576         /*
3577          * For SQ polling, the thread will do all submissions and completions.
3578          * Just return the requested submit count, and wake the thread if
3579          * we were asked to.
3580          */
3581         ret = 0;
3582         if (ctx->flags & IORING_SETUP_SQPOLL) {
3583                 io_cqring_overflow_flush(ctx);
3584
3585                 if (unlikely(ctx->sq_data->thread == NULL)) {
3586                         ret = -EOWNERDEAD;
3587                         goto out;
3588                 }
3589                 if (flags & IORING_ENTER_SQ_WAKEUP)
3590                         wake_up(&ctx->sq_data->wait);
3591                 if (flags & IORING_ENTER_SQ_WAIT)
3592                         io_sqpoll_wait_sq(ctx);
3593
3594                 ret = to_submit;
3595         } else if (to_submit) {
3596                 ret = io_uring_add_tctx_node(ctx);
3597                 if (unlikely(ret))
3598                         goto out;
3599
3600                 mutex_lock(&ctx->uring_lock);
3601                 ret = io_submit_sqes(ctx, to_submit);
3602                 if (ret != to_submit) {
3603                         mutex_unlock(&ctx->uring_lock);
3604                         goto out;
3605                 }
3606                 if (flags & IORING_ENTER_GETEVENTS) {
3607                         if (ctx->syscall_iopoll)
3608                                 goto iopoll_locked;
3609                         /*
3610                          * Ignore errors, we'll soon call io_cqring_wait() and
3611                          * it should handle ownership problems if any.
3612                          */
3613                         if (ctx->flags & IORING_SETUP_DEFER_TASKRUN)
3614                                 (void)io_run_local_work_locked(ctx);
3615                 }
3616                 mutex_unlock(&ctx->uring_lock);
3617         }
3618
3619         if (flags & IORING_ENTER_GETEVENTS) {
3620                 int ret2;
3621
3622                 if (ctx->syscall_iopoll) {
3623                         /*
3624                          * We disallow the app entering submit/complete with
3625                          * polling, but we still need to lock the ring to
3626                          * prevent racing with polled issue that got punted to
3627                          * a workqueue.
3628                          */
3629                         mutex_lock(&ctx->uring_lock);
3630 iopoll_locked:
3631                         ret2 = io_validate_ext_arg(flags, argp, argsz);
3632                         if (likely(!ret2)) {
3633                                 min_complete = min(min_complete,
3634                                                    ctx->cq_entries);
3635                                 ret2 = io_iopoll_check(ctx, min_complete);
3636                         }
3637                         mutex_unlock(&ctx->uring_lock);
3638                 } else {
3639                         const sigset_t __user *sig;
3640                         struct __kernel_timespec __user *ts;
3641
3642                         ret2 = io_get_ext_arg(flags, argp, &argsz, &ts, &sig);
3643                         if (likely(!ret2)) {
3644                                 min_complete = min(min_complete,
3645                                                    ctx->cq_entries);
3646                                 ret2 = io_cqring_wait(ctx, min_complete, sig,
3647                                                       argsz, ts);
3648                         }
3649                 }
3650
3651                 if (!ret) {
3652                         ret = ret2;
3653
3654                         /*
3655                          * EBADR indicates that one or more CQE were dropped.
3656                          * Once the user has been informed we can clear the bit
3657                          * as they are obviously ok with those drops.
3658                          */
3659                         if (unlikely(ret2 == -EBADR))
3660                                 clear_bit(IO_CHECK_CQ_DROPPED_BIT,
3661                                           &ctx->check_cq);
3662                 }
3663         }
3664 out:
3665         fdput(f);
3666         return ret;
3667 }
3668
3669 static const struct file_operations io_uring_fops = {
3670         .release        = io_uring_release,
3671         .mmap           = io_uring_mmap,
3672 #ifndef CONFIG_MMU
3673         .get_unmapped_area = io_uring_nommu_get_unmapped_area,
3674         .mmap_capabilities = io_uring_nommu_mmap_capabilities,
3675 #else
3676         .get_unmapped_area = io_uring_mmu_get_unmapped_area,
3677 #endif
3678         .poll           = io_uring_poll,
3679 #ifdef CONFIG_PROC_FS
3680         .show_fdinfo    = io_uring_show_fdinfo,
3681 #endif
3682 };
3683
3684 bool io_is_uring_fops(struct file *file)
3685 {
3686         return file->f_op == &io_uring_fops;
3687 }
3688
3689 static __cold int io_allocate_scq_urings(struct io_ring_ctx *ctx,
3690                                          struct io_uring_params *p)
3691 {
3692         struct io_rings *rings;
3693         size_t size, sq_array_offset;
3694         void *ptr;
3695
3696         /* make sure these are sane, as we already accounted them */
3697         ctx->sq_entries = p->sq_entries;
3698         ctx->cq_entries = p->cq_entries;
3699
3700         size = rings_size(ctx, p->sq_entries, p->cq_entries, &sq_array_offset);
3701         if (size == SIZE_MAX)
3702                 return -EOVERFLOW;
3703
3704         if (!(ctx->flags & IORING_SETUP_NO_MMAP))
3705                 rings = io_mem_alloc(size);
3706         else
3707                 rings = io_rings_map(ctx, p->cq_off.user_addr, size);
3708
3709         if (IS_ERR(rings))
3710                 return PTR_ERR(rings);
3711
3712         ctx->rings = rings;
3713         ctx->sq_array = (u32 *)((char *)rings + sq_array_offset);
3714         rings->sq_ring_mask = p->sq_entries - 1;
3715         rings->cq_ring_mask = p->cq_entries - 1;
3716         rings->sq_ring_entries = p->sq_entries;
3717         rings->cq_ring_entries = p->cq_entries;
3718
3719         if (p->flags & IORING_SETUP_SQE128)
3720                 size = array_size(2 * sizeof(struct io_uring_sqe), p->sq_entries);
3721         else
3722                 size = array_size(sizeof(struct io_uring_sqe), p->sq_entries);
3723         if (size == SIZE_MAX) {
3724                 io_rings_free(ctx);
3725                 return -EOVERFLOW;
3726         }
3727
3728         if (!(ctx->flags & IORING_SETUP_NO_MMAP))
3729                 ptr = io_mem_alloc(size);
3730         else
3731                 ptr = io_sqes_map(ctx, p->sq_off.user_addr, size);
3732
3733         if (IS_ERR(ptr)) {
3734                 io_rings_free(ctx);
3735                 return PTR_ERR(ptr);
3736         }
3737
3738         ctx->sq_sqes = ptr;
3739         return 0;
3740 }
3741
3742 static int io_uring_install_fd(struct file *file)
3743 {
3744         int fd;
3745
3746         fd = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
3747         if (fd < 0)
3748                 return fd;
3749         fd_install(fd, file);
3750         return fd;
3751 }
3752
3753 /*
3754  * Allocate an anonymous fd, this is what constitutes the application
3755  * visible backing of an io_uring instance. The application mmaps this
3756  * fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
3757  * we have to tie this fd to a socket for file garbage collection purposes.
3758  */
3759 static struct file *io_uring_get_file(struct io_ring_ctx *ctx)
3760 {
3761         struct file *file;
3762 #if defined(CONFIG_UNIX)
3763         int ret;
3764
3765         ret = sock_create_kern(&init_net, PF_UNIX, SOCK_RAW, IPPROTO_IP,
3766                                 &ctx->ring_sock);
3767         if (ret)
3768                 return ERR_PTR(ret);
3769 #endif
3770
3771         file = anon_inode_getfile_secure("[io_uring]", &io_uring_fops, ctx,
3772                                          O_RDWR | O_CLOEXEC, NULL);
3773 #if defined(CONFIG_UNIX)
3774         if (IS_ERR(file)) {
3775                 sock_release(ctx->ring_sock);
3776                 ctx->ring_sock = NULL;
3777         } else {
3778                 ctx->ring_sock->file = file;
3779         }
3780 #endif
3781         return file;
3782 }
3783
3784 static __cold int io_uring_create(unsigned entries, struct io_uring_params *p,
3785                                   struct io_uring_params __user *params)
3786 {
3787         struct io_ring_ctx *ctx;
3788         struct io_uring_task *tctx;
3789         struct file *file;
3790         int ret;
3791
3792         if (!entries)
3793                 return -EINVAL;
3794         if (entries > IORING_MAX_ENTRIES) {
3795                 if (!(p->flags & IORING_SETUP_CLAMP))
3796                         return -EINVAL;
3797                 entries = IORING_MAX_ENTRIES;
3798         }
3799
3800         if ((p->flags & IORING_SETUP_REGISTERED_FD_ONLY)
3801             && !(p->flags & IORING_SETUP_NO_MMAP))
3802                 return -EINVAL;
3803
3804         /*
3805          * Use twice as many entries for the CQ ring. It's possible for the
3806          * application to drive a higher depth than the size of the SQ ring,
3807          * since the sqes are only used at submission time. This allows for
3808          * some flexibility in overcommitting a bit. If the application has
3809          * set IORING_SETUP_CQSIZE, it will have passed in the desired number
3810          * of CQ ring entries manually.
3811          */
3812         p->sq_entries = roundup_pow_of_two(entries);
3813         if (p->flags & IORING_SETUP_CQSIZE) {
3814                 /*
3815                  * If IORING_SETUP_CQSIZE is set, we do the same roundup
3816                  * to a power-of-two, if it isn't already. We do NOT impose
3817                  * any cq vs sq ring sizing.
3818                  */
3819                 if (!p->cq_entries)
3820                         return -EINVAL;
3821                 if (p->cq_entries > IORING_MAX_CQ_ENTRIES) {
3822                         if (!(p->flags & IORING_SETUP_CLAMP))
3823                                 return -EINVAL;
3824                         p->cq_entries = IORING_MAX_CQ_ENTRIES;
3825                 }
3826                 p->cq_entries = roundup_pow_of_two(p->cq_entries);
3827                 if (p->cq_entries < p->sq_entries)
3828                         return -EINVAL;
3829         } else {
3830                 p->cq_entries = 2 * p->sq_entries;
3831         }
3832
3833         ctx = io_ring_ctx_alloc(p);
3834         if (!ctx)
3835                 return -ENOMEM;
3836
3837         if ((ctx->flags & IORING_SETUP_DEFER_TASKRUN) &&
3838             !(ctx->flags & IORING_SETUP_IOPOLL) &&
3839             !(ctx->flags & IORING_SETUP_SQPOLL))
3840                 ctx->task_complete = true;
3841
3842         if (ctx->task_complete || (ctx->flags & IORING_SETUP_IOPOLL))
3843                 ctx->lockless_cq = true;
3844
3845         /*
3846          * lazy poll_wq activation relies on ->task_complete for synchronisation
3847          * purposes, see io_activate_pollwq()
3848          */
3849         if (!ctx->task_complete)
3850                 ctx->poll_activated = true;
3851
3852         /*
3853          * When SETUP_IOPOLL and SETUP_SQPOLL are both enabled, user
3854          * space applications don't need to do io completion events
3855          * polling again, they can rely on io_sq_thread to do polling
3856          * work, which can reduce cpu usage and uring_lock contention.
3857          */
3858         if (ctx->flags & IORING_SETUP_IOPOLL &&
3859             !(ctx->flags & IORING_SETUP_SQPOLL))
3860                 ctx->syscall_iopoll = 1;
3861
3862         ctx->compat = in_compat_syscall();
3863         if (!capable(CAP_IPC_LOCK))
3864                 ctx->user = get_uid(current_user());
3865
3866         /*
3867          * For SQPOLL, we just need a wakeup, always. For !SQPOLL, if
3868          * COOP_TASKRUN is set, then IPIs are never needed by the app.
3869          */
3870         ret = -EINVAL;
3871         if (ctx->flags & IORING_SETUP_SQPOLL) {
3872                 /* IPI related flags don't make sense with SQPOLL */
3873                 if (ctx->flags & (IORING_SETUP_COOP_TASKRUN |
3874                                   IORING_SETUP_TASKRUN_FLAG |
3875                                   IORING_SETUP_DEFER_TASKRUN))
3876                         goto err;
3877                 ctx->notify_method = TWA_SIGNAL_NO_IPI;
3878         } else if (ctx->flags & IORING_SETUP_COOP_TASKRUN) {
3879                 ctx->notify_method = TWA_SIGNAL_NO_IPI;
3880         } else {
3881                 if (ctx->flags & IORING_SETUP_TASKRUN_FLAG &&
3882                     !(ctx->flags & IORING_SETUP_DEFER_TASKRUN))
3883                         goto err;
3884                 ctx->notify_method = TWA_SIGNAL;
3885         }
3886
3887         /*
3888          * For DEFER_TASKRUN we require the completion task to be the same as the
3889          * submission task. This implies that there is only one submitter, so enforce
3890          * that.
3891          */
3892         if (ctx->flags & IORING_SETUP_DEFER_TASKRUN &&
3893             !(ctx->flags & IORING_SETUP_SINGLE_ISSUER)) {
3894                 goto err;
3895         }
3896
3897         /*
3898          * This is just grabbed for accounting purposes. When a process exits,
3899          * the mm is exited and dropped before the files, hence we need to hang
3900          * on to this mm purely for the purposes of being able to unaccount
3901          * memory (locked/pinned vm). It's not used for anything else.
3902          */
3903         mmgrab(current->mm);
3904         ctx->mm_account = current->mm;
3905
3906         ret = io_allocate_scq_urings(ctx, p);
3907         if (ret)
3908                 goto err;
3909
3910         ret = io_sq_offload_create(ctx, p);
3911         if (ret)
3912                 goto err;
3913
3914         ret = io_rsrc_init(ctx);
3915         if (ret)
3916                 goto err;
3917
3918         p->sq_off.head = offsetof(struct io_rings, sq.head);
3919         p->sq_off.tail = offsetof(struct io_rings, sq.tail);
3920         p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask);
3921         p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries);
3922         p->sq_off.flags = offsetof(struct io_rings, sq_flags);
3923         p->sq_off.dropped = offsetof(struct io_rings, sq_dropped);
3924         p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings;
3925         p->sq_off.resv1 = 0;
3926         if (!(ctx->flags & IORING_SETUP_NO_MMAP))
3927                 p->sq_off.user_addr = 0;
3928
3929         p->cq_off.head = offsetof(struct io_rings, cq.head);
3930         p->cq_off.tail = offsetof(struct io_rings, cq.tail);
3931         p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask);
3932         p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries);
3933         p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
3934         p->cq_off.cqes = offsetof(struct io_rings, cqes);
3935         p->cq_off.flags = offsetof(struct io_rings, cq_flags);
3936         p->cq_off.resv1 = 0;
3937         if (!(ctx->flags & IORING_SETUP_NO_MMAP))
3938                 p->cq_off.user_addr = 0;
3939
3940         p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
3941                         IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
3942                         IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL |
3943                         IORING_FEAT_POLL_32BITS | IORING_FEAT_SQPOLL_NONFIXED |
3944                         IORING_FEAT_EXT_ARG | IORING_FEAT_NATIVE_WORKERS |
3945                         IORING_FEAT_RSRC_TAGS | IORING_FEAT_CQE_SKIP |
3946                         IORING_FEAT_LINKED_FILE | IORING_FEAT_REG_REG_RING;
3947
3948         if (copy_to_user(params, p, sizeof(*p))) {
3949                 ret = -EFAULT;
3950                 goto err;
3951         }
3952
3953         if (ctx->flags & IORING_SETUP_SINGLE_ISSUER
3954             && !(ctx->flags & IORING_SETUP_R_DISABLED))
3955                 WRITE_ONCE(ctx->submitter_task, get_task_struct(current));
3956
3957         file = io_uring_get_file(ctx);
3958         if (IS_ERR(file)) {
3959                 ret = PTR_ERR(file);
3960                 goto err;
3961         }
3962
3963         ret = __io_uring_add_tctx_node(ctx);
3964         if (ret)
3965                 goto err_fput;
3966         tctx = current->io_uring;
3967
3968         /*
3969          * Install ring fd as the very last thing, so we don't risk someone
3970          * having closed it before we finish setup
3971          */
3972         if (p->flags & IORING_SETUP_REGISTERED_FD_ONLY)
3973                 ret = io_ring_add_registered_file(tctx, file, 0, IO_RINGFD_REG_MAX);
3974         else
3975                 ret = io_uring_install_fd(file);
3976         if (ret < 0)
3977                 goto err_fput;
3978
3979         trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
3980         return ret;
3981 err:
3982         io_ring_ctx_wait_and_kill(ctx);
3983         return ret;
3984 err_fput:
3985         fput(file);
3986         return ret;
3987 }
3988
3989 /*
3990  * Sets up an aio uring context, and returns the fd. Applications asks for a
3991  * ring size, we return the actual sq/cq ring sizes (among other things) in the
3992  * params structure passed in.
3993  */
3994 static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
3995 {
3996         struct io_uring_params p;
3997         int i;
3998
3999         if (copy_from_user(&p, params, sizeof(p)))
4000                 return -EFAULT;
4001         for (i = 0; i < ARRAY_SIZE(p.resv); i++) {
4002                 if (p.resv[i])
4003                         return -EINVAL;
4004         }
4005
4006         if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
4007                         IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE |
4008                         IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ |
4009                         IORING_SETUP_R_DISABLED | IORING_SETUP_SUBMIT_ALL |
4010                         IORING_SETUP_COOP_TASKRUN | IORING_SETUP_TASKRUN_FLAG |
4011                         IORING_SETUP_SQE128 | IORING_SETUP_CQE32 |
4012                         IORING_SETUP_SINGLE_ISSUER | IORING_SETUP_DEFER_TASKRUN |
4013                         IORING_SETUP_NO_MMAP | IORING_SETUP_REGISTERED_FD_ONLY))
4014                 return -EINVAL;
4015
4016         return io_uring_create(entries, &p, params);
4017 }
4018
4019 SYSCALL_DEFINE2(io_uring_setup, u32, entries,
4020                 struct io_uring_params __user *, params)
4021 {
4022         return io_uring_setup(entries, params);
4023 }
4024
4025 static __cold int io_probe(struct io_ring_ctx *ctx, void __user *arg,
4026                            unsigned nr_args)
4027 {
4028         struct io_uring_probe *p;
4029         size_t size;
4030         int i, ret;
4031
4032         size = struct_size(p, ops, nr_args);
4033         if (size == SIZE_MAX)
4034                 return -EOVERFLOW;
4035         p = kzalloc(size, GFP_KERNEL);
4036         if (!p)
4037                 return -ENOMEM;
4038
4039         ret = -EFAULT;
4040         if (copy_from_user(p, arg, size))
4041                 goto out;
4042         ret = -EINVAL;
4043         if (memchr_inv(p, 0, size))
4044                 goto out;
4045
4046         p->last_op = IORING_OP_LAST - 1;
4047         if (nr_args > IORING_OP_LAST)
4048                 nr_args = IORING_OP_LAST;
4049
4050         for (i = 0; i < nr_args; i++) {
4051                 p->ops[i].op = i;
4052                 if (!io_issue_defs[i].not_supported)
4053                         p->ops[i].flags = IO_URING_OP_SUPPORTED;
4054         }
4055         p->ops_len = i;
4056
4057         ret = 0;
4058         if (copy_to_user(arg, p, size))
4059                 ret = -EFAULT;
4060 out:
4061         kfree(p);
4062         return ret;
4063 }
4064
4065 static int io_register_personality(struct io_ring_ctx *ctx)
4066 {
4067         const struct cred *creds;
4068         u32 id;
4069         int ret;
4070
4071         creds = get_current_cred();
4072
4073         ret = xa_alloc_cyclic(&ctx->personalities, &id, (void *)creds,
4074                         XA_LIMIT(0, USHRT_MAX), &ctx->pers_next, GFP_KERNEL);
4075         if (ret < 0) {
4076                 put_cred(creds);
4077                 return ret;
4078         }
4079         return id;
4080 }
4081
4082 static __cold int io_register_restrictions(struct io_ring_ctx *ctx,
4083                                            void __user *arg, unsigned int nr_args)
4084 {
4085         struct io_uring_restriction *res;
4086         size_t size;
4087         int i, ret;
4088
4089         /* Restrictions allowed only if rings started disabled */
4090         if (!(ctx->flags & IORING_SETUP_R_DISABLED))
4091                 return -EBADFD;
4092
4093         /* We allow only a single restrictions registration */
4094         if (ctx->restrictions.registered)
4095                 return -EBUSY;
4096
4097         if (!arg || nr_args > IORING_MAX_RESTRICTIONS)
4098                 return -EINVAL;
4099
4100         size = array_size(nr_args, sizeof(*res));
4101         if (size == SIZE_MAX)
4102                 return -EOVERFLOW;
4103
4104         res = memdup_user(arg, size);
4105         if (IS_ERR(res))
4106                 return PTR_ERR(res);
4107
4108         ret = 0;
4109
4110         for (i = 0; i < nr_args; i++) {
4111                 switch (res[i].opcode) {
4112                 case IORING_RESTRICTION_REGISTER_OP:
4113                         if (res[i].register_op >= IORING_REGISTER_LAST) {
4114                                 ret = -EINVAL;
4115                                 goto out;
4116                         }
4117
4118                         __set_bit(res[i].register_op,
4119                                   ctx->restrictions.register_op);
4120                         break;
4121                 case IORING_RESTRICTION_SQE_OP:
4122                         if (res[i].sqe_op >= IORING_OP_LAST) {
4123                                 ret = -EINVAL;
4124                                 goto out;
4125                         }
4126
4127                         __set_bit(res[i].sqe_op, ctx->restrictions.sqe_op);
4128                         break;
4129                 case IORING_RESTRICTION_SQE_FLAGS_ALLOWED:
4130                         ctx->restrictions.sqe_flags_allowed = res[i].sqe_flags;
4131                         break;
4132                 case IORING_RESTRICTION_SQE_FLAGS_REQUIRED:
4133                         ctx->restrictions.sqe_flags_required = res[i].sqe_flags;
4134                         break;
4135                 default:
4136                         ret = -EINVAL;
4137                         goto out;
4138                 }
4139         }
4140
4141 out:
4142         /* Reset all restrictions if an error happened */
4143         if (ret != 0)
4144                 memset(&ctx->restrictions, 0, sizeof(ctx->restrictions));
4145         else
4146                 ctx->restrictions.registered = true;
4147
4148         kfree(res);
4149         return ret;
4150 }
4151
4152 static int io_register_enable_rings(struct io_ring_ctx *ctx)
4153 {
4154         if (!(ctx->flags & IORING_SETUP_R_DISABLED))
4155                 return -EBADFD;
4156
4157         if (ctx->flags & IORING_SETUP_SINGLE_ISSUER && !ctx->submitter_task) {
4158                 WRITE_ONCE(ctx->submitter_task, get_task_struct(current));
4159                 /*
4160                  * Lazy activation attempts would fail if it was polled before
4161                  * submitter_task is set.
4162                  */
4163                 if (wq_has_sleeper(&ctx->poll_wq))
4164                         io_activate_pollwq(ctx);
4165         }
4166
4167         if (ctx->restrictions.registered)
4168                 ctx->restricted = 1;
4169
4170         ctx->flags &= ~IORING_SETUP_R_DISABLED;
4171         if (ctx->sq_data && wq_has_sleeper(&ctx->sq_data->wait))
4172                 wake_up(&ctx->sq_data->wait);
4173         return 0;
4174 }
4175
4176 static __cold int __io_register_iowq_aff(struct io_ring_ctx *ctx,
4177                                          cpumask_var_t new_mask)
4178 {
4179         int ret;
4180
4181         if (!(ctx->flags & IORING_SETUP_SQPOLL)) {
4182                 ret = io_wq_cpu_affinity(current->io_uring, new_mask);
4183         } else {
4184                 mutex_unlock(&ctx->uring_lock);
4185                 ret = io_sqpoll_wq_cpu_affinity(ctx, new_mask);
4186                 mutex_lock(&ctx->uring_lock);
4187         }
4188
4189         return ret;
4190 }
4191
4192 static __cold int io_register_iowq_aff(struct io_ring_ctx *ctx,
4193                                        void __user *arg, unsigned len)
4194 {
4195         cpumask_var_t new_mask;
4196         int ret;
4197
4198         if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
4199                 return -ENOMEM;
4200
4201         cpumask_clear(new_mask);
4202         if (len > cpumask_size())
4203                 len = cpumask_size();
4204
4205         if (in_compat_syscall()) {
4206                 ret = compat_get_bitmap(cpumask_bits(new_mask),
4207                                         (const compat_ulong_t __user *)arg,
4208                                         len * 8 /* CHAR_BIT */);
4209         } else {
4210                 ret = copy_from_user(new_mask, arg, len);
4211         }
4212
4213         if (ret) {
4214                 free_cpumask_var(new_mask);
4215                 return -EFAULT;
4216         }
4217
4218         ret = __io_register_iowq_aff(ctx, new_mask);
4219         free_cpumask_var(new_mask);
4220         return ret;
4221 }
4222
4223 static __cold int io_unregister_iowq_aff(struct io_ring_ctx *ctx)
4224 {
4225         return __io_register_iowq_aff(ctx, NULL);
4226 }
4227
4228 static __cold int io_register_iowq_max_workers(struct io_ring_ctx *ctx,
4229                                                void __user *arg)
4230         __must_hold(&ctx->uring_lock)
4231 {
4232         struct io_tctx_node *node;
4233         struct io_uring_task *tctx = NULL;
4234         struct io_sq_data *sqd = NULL;
4235         __u32 new_count[2];
4236         int i, ret;
4237
4238         if (copy_from_user(new_count, arg, sizeof(new_count)))
4239                 return -EFAULT;
4240         for (i = 0; i < ARRAY_SIZE(new_count); i++)
4241                 if (new_count[i] > INT_MAX)
4242                         return -EINVAL;
4243
4244         if (ctx->flags & IORING_SETUP_SQPOLL) {
4245                 sqd = ctx->sq_data;
4246                 if (sqd) {
4247                         /*
4248                          * Observe the correct sqd->lock -> ctx->uring_lock
4249                          * ordering. Fine to drop uring_lock here, we hold
4250                          * a ref to the ctx.
4251                          */
4252                         refcount_inc(&sqd->refs);
4253                         mutex_unlock(&ctx->uring_lock);
4254                         mutex_lock(&sqd->lock);
4255                         mutex_lock(&ctx->uring_lock);
4256                         if (sqd->thread)
4257                                 tctx = sqd->thread->io_uring;
4258                 }
4259         } else {
4260                 tctx = current->io_uring;
4261         }
4262
4263         BUILD_BUG_ON(sizeof(new_count) != sizeof(ctx->iowq_limits));
4264
4265         for (i = 0; i < ARRAY_SIZE(new_count); i++)
4266                 if (new_count[i])
4267                         ctx->iowq_limits[i] = new_count[i];
4268         ctx->iowq_limits_set = true;
4269
4270         if (tctx && tctx->io_wq) {
4271                 ret = io_wq_max_workers(tctx->io_wq, new_count);
4272                 if (ret)
4273                         goto err;
4274         } else {
4275                 memset(new_count, 0, sizeof(new_count));
4276         }
4277
4278         if (sqd) {
4279                 mutex_unlock(&sqd->lock);
4280                 io_put_sq_data(sqd);
4281         }
4282
4283         if (copy_to_user(arg, new_count, sizeof(new_count)))
4284                 return -EFAULT;
4285
4286         /* that's it for SQPOLL, only the SQPOLL task creates requests */
4287         if (sqd)
4288                 return 0;
4289
4290         /* now propagate the restriction to all registered users */
4291         list_for_each_entry(node, &ctx->tctx_list, ctx_node) {
4292                 struct io_uring_task *tctx = node->task->io_uring;
4293
4294                 if (WARN_ON_ONCE(!tctx->io_wq))
4295                         continue;
4296
4297                 for (i = 0; i < ARRAY_SIZE(new_count); i++)
4298                         new_count[i] = ctx->iowq_limits[i];
4299                 /* ignore errors, it always returns zero anyway */
4300                 (void)io_wq_max_workers(tctx->io_wq, new_count);
4301         }
4302         return 0;
4303 err:
4304         if (sqd) {
4305                 mutex_unlock(&sqd->lock);
4306                 io_put_sq_data(sqd);
4307         }
4308         return ret;
4309 }
4310
4311 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
4312                                void __user *arg, unsigned nr_args)
4313         __releases(ctx->uring_lock)
4314         __acquires(ctx->uring_lock)
4315 {
4316         int ret;
4317
4318         /*
4319          * We don't quiesce the refs for register anymore and so it can't be
4320          * dying as we're holding a file ref here.
4321          */
4322         if (WARN_ON_ONCE(percpu_ref_is_dying(&ctx->refs)))
4323                 return -ENXIO;
4324
4325         if (ctx->submitter_task && ctx->submitter_task != current)
4326                 return -EEXIST;
4327
4328         if (ctx->restricted) {
4329                 opcode = array_index_nospec(opcode, IORING_REGISTER_LAST);
4330                 if (!test_bit(opcode, ctx->restrictions.register_op))
4331                         return -EACCES;
4332         }
4333
4334         switch (opcode) {
4335         case IORING_REGISTER_BUFFERS:
4336                 ret = -EFAULT;
4337                 if (!arg)
4338                         break;
4339                 ret = io_sqe_buffers_register(ctx, arg, nr_args, NULL);
4340                 break;
4341         case IORING_UNREGISTER_BUFFERS:
4342                 ret = -EINVAL;
4343                 if (arg || nr_args)
4344                         break;
4345                 ret = io_sqe_buffers_unregister(ctx);
4346                 break;
4347         case IORING_REGISTER_FILES:
4348                 ret = -EFAULT;
4349                 if (!arg)
4350                         break;
4351                 ret = io_sqe_files_register(ctx, arg, nr_args, NULL);
4352                 break;
4353         case IORING_UNREGISTER_FILES:
4354                 ret = -EINVAL;
4355                 if (arg || nr_args)
4356                         break;
4357                 ret = io_sqe_files_unregister(ctx);
4358                 break;
4359         case IORING_REGISTER_FILES_UPDATE:
4360                 ret = io_register_files_update(ctx, arg, nr_args);
4361                 break;
4362         case IORING_REGISTER_EVENTFD:
4363                 ret = -EINVAL;
4364                 if (nr_args != 1)
4365                         break;
4366                 ret = io_eventfd_register(ctx, arg, 0);
4367                 break;
4368         case IORING_REGISTER_EVENTFD_ASYNC:
4369                 ret = -EINVAL;
4370                 if (nr_args != 1)
4371                         break;
4372                 ret = io_eventfd_register(ctx, arg, 1);
4373                 break;
4374         case IORING_UNREGISTER_EVENTFD:
4375                 ret = -EINVAL;
4376                 if (arg || nr_args)
4377                         break;
4378                 ret = io_eventfd_unregister(ctx);
4379                 break;
4380         case IORING_REGISTER_PROBE:
4381                 ret = -EINVAL;
4382                 if (!arg || nr_args > 256)
4383                         break;
4384                 ret = io_probe(ctx, arg, nr_args);
4385                 break;
4386         case IORING_REGISTER_PERSONALITY:
4387                 ret = -EINVAL;
4388                 if (arg || nr_args)
4389                         break;
4390                 ret = io_register_personality(ctx);
4391                 break;
4392         case IORING_UNREGISTER_PERSONALITY:
4393                 ret = -EINVAL;
4394                 if (arg)
4395                         break;
4396                 ret = io_unregister_personality(ctx, nr_args);
4397                 break;
4398         case IORING_REGISTER_ENABLE_RINGS:
4399                 ret = -EINVAL;
4400                 if (arg || nr_args)
4401                         break;
4402                 ret = io_register_enable_rings(ctx);
4403                 break;
4404         case IORING_REGISTER_RESTRICTIONS:
4405                 ret = io_register_restrictions(ctx, arg, nr_args);
4406                 break;
4407         case IORING_REGISTER_FILES2:
4408                 ret = io_register_rsrc(ctx, arg, nr_args, IORING_RSRC_FILE);
4409                 break;
4410         case IORING_REGISTER_FILES_UPDATE2:
4411                 ret = io_register_rsrc_update(ctx, arg, nr_args,
4412                                               IORING_RSRC_FILE);
4413                 break;
4414         case IORING_REGISTER_BUFFERS2:
4415                 ret = io_register_rsrc(ctx, arg, nr_args, IORING_RSRC_BUFFER);
4416                 break;
4417         case IORING_REGISTER_BUFFERS_UPDATE:
4418                 ret = io_register_rsrc_update(ctx, arg, nr_args,
4419                                               IORING_RSRC_BUFFER);
4420                 break;
4421         case IORING_REGISTER_IOWQ_AFF:
4422                 ret = -EINVAL;
4423                 if (!arg || !nr_args)
4424                         break;
4425                 ret = io_register_iowq_aff(ctx, arg, nr_args);
4426                 break;
4427         case IORING_UNREGISTER_IOWQ_AFF:
4428                 ret = -EINVAL;
4429                 if (arg || nr_args)
4430                         break;
4431                 ret = io_unregister_iowq_aff(ctx);
4432                 break;
4433         case IORING_REGISTER_IOWQ_MAX_WORKERS:
4434                 ret = -EINVAL;
4435                 if (!arg || nr_args != 2)
4436                         break;
4437                 ret = io_register_iowq_max_workers(ctx, arg);
4438                 break;
4439         case IORING_REGISTER_RING_FDS:
4440                 ret = io_ringfd_register(ctx, arg, nr_args);
4441                 break;
4442         case IORING_UNREGISTER_RING_FDS:
4443                 ret = io_ringfd_unregister(ctx, arg, nr_args);
4444                 break;
4445         case IORING_REGISTER_PBUF_RING:
4446                 ret = -EINVAL;
4447                 if (!arg || nr_args != 1)
4448                         break;
4449                 ret = io_register_pbuf_ring(ctx, arg);
4450                 break;
4451         case IORING_UNREGISTER_PBUF_RING:
4452                 ret = -EINVAL;
4453                 if (!arg || nr_args != 1)
4454                         break;
4455                 ret = io_unregister_pbuf_ring(ctx, arg);
4456                 break;
4457         case IORING_REGISTER_SYNC_CANCEL:
4458                 ret = -EINVAL;
4459                 if (!arg || nr_args != 1)
4460                         break;
4461                 ret = io_sync_cancel(ctx, arg);
4462                 break;
4463         case IORING_REGISTER_FILE_ALLOC_RANGE:
4464                 ret = -EINVAL;
4465                 if (!arg || nr_args)
4466                         break;
4467                 ret = io_register_file_alloc_range(ctx, arg);
4468                 break;
4469         default:
4470                 ret = -EINVAL;
4471                 break;
4472         }
4473
4474         return ret;
4475 }
4476
4477 SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
4478                 void __user *, arg, unsigned int, nr_args)
4479 {
4480         struct io_ring_ctx *ctx;
4481         long ret = -EBADF;
4482         struct fd f;
4483         bool use_registered_ring;
4484
4485         use_registered_ring = !!(opcode & IORING_REGISTER_USE_REGISTERED_RING);
4486         opcode &= ~IORING_REGISTER_USE_REGISTERED_RING;
4487
4488         if (opcode >= IORING_REGISTER_LAST)
4489                 return -EINVAL;
4490
4491         if (use_registered_ring) {
4492                 /*
4493                  * Ring fd has been registered via IORING_REGISTER_RING_FDS, we
4494                  * need only dereference our task private array to find it.
4495                  */
4496                 struct io_uring_task *tctx = current->io_uring;
4497
4498                 if (unlikely(!tctx || fd >= IO_RINGFD_REG_MAX))
4499                         return -EINVAL;
4500                 fd = array_index_nospec(fd, IO_RINGFD_REG_MAX);
4501                 f.file = tctx->registered_rings[fd];
4502                 f.flags = 0;
4503                 if (unlikely(!f.file))
4504                         return -EBADF;
4505         } else {
4506                 f = fdget(fd);
4507                 if (unlikely(!f.file))
4508                         return -EBADF;
4509                 ret = -EOPNOTSUPP;
4510                 if (!io_is_uring_fops(f.file))
4511                         goto out_fput;
4512         }
4513
4514         ctx = f.file->private_data;
4515
4516         mutex_lock(&ctx->uring_lock);
4517         ret = __io_uring_register(ctx, opcode, arg, nr_args);
4518         mutex_unlock(&ctx->uring_lock);
4519         trace_io_uring_register(ctx, opcode, ctx->nr_user_files, ctx->nr_user_bufs, ret);
4520 out_fput:
4521         fdput(f);
4522         return ret;
4523 }
4524
4525 static int __init io_uring_init(void)
4526 {
4527 #define __BUILD_BUG_VERIFY_OFFSET_SIZE(stype, eoffset, esize, ename) do { \
4528         BUILD_BUG_ON(offsetof(stype, ename) != eoffset); \
4529         BUILD_BUG_ON(sizeof_field(stype, ename) != esize); \
4530 } while (0)
4531
4532 #define BUILD_BUG_SQE_ELEM(eoffset, etype, ename) \
4533         __BUILD_BUG_VERIFY_OFFSET_SIZE(struct io_uring_sqe, eoffset, sizeof(etype), ename)
4534 #define BUILD_BUG_SQE_ELEM_SIZE(eoffset, esize, ename) \
4535         __BUILD_BUG_VERIFY_OFFSET_SIZE(struct io_uring_sqe, eoffset, esize, ename)
4536         BUILD_BUG_ON(sizeof(struct io_uring_sqe) != 64);
4537         BUILD_BUG_SQE_ELEM(0,  __u8,   opcode);
4538         BUILD_BUG_SQE_ELEM(1,  __u8,   flags);
4539         BUILD_BUG_SQE_ELEM(2,  __u16,  ioprio);
4540         BUILD_BUG_SQE_ELEM(4,  __s32,  fd);
4541         BUILD_BUG_SQE_ELEM(8,  __u64,  off);
4542         BUILD_BUG_SQE_ELEM(8,  __u64,  addr2);
4543         BUILD_BUG_SQE_ELEM(8,  __u32,  cmd_op);
4544         BUILD_BUG_SQE_ELEM(12, __u32, __pad1);
4545         BUILD_BUG_SQE_ELEM(16, __u64,  addr);
4546         BUILD_BUG_SQE_ELEM(16, __u64,  splice_off_in);
4547         BUILD_BUG_SQE_ELEM(24, __u32,  len);
4548         BUILD_BUG_SQE_ELEM(28,     __kernel_rwf_t, rw_flags);
4549         BUILD_BUG_SQE_ELEM(28, /* compat */   int, rw_flags);
4550         BUILD_BUG_SQE_ELEM(28, /* compat */ __u32, rw_flags);
4551         BUILD_BUG_SQE_ELEM(28, __u32,  fsync_flags);
4552         BUILD_BUG_SQE_ELEM(28, /* compat */ __u16,  poll_events);
4553         BUILD_BUG_SQE_ELEM(28, __u32,  poll32_events);
4554         BUILD_BUG_SQE_ELEM(28, __u32,  sync_range_flags);
4555         BUILD_BUG_SQE_ELEM(28, __u32,  msg_flags);
4556         BUILD_BUG_SQE_ELEM(28, __u32,  timeout_flags);
4557         BUILD_BUG_SQE_ELEM(28, __u32,  accept_flags);
4558         BUILD_BUG_SQE_ELEM(28, __u32,  cancel_flags);
4559         BUILD_BUG_SQE_ELEM(28, __u32,  open_flags);
4560         BUILD_BUG_SQE_ELEM(28, __u32,  statx_flags);
4561         BUILD_BUG_SQE_ELEM(28, __u32,  fadvise_advice);
4562         BUILD_BUG_SQE_ELEM(28, __u32,  splice_flags);
4563         BUILD_BUG_SQE_ELEM(28, __u32,  rename_flags);
4564         BUILD_BUG_SQE_ELEM(28, __u32,  unlink_flags);
4565         BUILD_BUG_SQE_ELEM(28, __u32,  hardlink_flags);
4566         BUILD_BUG_SQE_ELEM(28, __u32,  xattr_flags);
4567         BUILD_BUG_SQE_ELEM(28, __u32,  msg_ring_flags);
4568         BUILD_BUG_SQE_ELEM(32, __u64,  user_data);
4569         BUILD_BUG_SQE_ELEM(40, __u16,  buf_index);
4570         BUILD_BUG_SQE_ELEM(40, __u16,  buf_group);
4571         BUILD_BUG_SQE_ELEM(42, __u16,  personality);
4572         BUILD_BUG_SQE_ELEM(44, __s32,  splice_fd_in);
4573         BUILD_BUG_SQE_ELEM(44, __u32,  file_index);
4574         BUILD_BUG_SQE_ELEM(44, __u16,  addr_len);
4575         BUILD_BUG_SQE_ELEM(46, __u16,  __pad3[0]);
4576         BUILD_BUG_SQE_ELEM(48, __u64,  addr3);
4577         BUILD_BUG_SQE_ELEM_SIZE(48, 0, cmd);
4578         BUILD_BUG_SQE_ELEM(56, __u64,  __pad2);
4579
4580         BUILD_BUG_ON(sizeof(struct io_uring_files_update) !=
4581                      sizeof(struct io_uring_rsrc_update));
4582         BUILD_BUG_ON(sizeof(struct io_uring_rsrc_update) >
4583                      sizeof(struct io_uring_rsrc_update2));
4584
4585         /* ->buf_index is u16 */
4586         BUILD_BUG_ON(offsetof(struct io_uring_buf_ring, bufs) != 0);
4587         BUILD_BUG_ON(offsetof(struct io_uring_buf, resv) !=
4588                      offsetof(struct io_uring_buf_ring, tail));
4589
4590         /* should fit into one byte */
4591         BUILD_BUG_ON(SQE_VALID_FLAGS >= (1 << 8));
4592         BUILD_BUG_ON(SQE_COMMON_FLAGS >= (1 << 8));
4593         BUILD_BUG_ON((SQE_VALID_FLAGS | SQE_COMMON_FLAGS) != SQE_VALID_FLAGS);
4594
4595         BUILD_BUG_ON(__REQ_F_LAST_BIT > 8 * sizeof(int));
4596
4597         BUILD_BUG_ON(sizeof(atomic_t) != sizeof(u32));
4598
4599         io_uring_optable_init();
4600
4601         /*
4602          * Allow user copy in the per-command field, which starts after the
4603          * file in io_kiocb and until the opcode field. The openat2 handling
4604          * requires copying in user memory into the io_kiocb object in that
4605          * range, and HARDENED_USERCOPY will complain if we haven't
4606          * correctly annotated this range.
4607          */
4608         req_cachep = kmem_cache_create_usercopy("io_kiocb",
4609                                 sizeof(struct io_kiocb), 0,
4610                                 SLAB_HWCACHE_ALIGN | SLAB_PANIC |
4611                                 SLAB_ACCOUNT | SLAB_TYPESAFE_BY_RCU,
4612                                 offsetof(struct io_kiocb, cmd.data),
4613                                 sizeof_field(struct io_kiocb, cmd.data), NULL);
4614
4615         return 0;
4616 };
4617 __initcall(io_uring_init);