fs/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_cqring (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 <linux/compat.h>
  47 #include <net/compat.h>
  48 #include <linux/refcount.h>
  49 #include <linux/uio.h>
  50 #include <linux/bits.h>
  51
  52 #include <linux/sched/signal.h>
  53 #include <linux/fs.h>
  54 #include <linux/file.h>
  55 #include <linux/fdtable.h>
  56 #include <linux/mm.h>
  57 #include <linux/mman.h>
  58 #include <linux/percpu.h>
  59 #include <linux/slab.h>
  60 #include <linux/kthread.h>
  61 #include <linux/blkdev.h>
  62 #include <linux/bvec.h>
  63 #include <linux/net.h>
  64 #include <net/sock.h>
  65 #include <net/af_unix.h>
  66 #include <net/scm.h>
  67 #include <linux/anon_inodes.h>
  68 #include <linux/sched/mm.h>
  69 #include <linux/uaccess.h>
  70 #include <linux/nospec.h>
  71 #include <linux/sizes.h>
  72 #include <linux/hugetlb.h>
  73 #include <linux/highmem.h>
  74 #include <linux/namei.h>
  75 #include <linux/fsnotify.h>
  76 #include <linux/fadvise.h>
  77 #include <linux/eventpoll.h>
  78 #include <linux/fs_struct.h>
  79 #include <linux/splice.h>
  80 #include <linux/task_work.h>
  81 #include <linux/pagemap.h>
  82
  83 #define CREATE_TRACE_POINTS
  84 #include <trace/events/io_uring.h>
  85
  86 #include <uapi/linux/io_uring.h>
  87
  88 #include "internal.h"
  89 #include "io-wq.h"
  90
  91 #define IORING_MAX_ENTRIES      32768
  92 #define IORING_MAX_CQ_ENTRIES   (2 * IORING_MAX_ENTRIES)
  93
  94 /*
  95  * Shift of 9 is 512 entries, or exactly one page on 64-bit archs
  96  */
  97 #define IORING_FILE_TABLE_SHIFT 9
  98 #define IORING_MAX_FILES_TABLE  (1U << IORING_FILE_TABLE_SHIFT)
  99 #define IORING_FILE_TABLE_MASK  (IORING_MAX_FILES_TABLE - 1)
 100 #define IORING_MAX_FIXED_FILES  (64 * IORING_MAX_FILES_TABLE)
 101
 102 struct io_uring {
 103         u32 head ____cacheline_aligned_in_smp;
 104         u32 tail ____cacheline_aligned_in_smp;
 105 };
 106
 107 /*
 108  * This data is shared with the application through the mmap at offsets
 109  * IORING_OFF_SQ_RING and IORING_OFF_CQ_RING.
 110  *
 111  * The offsets to the member fields are published through struct
 112  * io_sqring_offsets when calling io_uring_setup.
 113  */
 114 struct io_rings {
 115         /*
 116          * Head and tail offsets into the ring; the offsets need to be
 117          * masked to get valid indices.
 118          *
 119          * The kernel controls head of the sq ring and the tail of the cq ring,
 120          * and the application controls tail of the sq ring and the head of the
 121          * cq ring.
 122          */
 123         struct io_uring         sq, cq;
 124         /*
 125          * Bitmasks to apply to head and tail offsets (constant, equals
 126          * ring_entries - 1)
 127          */
 128         u32                     sq_ring_mask, cq_ring_mask;
 129         /* Ring sizes (constant, power of 2) */
 130         u32                     sq_ring_entries, cq_ring_entries;
 131         /*
 132          * Number of invalid entries dropped by the kernel due to
 133          * invalid index stored in array
 134          *
 135          * Written by the kernel, shouldn't be modified by the
 136          * application (i.e. get number of "new events" by comparing to
 137          * cached value).
 138          *
 139          * After a new SQ head value was read by the application this
 140          * counter includes all submissions that were dropped reaching
 141          * the new SQ head (and possibly more).
 142          */
 143         u32                     sq_dropped;
 144         /*
 145          * Runtime SQ flags
 146          *
 147          * Written by the kernel, shouldn't be modified by the
 148          * application.
 149          *
 150          * The application needs a full memory barrier before checking
 151          * for IORING_SQ_NEED_WAKEUP after updating the sq tail.
 152          */
 153         u32                     sq_flags;
 154         /*
 155          * Runtime CQ flags
 156          *
 157          * Written by the application, shouldn't be modified by the
 158          * kernel.
 159          */
 160         u32                     cq_flags;
 161         /*
 162          * Number of completion events lost because the queue was full;
 163          * this should be avoided by the application by making sure
 164          * there are not more requests pending than there is space in
 165          * the completion queue.
 166          *
 167          * Written by the kernel, shouldn't be modified by the
 168          * application (i.e. get number of "new events" by comparing to
 169          * cached value).
 170          *
 171          * As completion events come in out of order this counter is not
 172          * ordered with any other data.
 173          */
 174         u32                     cq_overflow;
 175         /*
 176          * Ring buffer of completion events.
 177          *
 178          * The kernel writes completion events fresh every time they are
 179          * produced, so the application is allowed to modify pending
 180          * entries.
 181          */
 182         struct io_uring_cqe     cqes[] ____cacheline_aligned_in_smp;
 183 };
 184
 185 struct io_mapped_ubuf {
 186         u64             ubuf;
 187         size_t          len;
 188         struct          bio_vec *bvec;
 189         unsigned int    nr_bvecs;
 190 };
 191
 192 struct fixed_file_table {
 193         struct file             **files;
 194 };
 195
 196 struct fixed_file_ref_node {
 197         struct percpu_ref               refs;
 198         struct list_head                node;
 199         struct list_head                file_list;
 200         struct fixed_file_data          *file_data;
 201         struct llist_node               llist;
 202 };
 203
 204 struct fixed_file_data {
 205         struct fixed_file_table         *table;
 206         struct io_ring_ctx              *ctx;
 207
 208         struct percpu_ref               *cur_refs;
 209         struct percpu_ref               refs;
 210         struct completion               done;
 211         struct list_head                ref_list;
 212         spinlock_t                      lock;
 213 };
 214
 215 struct io_buffer {
 216         struct list_head list;
 217         __u64 addr;
 218         __s32 len;
 219         __u16 bid;
 220 };
 221
 222 struct io_ring_ctx {
 223         struct {
 224                 struct percpu_ref       refs;
 225         } ____cacheline_aligned_in_smp;
 226
 227         struct {
 228                 unsigned int            flags;
 229                 unsigned int            compat: 1;
 230                 unsigned int            limit_mem: 1;
 231                 unsigned int            cq_overflow_flushed: 1;
 232                 unsigned int            drain_next: 1;
 233                 unsigned int            eventfd_async: 1;
 234
 235                 /*
 236                  * Ring buffer of indices into array of io_uring_sqe, which is
 237                  * mmapped by the application using the IORING_OFF_SQES offset.
 238                  *
 239                  * This indirection could e.g. be used to assign fixed
 240                  * io_uring_sqe entries to operations and only submit them to
 241                  * the queue when needed.
 242                  *
 243                  * The kernel modifies neither the indices array nor the entries
 244                  * array.
 245                  */
 246                 u32                     *sq_array;
 247                 unsigned                cached_sq_head;
 248                 unsigned                sq_entries;
 249                 unsigned                sq_mask;
 250                 unsigned                sq_thread_idle;
 251                 unsigned                cached_sq_dropped;
 252                 atomic_t                cached_cq_overflow;
 253                 unsigned long           sq_check_overflow;
 254
 255                 struct list_head        defer_list;
 256                 struct list_head        timeout_list;
 257                 struct list_head        cq_overflow_list;
 258
 259                 wait_queue_head_t       inflight_wait;
 260                 struct io_uring_sqe     *sq_sqes;
 261         } ____cacheline_aligned_in_smp;
 262
 263         struct io_rings *rings;
 264
 265         /* IO offload */
 266         struct io_wq            *io_wq;
 267         struct task_struct      *sqo_thread;    /* if using sq thread polling */
 268         struct mm_struct        *sqo_mm;
 269         wait_queue_head_t       sqo_wait;
 270
 271         /*
 272          * If used, fixed file set. Writers must ensure that ->refs is dead,
 273          * readers must ensure that ->refs is alive as long as the file* is
 274          * used. Only updated through io_uring_register(2).
 275          */
 276         struct fixed_file_data  *file_data;
 277         unsigned                nr_user_files;
 278         int                     ring_fd;
 279         struct file             *ring_file;
 280
 281         /* if used, fixed mapped user buffers */
 282         unsigned                nr_user_bufs;
 283         struct io_mapped_ubuf   *user_bufs;
 284
 285         struct user_struct      *user;
 286
 287         const struct cred       *creds;
 288
 289         struct completion       ref_comp;
 290         struct completion       sq_thread_comp;
 291
 292         /* if all else fails... */
 293         struct io_kiocb         *fallback_req;
 294
 295 #if defined(CONFIG_UNIX)
 296         struct socket           *ring_sock;
 297 #endif
 298
 299         struct idr              io_buffer_idr;
 300
 301         struct idr              personality_idr;
 302
 303         struct {
 304                 unsigned                cached_cq_tail;
 305                 unsigned                cq_entries;
 306                 unsigned                cq_mask;
 307                 atomic_t                cq_timeouts;
 308                 unsigned long           cq_check_overflow;
 309                 struct wait_queue_head  cq_wait;
 310                 struct fasync_struct    *cq_fasync;
 311                 struct eventfd_ctx      *cq_ev_fd;
 312         } ____cacheline_aligned_in_smp;
 313
 314         struct {
 315                 struct mutex            uring_lock;
 316                 wait_queue_head_t       wait;
 317         } ____cacheline_aligned_in_smp;
 318
 319         struct {
 320                 spinlock_t              completion_lock;
 321
 322                 /*
 323                  * ->iopoll_list is protected by the ctx->uring_lock for
 324                  * io_uring instances that don't use IORING_SETUP_SQPOLL.
 325                  * For SQPOLL, only the single threaded io_sq_thread() will
 326                  * manipulate the list, hence no extra locking is needed there.
 327                  */
 328                 struct list_head        iopoll_list;
 329                 struct hlist_head       *cancel_hash;
 330                 unsigned                cancel_hash_bits;
 331                 bool                    poll_multi_file;
 332
 333                 spinlock_t              inflight_lock;
 334                 struct list_head        inflight_list;
 335         } ____cacheline_aligned_in_smp;
 336
 337         struct delayed_work             file_put_work;
 338         struct llist_head               file_put_llist;
 339
 340         struct work_struct              exit_work;
 341 };
 342
 343 /*
 344  * First field must be the file pointer in all the
 345  * iocb unions! See also 'struct kiocb' in <linux/fs.h>
 346  */
 347 struct io_poll_iocb {
 348         struct file                     *file;
 349         union {
 350                 struct wait_queue_head  *head;
 351                 u64                     addr;
 352         };
 353         __poll_t                        events;
 354         bool                            done;
 355         bool                            canceled;
 356         struct wait_queue_entry         wait;
 357 };
 358
 359 struct io_close {
 360         struct file                     *file;
 361         struct file                     *put_file;
 362         int                             fd;
 363 };
 364
 365 struct io_timeout_data {
 366         struct io_kiocb                 *req;
 367         struct hrtimer                  timer;
 368         struct timespec64               ts;
 369         enum hrtimer_mode               mode;
 370 };
 371
 372 struct io_accept {
 373         struct file                     *file;
 374         struct sockaddr __user          *addr;
 375         int __user                      *addr_len;
 376         int                             flags;
 377         unsigned long                   nofile;
 378 };
 379
 380 struct io_sync {
 381         struct file                     *file;
 382         loff_t                          len;
 383         loff_t                          off;
 384         int                             flags;
 385         int                             mode;
 386 };
 387
 388 struct io_cancel {
 389         struct file                     *file;
 390         u64                             addr;
 391 };
 392
 393 struct io_timeout {
 394         struct file                     *file;
 395         u64                             addr;
 396         int                             flags;
 397         u32                             off;
 398         u32                             target_seq;
 399         struct list_head                list;
 400 };
 401
 402 struct io_rw {
 403         /* NOTE: kiocb has the file as the first member, so don't do it here */
 404         struct kiocb                    kiocb;
 405         u64                             addr;
 406         u64                             len;
 407 };
 408
 409 struct io_connect {
 410         struct file                     *file;
 411         struct sockaddr __user          *addr;
 412         int                             addr_len;
 413 };
 414
 415 struct io_sr_msg {
 416         struct file                     *file;
 417         union {
 418                 struct user_msghdr __user *umsg;
 419                 void __user             *buf;
 420         };
 421         int                             msg_flags;
 422         int                             bgid;
 423         size_t                          len;
 424         struct io_buffer                *kbuf;
 425 };
 426
 427 struct io_open {
 428         struct file                     *file;
 429         int                             dfd;
 430         struct filename                 *filename;
 431         struct open_how                 how;
 432         unsigned long                   nofile;
 433 };
 434
 435 struct io_files_update {
 436         struct file                     *file;
 437         u64                             arg;
 438         u32                             nr_args;
 439         u32                             offset;
 440 };
 441
 442 struct io_fadvise {
 443         struct file                     *file;
 444         u64                             offset;
 445         u32                             len;
 446         u32                             advice;
 447 };
 448
 449 struct io_madvise {
 450         struct file                     *file;
 451         u64                             addr;
 452         u32                             len;
 453         u32                             advice;
 454 };
 455
 456 struct io_epoll {
 457         struct file                     *file;
 458         int                             epfd;
 459         int                             op;
 460         int                             fd;
 461         struct epoll_event              event;
 462 };
 463
 464 struct io_splice {
 465         struct file                     *file_out;
 466         struct file                     *file_in;
 467         loff_t                          off_out;
 468         loff_t                          off_in;
 469         u64                             len;
 470         unsigned int                    flags;
 471 };
 472
 473 struct io_provide_buf {
 474         struct file                     *file;
 475         __u64                           addr;
 476         __s32                           len;
 477         __u32                           bgid;
 478         __u16                           nbufs;
 479         __u16                           bid;
 480 };
 481
 482 struct io_statx {
 483         struct file                     *file;
 484         int                             dfd;
 485         unsigned int                    mask;
 486         unsigned int                    flags;
 487         const char __user               *filename;
 488         struct statx __user             *buffer;
 489 };
 490
 491 struct io_completion {
 492         struct file                     *file;
 493         struct list_head                list;
 494         int                             cflags;
 495 };
 496
 497 struct io_async_connect {
 498         struct sockaddr_storage         address;
 499 };
 500
 501 struct io_async_msghdr {
 502         struct iovec                    fast_iov[UIO_FASTIOV];
 503         struct iovec                    *iov;
 504         struct sockaddr __user          *uaddr;
 505         struct msghdr                   msg;
 506         struct sockaddr_storage         addr;
 507 };
 508
 509 struct io_async_rw {
 510         struct iovec                    fast_iov[UIO_FASTIOV];
 511         struct iovec                    *iov;
 512         ssize_t                         nr_segs;
 513         ssize_t                         size;
 514         struct wait_page_queue          wpq;
 515 };
 516
 517 struct io_async_ctx {
 518         union {
 519                 struct io_async_rw      rw;
 520                 struct io_async_msghdr  msg;
 521                 struct io_async_connect connect;
 522                 struct io_timeout_data  timeout;
 523         };
 524 };
 525
 526 enum {
 527         REQ_F_FIXED_FILE_BIT    = IOSQE_FIXED_FILE_BIT,
 528         REQ_F_IO_DRAIN_BIT      = IOSQE_IO_DRAIN_BIT,
 529         REQ_F_LINK_BIT          = IOSQE_IO_LINK_BIT,
 530         REQ_F_HARDLINK_BIT      = IOSQE_IO_HARDLINK_BIT,
 531         REQ_F_FORCE_ASYNC_BIT   = IOSQE_ASYNC_BIT,
 532         REQ_F_BUFFER_SELECT_BIT = IOSQE_BUFFER_SELECT_BIT,
 533
 534         REQ_F_LINK_HEAD_BIT,
 535         REQ_F_FAIL_LINK_BIT,
 536         REQ_F_INFLIGHT_BIT,
 537         REQ_F_CUR_POS_BIT,
 538         REQ_F_NOWAIT_BIT,
 539         REQ_F_LINK_TIMEOUT_BIT,
 540         REQ_F_ISREG_BIT,
 541         REQ_F_COMP_LOCKED_BIT,
 542         REQ_F_NEED_CLEANUP_BIT,
 543         REQ_F_OVERFLOW_BIT,
 544         REQ_F_POLLED_BIT,
 545         REQ_F_BUFFER_SELECTED_BIT,
 546         REQ_F_NO_FILE_TABLE_BIT,
 547         REQ_F_WORK_INITIALIZED_BIT,
 548         REQ_F_TASK_PINNED_BIT,
 549
 550         /* not a real bit, just to check we're not overflowing the space */
 551         __REQ_F_LAST_BIT,
 552 };
 553
 554 enum {
 555         /* ctx owns file */
 556         REQ_F_FIXED_FILE        = BIT(REQ_F_FIXED_FILE_BIT),
 557         /* drain existing IO first */
 558         REQ_F_IO_DRAIN          = BIT(REQ_F_IO_DRAIN_BIT),
 559         /* linked sqes */
 560         REQ_F_LINK              = BIT(REQ_F_LINK_BIT),
 561         /* doesn't sever on completion < 0 */
 562         REQ_F_HARDLINK          = BIT(REQ_F_HARDLINK_BIT),
 563         /* IOSQE_ASYNC */
 564         REQ_F_FORCE_ASYNC       = BIT(REQ_F_FORCE_ASYNC_BIT),
 565         /* IOSQE_BUFFER_SELECT */
 566         REQ_F_BUFFER_SELECT     = BIT(REQ_F_BUFFER_SELECT_BIT),
 567
 568         /* head of a link */
 569         REQ_F_LINK_HEAD         = BIT(REQ_F_LINK_HEAD_BIT),
 570         /* fail rest of links */
 571         REQ_F_FAIL_LINK         = BIT(REQ_F_FAIL_LINK_BIT),
 572         /* on inflight list */
 573         REQ_F_INFLIGHT          = BIT(REQ_F_INFLIGHT_BIT),
 574         /* read/write uses file position */
 575         REQ_F_CUR_POS           = BIT(REQ_F_CUR_POS_BIT),
 576         /* must not punt to workers */
 577         REQ_F_NOWAIT            = BIT(REQ_F_NOWAIT_BIT),
 578         /* has linked timeout */
 579         REQ_F_LINK_TIMEOUT      = BIT(REQ_F_LINK_TIMEOUT_BIT),
 580         /* regular file */
 581         REQ_F_ISREG             = BIT(REQ_F_ISREG_BIT),
 582         /* completion under lock */
 583         REQ_F_COMP_LOCKED       = BIT(REQ_F_COMP_LOCKED_BIT),
 584         /* needs cleanup */
 585         REQ_F_NEED_CLEANUP      = BIT(REQ_F_NEED_CLEANUP_BIT),
 586         /* in overflow list */
 587         REQ_F_OVERFLOW          = BIT(REQ_F_OVERFLOW_BIT),
 588         /* already went through poll handler */
 589         REQ_F_POLLED            = BIT(REQ_F_POLLED_BIT),
 590         /* buffer already selected */
 591         REQ_F_BUFFER_SELECTED   = BIT(REQ_F_BUFFER_SELECTED_BIT),
 592         /* doesn't need file table for this request */
 593         REQ_F_NO_FILE_TABLE     = BIT(REQ_F_NO_FILE_TABLE_BIT),
 594         /* io_wq_work is initialized */
 595         REQ_F_WORK_INITIALIZED  = BIT(REQ_F_WORK_INITIALIZED_BIT),
 596         /* req->task is refcounted */
 597         REQ_F_TASK_PINNED       = BIT(REQ_F_TASK_PINNED_BIT),
 598 };
 599
 600 struct async_poll {
 601         struct io_poll_iocb     poll;
 602         struct io_poll_iocb     *double_poll;
 603 };
 604
 605 /*
 606  * NOTE! Each of the iocb union members has the file pointer
 607  * as the first entry in their struct definition. So you can
 608  * access the file pointer through any of the sub-structs,
 609  * or directly as just 'ki_filp' in this struct.
 610  */
 611 struct io_kiocb {
 612         union {
 613                 struct file             *file;
 614                 struct io_rw            rw;
 615                 struct io_poll_iocb     poll;
 616                 struct io_accept        accept;
 617                 struct io_sync          sync;
 618                 struct io_cancel        cancel;
 619                 struct io_timeout       timeout;
 620                 struct io_connect       connect;
 621                 struct io_sr_msg        sr_msg;
 622                 struct io_open          open;
 623                 struct io_close         close;
 624                 struct io_files_update  files_update;
 625                 struct io_fadvise       fadvise;
 626                 struct io_madvise       madvise;
 627                 struct io_epoll         epoll;
 628                 struct io_splice        splice;
 629                 struct io_provide_buf   pbuf;
 630                 struct io_statx         statx;
 631                 /* use only after cleaning per-op data, see io_clean_op() */
 632                 struct io_completion    compl;
 633         };
 634
 635         struct io_async_ctx             *io;
 636         u8                              opcode;
 637         /* polled IO has completed */
 638         u8                              iopoll_completed;
 639
 640         u16                             buf_index;
 641         u32                             result;
 642
 643         struct io_ring_ctx              *ctx;
 644         unsigned int                    flags;
 645         refcount_t                      refs;
 646         struct task_struct              *task;
 647         u64                             user_data;
 648
 649         struct list_head                link_list;
 650
 651         /*
 652          * 1. used with ctx->iopoll_list with reads/writes
 653          * 2. to track reqs with ->files (see io_op_def::file_table)
 654          */
 655         struct list_head                inflight_entry;
 656
 657         struct percpu_ref               *fixed_file_refs;
 658         struct callback_head            task_work;
 659         /* for polled requests, i.e. IORING_OP_POLL_ADD and async armed poll */
 660         struct hlist_node               hash_node;
 661         struct async_poll               *apoll;
 662         struct io_wq_work               work;
 663 };
 664
 665 struct io_defer_entry {
 666         struct list_head        list;
 667         struct io_kiocb         *req;
 668         u32                     seq;
 669 };
 670
 671 #define IO_IOPOLL_BATCH                 8
 672
 673 struct io_comp_state {
 674         unsigned int            nr;
 675         struct list_head        list;
 676         struct io_ring_ctx      *ctx;
 677 };
 678
 679 struct io_submit_state {
 680         struct blk_plug         plug;
 681
 682         /*
 683          * io_kiocb alloc cache
 684          */
 685         void                    *reqs[IO_IOPOLL_BATCH];
 686         unsigned int            free_reqs;
 687
 688         /*
 689          * Batch completion logic
 690          */
 691         struct io_comp_state    comp;
 692
 693         /*
 694          * File reference cache
 695          */
 696         struct file             *file;
 697         unsigned int            fd;
 698         unsigned int            has_refs;
 699         unsigned int            ios_left;
 700 };
 701
 702 struct io_op_def {
 703         /* needs req->io allocated for deferral/async */
 704         unsigned                async_ctx : 1;
 705         /* needs current->mm setup, does mm access */
 706         unsigned                needs_mm : 1;
 707         /* needs req->file assigned */
 708         unsigned                needs_file : 1;
 709         /* don't fail if file grab fails */
 710         unsigned                needs_file_no_error : 1;
 711         /* hash wq insertion if file is a regular file */
 712         unsigned                hash_reg_file : 1;
 713         /* unbound wq insertion if file is a non-regular file */
 714         unsigned                unbound_nonreg_file : 1;
 715         /* opcode is not supported by this kernel */
 716         unsigned                not_supported : 1;
 717         /* needs file table */
 718         unsigned                file_table : 1;
 719         /* needs ->fs */
 720         unsigned                needs_fs : 1;
 721         /* set if opcode supports polled "wait" */
 722         unsigned                pollin : 1;
 723         unsigned                pollout : 1;
 724         /* op supports buffer selection */
 725         unsigned                buffer_select : 1;
 726         unsigned                needs_fsize : 1;
 727 };
 728
 729 static const struct io_op_def io_op_defs[] = {
 730         [IORING_OP_NOP] = {},
 731         [IORING_OP_READV] = {
 732                 .async_ctx              = 1,
 733                 .needs_mm               = 1,
 734                 .needs_file             = 1,
 735                 .unbound_nonreg_file    = 1,
 736                 .pollin                 = 1,
 737                 .buffer_select          = 1,
 738         },
 739         [IORING_OP_WRITEV] = {
 740                 .async_ctx              = 1,
 741                 .needs_mm               = 1,
 742                 .needs_file             = 1,
 743                 .hash_reg_file          = 1,
 744                 .unbound_nonreg_file    = 1,
 745                 .pollout                = 1,
 746                 .needs_fsize            = 1,
 747         },
 748         [IORING_OP_FSYNC] = {
 749                 .needs_file             = 1,
 750         },
 751         [IORING_OP_READ_FIXED] = {
 752                 .needs_file             = 1,
 753                 .unbound_nonreg_file    = 1,
 754                 .pollin                 = 1,
 755         },
 756         [IORING_OP_WRITE_FIXED] = {
 757                 .needs_file             = 1,
 758                 .hash_reg_file          = 1,
 759                 .unbound_nonreg_file    = 1,
 760                 .pollout                = 1,
 761                 .needs_fsize            = 1,
 762         },
 763         [IORING_OP_POLL_ADD] = {
 764                 .needs_file             = 1,
 765                 .unbound_nonreg_file    = 1,
 766         },
 767         [IORING_OP_POLL_REMOVE] = {},
 768         [IORING_OP_SYNC_FILE_RANGE] = {
 769                 .needs_file             = 1,
 770         },
 771         [IORING_OP_SENDMSG] = {
 772                 .async_ctx              = 1,
 773                 .needs_mm               = 1,
 774                 .needs_file             = 1,
 775                 .unbound_nonreg_file    = 1,
 776                 .needs_fs               = 1,
 777                 .pollout                = 1,
 778         },
 779         [IORING_OP_RECVMSG] = {
 780                 .async_ctx              = 1,
 781                 .needs_mm               = 1,
 782                 .needs_file             = 1,
 783                 .unbound_nonreg_file    = 1,
 784                 .needs_fs               = 1,
 785                 .pollin                 = 1,
 786                 .buffer_select          = 1,
 787         },
 788         [IORING_OP_TIMEOUT] = {
 789                 .async_ctx              = 1,
 790                 .needs_mm               = 1,
 791         },
 792         [IORING_OP_TIMEOUT_REMOVE] = {},
 793         [IORING_OP_ACCEPT] = {
 794                 .needs_mm               = 1,
 795                 .needs_file             = 1,
 796                 .unbound_nonreg_file    = 1,
 797                 .file_table             = 1,
 798                 .pollin                 = 1,
 799         },
 800         [IORING_OP_ASYNC_CANCEL] = {},
 801         [IORING_OP_LINK_TIMEOUT] = {
 802                 .async_ctx              = 1,
 803                 .needs_mm               = 1,
 804         },
 805         [IORING_OP_CONNECT] = {
 806                 .async_ctx              = 1,
 807                 .needs_mm               = 1,
 808                 .needs_file             = 1,
 809                 .unbound_nonreg_file    = 1,
 810                 .pollout                = 1,
 811         },
 812         [IORING_OP_FALLOCATE] = {
 813                 .needs_file             = 1,
 814                 .needs_fsize            = 1,
 815         },
 816         [IORING_OP_OPENAT] = {
 817                 .file_table             = 1,
 818                 .needs_fs               = 1,
 819         },
 820         [IORING_OP_CLOSE] = {
 821                 .needs_file             = 1,
 822                 .needs_file_no_error    = 1,
 823                 .file_table             = 1,
 824         },
 825         [IORING_OP_FILES_UPDATE] = {
 826                 .needs_mm               = 1,
 827                 .file_table             = 1,
 828         },
 829         [IORING_OP_STATX] = {
 830                 .needs_mm               = 1,
 831                 .needs_fs               = 1,
 832                 .file_table             = 1,
 833         },
 834         [IORING_OP_READ] = {
 835                 .needs_mm               = 1,
 836                 .needs_file             = 1,
 837                 .unbound_nonreg_file    = 1,
 838                 .pollin                 = 1,
 839                 .buffer_select          = 1,
 840         },
 841         [IORING_OP_WRITE] = {
 842                 .needs_mm               = 1,
 843                 .needs_file             = 1,
 844                 .unbound_nonreg_file    = 1,
 845                 .pollout                = 1,
 846                 .needs_fsize            = 1,
 847         },
 848         [IORING_OP_FADVISE] = {
 849                 .needs_file             = 1,
 850         },
 851         [IORING_OP_MADVISE] = {
 852                 .needs_mm               = 1,
 853         },
 854         [IORING_OP_SEND] = {
 855                 .needs_mm               = 1,
 856                 .needs_file             = 1,
 857                 .unbound_nonreg_file    = 1,
 858                 .pollout                = 1,
 859         },
 860         [IORING_OP_RECV] = {
 861                 .needs_mm               = 1,
 862                 .needs_file             = 1,
 863                 .unbound_nonreg_file    = 1,
 864                 .pollin                 = 1,
 865                 .buffer_select          = 1,
 866         },
 867         [IORING_OP_OPENAT2] = {
 868                 .file_table             = 1,
 869                 .needs_fs               = 1,
 870         },
 871         [IORING_OP_EPOLL_CTL] = {
 872                 .unbound_nonreg_file    = 1,
 873                 .file_table             = 1,
 874         },
 875         [IORING_OP_SPLICE] = {
 876                 .needs_file             = 1,
 877                 .hash_reg_file          = 1,
 878                 .unbound_nonreg_file    = 1,
 879         },
 880         [IORING_OP_PROVIDE_BUFFERS] = {},
 881         [IORING_OP_REMOVE_BUFFERS] = {},
 882         [IORING_OP_TEE] = {
 883                 .needs_file             = 1,
 884                 .hash_reg_file          = 1,
 885                 .unbound_nonreg_file    = 1,
 886         },
 887 };
 888
 889 enum io_mem_account {
 890         ACCT_LOCKED,
 891         ACCT_PINNED,
 892 };
 893
 894 static void __io_complete_rw(struct io_kiocb *req, long res, long res2,
 895                              struct io_comp_state *cs);
 896 static void io_cqring_fill_event(struct io_kiocb *req, long res);
 897 static void io_put_req(struct io_kiocb *req);
 898 static void io_double_put_req(struct io_kiocb *req);
 899 static void __io_double_put_req(struct io_kiocb *req);
 900 static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req);
 901 static void __io_queue_linked_timeout(struct io_kiocb *req);
 902 static void io_queue_linked_timeout(struct io_kiocb *req);
 903 static int __io_sqe_files_update(struct io_ring_ctx *ctx,
 904                                  struct io_uring_files_update *ip,
 905                                  unsigned nr_args);
 906 static int io_prep_work_files(struct io_kiocb *req);
 907 static void __io_clean_op(struct io_kiocb *req);
 908 static int io_file_get(struct io_submit_state *state, struct io_kiocb *req,
 909                        int fd, struct file **out_file, bool fixed);
 910 static void __io_queue_sqe(struct io_kiocb *req,
 911                            const struct io_uring_sqe *sqe,
 912                            struct io_comp_state *cs);
 913 static void io_file_put_work(struct work_struct *work);
 914
 915 static ssize_t io_import_iovec(int rw, struct io_kiocb *req,
 916                                struct iovec **iovec, struct iov_iter *iter,
 917                                bool needs_lock);
 918 static int io_setup_async_rw(struct io_kiocb *req, ssize_t io_size,
 919                              struct iovec *iovec, struct iovec *fast_iov,
 920                              struct iov_iter *iter);
 921
 922 static struct kmem_cache *req_cachep;
 923
 924 static const struct file_operations io_uring_fops;
 925
 926 struct sock *io_uring_get_socket(struct file *file)
 927 {
 928 #if defined(CONFIG_UNIX)
 929         if (file->f_op == &io_uring_fops) {
 930                 struct io_ring_ctx *ctx = file->private_data;
 931
 932                 return ctx->ring_sock->sk;
 933         }
 934 #endif
 935         return NULL;
 936 }
 937 EXPORT_SYMBOL(io_uring_get_socket);
 938
 939 static void io_get_req_task(struct io_kiocb *req)
 940 {
 941         if (req->flags & REQ_F_TASK_PINNED)
 942                 return;
 943         get_task_struct(req->task);
 944         req->flags |= REQ_F_TASK_PINNED;
 945 }
 946
 947 static inline void io_clean_op(struct io_kiocb *req)
 948 {
 949         if (req->flags & (REQ_F_NEED_CLEANUP | REQ_F_BUFFER_SELECTED))
 950                 __io_clean_op(req);
 951 }
 952
 953 /* not idempotent -- it doesn't clear REQ_F_TASK_PINNED */
 954 static void __io_put_req_task(struct io_kiocb *req)
 955 {
 956         if (req->flags & REQ_F_TASK_PINNED)
 957                 put_task_struct(req->task);
 958 }
 959
 960 static void io_sq_thread_drop_mm(void)
 961 {
 962         struct mm_struct *mm = current->mm;
 963
 964         if (mm) {
 965                 kthread_unuse_mm(mm);
 966                 mmput(mm);
 967         }
 968 }
 969
 970 static int __io_sq_thread_acquire_mm(struct io_ring_ctx *ctx)
 971 {
 972         if (!current->mm) {
 973                 if (unlikely(!(ctx->flags & IORING_SETUP_SQPOLL) ||
 974                              !mmget_not_zero(ctx->sqo_mm)))
 975                         return -EFAULT;
 976                 kthread_use_mm(ctx->sqo_mm);
 977         }
 978
 979         return 0;
 980 }
 981
 982 static int io_sq_thread_acquire_mm(struct io_ring_ctx *ctx,
 983                                    struct io_kiocb *req)
 984 {
 985         if (!io_op_defs[req->opcode].needs_mm)
 986                 return 0;
 987         return __io_sq_thread_acquire_mm(ctx);
 988 }
 989
 990 static inline void req_set_fail_links(struct io_kiocb *req)
 991 {
 992         if ((req->flags & (REQ_F_LINK | REQ_F_HARDLINK)) == REQ_F_LINK)
 993                 req->flags |= REQ_F_FAIL_LINK;
 994 }
 995
 996 /*
 997  * Note: must call io_req_init_async() for the first time you
 998  * touch any members of io_wq_work.
 999  */
1000 static inline void io_req_init_async(struct io_kiocb *req)
1001 {
1002         if (req->flags & REQ_F_WORK_INITIALIZED)
1003                 return;
1004
1005         memset(&req->work, 0, sizeof(req->work));
1006         req->flags |= REQ_F_WORK_INITIALIZED;
1007 }
1008
1009 static inline bool io_async_submit(struct io_ring_ctx *ctx)
1010 {
1011         return ctx->flags & IORING_SETUP_SQPOLL;
1012 }
1013
1014 static void io_ring_ctx_ref_free(struct percpu_ref *ref)
1015 {
1016         struct io_ring_ctx *ctx = container_of(ref, struct io_ring_ctx, refs);
1017
1018         complete(&ctx->ref_comp);
1019 }
1020
1021 static inline bool io_is_timeout_noseq(struct io_kiocb *req)
1022 {
1023         return !req->timeout.off;
1024 }
1025
1026 static struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
1027 {
1028         struct io_ring_ctx *ctx;
1029         int hash_bits;
1030
1031         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1032         if (!ctx)
1033                 return NULL;
1034
1035         ctx->fallback_req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
1036         if (!ctx->fallback_req)
1037                 goto err;
1038
1039         /*
1040          * Use 5 bits less than the max cq entries, that should give us around
1041          * 32 entries per hash list if totally full and uniformly spread.
1042          */
1043         hash_bits = ilog2(p->cq_entries);
1044         hash_bits -= 5;
1045         if (hash_bits <= 0)
1046                 hash_bits = 1;
1047         ctx->cancel_hash_bits = hash_bits;
1048         ctx->cancel_hash = kmalloc((1U << hash_bits) * sizeof(struct hlist_head),
1049                                         GFP_KERNEL);
1050         if (!ctx->cancel_hash)
1051                 goto err;
1052         __hash_init(ctx->cancel_hash, 1U << hash_bits);
1053
1054         if (percpu_ref_init(&ctx->refs, io_ring_ctx_ref_free,
1055                             PERCPU_REF_ALLOW_REINIT, GFP_KERNEL))
1056                 goto err;
1057
1058         ctx->flags = p->flags;
1059         init_waitqueue_head(&ctx->sqo_wait);
1060         init_waitqueue_head(&ctx->cq_wait);
1061         INIT_LIST_HEAD(&ctx->cq_overflow_list);
1062         init_completion(&ctx->ref_comp);
1063         init_completion(&ctx->sq_thread_comp);
1064         idr_init(&ctx->io_buffer_idr);
1065         idr_init(&ctx->personality_idr);
1066         mutex_init(&ctx->uring_lock);
1067         init_waitqueue_head(&ctx->wait);
1068         spin_lock_init(&ctx->completion_lock);
1069         INIT_LIST_HEAD(&ctx->iopoll_list);
1070         INIT_LIST_HEAD(&ctx->defer_list);
1071         INIT_LIST_HEAD(&ctx->timeout_list);
1072         init_waitqueue_head(&ctx->inflight_wait);
1073         spin_lock_init(&ctx->inflight_lock);
1074         INIT_LIST_HEAD(&ctx->inflight_list);
1075         INIT_DELAYED_WORK(&ctx->file_put_work, io_file_put_work);
1076         init_llist_head(&ctx->file_put_llist);
1077         return ctx;
1078 err:
1079         if (ctx->fallback_req)
1080                 kmem_cache_free(req_cachep, ctx->fallback_req);
1081         kfree(ctx->cancel_hash);
1082         kfree(ctx);
1083         return NULL;
1084 }
1085
1086 static bool req_need_defer(struct io_kiocb *req, u32 seq)
1087 {
1088         if (unlikely(req->flags & REQ_F_IO_DRAIN)) {
1089                 struct io_ring_ctx *ctx = req->ctx;
1090
1091                 return seq != ctx->cached_cq_tail
1092                                 + atomic_read(&ctx->cached_cq_overflow);
1093         }
1094
1095         return false;
1096 }
1097
1098 static void __io_commit_cqring(struct io_ring_ctx *ctx)
1099 {
1100         struct io_rings *rings = ctx->rings;
1101
1102         /* order cqe stores with ring update */
1103         smp_store_release(&rings->cq.tail, ctx->cached_cq_tail);
1104
1105         if (wq_has_sleeper(&ctx->cq_wait)) {
1106                 wake_up_interruptible(&ctx->cq_wait);
1107                 kill_fasync(&ctx->cq_fasync, SIGIO, POLL_IN);
1108         }
1109 }
1110
1111 /*
1112  * Returns true if we need to defer file table putting. This can only happen
1113  * from the error path with REQ_F_COMP_LOCKED set.
1114  */
1115 static bool io_req_clean_work(struct io_kiocb *req)
1116 {
1117         if (!(req->flags & REQ_F_WORK_INITIALIZED))
1118                 return false;
1119
1120         req->flags &= ~REQ_F_WORK_INITIALIZED;
1121
1122         if (req->work.mm) {
1123                 mmdrop(req->work.mm);
1124                 req->work.mm = NULL;
1125         }
1126         if (req->work.creds) {
1127                 put_cred(req->work.creds);
1128                 req->work.creds = NULL;
1129         }
1130         if (req->work.fs) {
1131                 struct fs_struct *fs = req->work.fs;
1132
1133                 if (req->flags & REQ_F_COMP_LOCKED)
1134                         return true;
1135
1136                 spin_lock(&req->work.fs->lock);
1137                 if (--fs->users)
1138                         fs = NULL;
1139                 spin_unlock(&req->work.fs->lock);
1140                 if (fs)
1141                         free_fs_struct(fs);
1142                 req->work.fs = NULL;
1143         }
1144
1145         return false;
1146 }
1147
1148 static void io_prep_async_work(struct io_kiocb *req)
1149 {
1150         const struct io_op_def *def = &io_op_defs[req->opcode];
1151
1152         io_req_init_async(req);
1153
1154         if (req->flags & REQ_F_ISREG) {
1155                 if (def->hash_reg_file)
1156                         io_wq_hash_work(&req->work, file_inode(req->file));
1157         } else {
1158                 if (def->unbound_nonreg_file)
1159                         req->work.flags |= IO_WQ_WORK_UNBOUND;
1160         }
1161         if (!req->work.mm && def->needs_mm) {
1162                 mmgrab(current->mm);
1163                 req->work.mm = current->mm;
1164         }
1165         if (!req->work.creds)
1166                 req->work.creds = get_current_cred();
1167         if (!req->work.fs && def->needs_fs) {
1168                 spin_lock(&current->fs->lock);
1169                 if (!current->fs->in_exec) {
1170                         req->work.fs = current->fs;
1171                         req->work.fs->users++;
1172                 } else {
1173                         req->work.flags |= IO_WQ_WORK_CANCEL;
1174                 }
1175                 spin_unlock(&current->fs->lock);
1176         }
1177         if (def->needs_fsize)
1178                 req->work.fsize = rlimit(RLIMIT_FSIZE);
1179         else
1180                 req->work.fsize = RLIM_INFINITY;
1181 }
1182
1183 static void io_prep_async_link(struct io_kiocb *req)
1184 {
1185         struct io_kiocb *cur;
1186
1187         io_prep_async_work(req);
1188         if (req->flags & REQ_F_LINK_HEAD)
1189                 list_for_each_entry(cur, &req->link_list, link_list)
1190                         io_prep_async_work(cur);
1191 }
1192
1193 static struct io_kiocb *__io_queue_async_work(struct io_kiocb *req)
1194 {
1195         struct io_ring_ctx *ctx = req->ctx;
1196         struct io_kiocb *link = io_prep_linked_timeout(req);
1197
1198         trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
1199                                         &req->work, req->flags);
1200         io_wq_enqueue(ctx->io_wq, &req->work);
1201         return link;
1202 }
1203
1204 static void io_queue_async_work(struct io_kiocb *req)
1205 {
1206         struct io_kiocb *link;
1207
1208         /* init ->work of the whole link before punting */
1209         io_prep_async_link(req);
1210         link = __io_queue_async_work(req);
1211
1212         if (link)
1213                 io_queue_linked_timeout(link);
1214 }
1215
1216 static void io_kill_timeout(struct io_kiocb *req)
1217 {
1218         int ret;
1219
1220         ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
1221         if (ret != -1) {
1222                 atomic_set(&req->ctx->cq_timeouts,
1223                         atomic_read(&req->ctx->cq_timeouts) + 1);
1224                 list_del_init(&req->timeout.list);
1225                 req->flags |= REQ_F_COMP_LOCKED;
1226                 io_cqring_fill_event(req, 0);
1227                 io_put_req(req);
1228         }
1229 }
1230
1231 static void io_kill_timeouts(struct io_ring_ctx *ctx)
1232 {
1233         struct io_kiocb *req, *tmp;
1234
1235         spin_lock_irq(&ctx->completion_lock);
1236         list_for_each_entry_safe(req, tmp, &ctx->timeout_list, timeout.list)
1237                 io_kill_timeout(req);
1238         spin_unlock_irq(&ctx->completion_lock);
1239 }
1240
1241 static void __io_queue_deferred(struct io_ring_ctx *ctx)
1242 {
1243         do {
1244                 struct io_defer_entry *de = list_first_entry(&ctx->defer_list,
1245                                                 struct io_defer_entry, list);
1246                 struct io_kiocb *link;
1247
1248                 if (req_need_defer(de->req, de->seq))
1249                         break;
1250                 list_del_init(&de->list);
1251                 /* punt-init is done before queueing for defer */
1252                 link = __io_queue_async_work(de->req);
1253                 if (link) {
1254                         __io_queue_linked_timeout(link);
1255                         /* drop submission reference */
1256                         link->flags |= REQ_F_COMP_LOCKED;
1257                         io_put_req(link);
1258                 }
1259                 kfree(de);
1260         } while (!list_empty(&ctx->defer_list));
1261 }
1262
1263 static void io_flush_timeouts(struct io_ring_ctx *ctx)
1264 {
1265         while (!list_empty(&ctx->timeout_list)) {
1266                 struct io_kiocb *req = list_first_entry(&ctx->timeout_list,
1267                                                 struct io_kiocb, timeout.list);
1268
1269                 if (io_is_timeout_noseq(req))
1270                         break;
1271                 if (req->timeout.target_seq != ctx->cached_cq_tail
1272                                         - atomic_read(&ctx->cq_timeouts))
1273                         break;
1274
1275                 list_del_init(&req->timeout.list);
1276                 io_kill_timeout(req);
1277         }
1278 }
1279
1280 static void io_commit_cqring(struct io_ring_ctx *ctx)
1281 {
1282         io_flush_timeouts(ctx);
1283         __io_commit_cqring(ctx);
1284
1285         if (unlikely(!list_empty(&ctx->defer_list)))
1286                 __io_queue_deferred(ctx);
1287 }
1288
1289 static struct io_uring_cqe *io_get_cqring(struct io_ring_ctx *ctx)
1290 {
1291         struct io_rings *rings = ctx->rings;
1292         unsigned tail;
1293
1294         tail = ctx->cached_cq_tail;
1295         /*
1296          * writes to the cq entry need to come after reading head; the
1297          * control dependency is enough as we're using WRITE_ONCE to
1298          * fill the cq entry
1299          */
1300         if (tail - READ_ONCE(rings->cq.head) == rings->cq_ring_entries)
1301                 return NULL;
1302
1303         ctx->cached_cq_tail++;
1304         return &rings->cqes[tail & ctx->cq_mask];
1305 }
1306
1307 static inline bool io_should_trigger_evfd(struct io_ring_ctx *ctx)
1308 {
1309         if (!ctx->cq_ev_fd)
1310                 return false;
1311         if (READ_ONCE(ctx->rings->cq_flags) & IORING_CQ_EVENTFD_DISABLED)
1312                 return false;
1313         if (!ctx->eventfd_async)
1314                 return true;
1315         return io_wq_current_is_worker();
1316 }
1317
1318 static void io_cqring_ev_posted(struct io_ring_ctx *ctx)
1319 {
1320         if (waitqueue_active(&ctx->wait))
1321                 wake_up(&ctx->wait);
1322         if (waitqueue_active(&ctx->sqo_wait))
1323                 wake_up(&ctx->sqo_wait);
1324         if (io_should_trigger_evfd(ctx))
1325                 eventfd_signal(ctx->cq_ev_fd, 1);
1326 }
1327
1328 static void io_cqring_mark_overflow(struct io_ring_ctx *ctx)
1329 {
1330         if (list_empty(&ctx->cq_overflow_list)) {
1331                 clear_bit(0, &ctx->sq_check_overflow);
1332                 clear_bit(0, &ctx->cq_check_overflow);
1333                 ctx->rings->sq_flags &= ~IORING_SQ_CQ_OVERFLOW;
1334         }
1335 }
1336
1337 /* Returns true if there are no backlogged entries after the flush */
1338 static bool io_cqring_overflow_flush(struct io_ring_ctx *ctx, bool force)
1339 {
1340         struct io_rings *rings = ctx->rings;
1341         struct io_uring_cqe *cqe;
1342         struct io_kiocb *req;
1343         unsigned long flags;
1344         LIST_HEAD(list);
1345
1346         if (!force) {
1347                 if (list_empty_careful(&ctx->cq_overflow_list))
1348                         return true;
1349                 if ((ctx->cached_cq_tail - READ_ONCE(rings->cq.head) ==
1350                     rings->cq_ring_entries))
1351                         return false;
1352         }
1353
1354         spin_lock_irqsave(&ctx->completion_lock, flags);
1355
1356         /* if force is set, the ring is going away. always drop after that */
1357         if (force)
1358                 ctx->cq_overflow_flushed = 1;
1359
1360         cqe = NULL;
1361         while (!list_empty(&ctx->cq_overflow_list)) {
1362                 cqe = io_get_cqring(ctx);
1363                 if (!cqe && !force)
1364                         break;
1365
1366                 req = list_first_entry(&ctx->cq_overflow_list, struct io_kiocb,
1367                                                 compl.list);
1368                 list_move(&req->compl.list, &list);
1369                 req->flags &= ~REQ_F_OVERFLOW;
1370                 if (cqe) {
1371                         WRITE_ONCE(cqe->user_data, req->user_data);
1372                         WRITE_ONCE(cqe->res, req->result);
1373                         WRITE_ONCE(cqe->flags, req->compl.cflags);
1374                 } else {
1375                         WRITE_ONCE(ctx->rings->cq_overflow,
1376                                 atomic_inc_return(&ctx->cached_cq_overflow));
1377                 }
1378         }
1379
1380         io_commit_cqring(ctx);
1381         io_cqring_mark_overflow(ctx);
1382
1383         spin_unlock_irqrestore(&ctx->completion_lock, flags);
1384         io_cqring_ev_posted(ctx);
1385
1386         while (!list_empty(&list)) {
1387                 req = list_first_entry(&list, struct io_kiocb, compl.list);
1388                 list_del(&req->compl.list);
1389                 io_put_req(req);
1390         }
1391
1392         return cqe != NULL;
1393 }
1394
1395 static void __io_cqring_fill_event(struct io_kiocb *req, long res, long cflags)
1396 {
1397         struct io_ring_ctx *ctx = req->ctx;
1398         struct io_uring_cqe *cqe;
1399
1400         trace_io_uring_complete(ctx, req->user_data, res);
1401
1402         /*
1403          * If we can't get a cq entry, userspace overflowed the
1404          * submission (by quite a lot). Increment the overflow count in
1405          * the ring.
1406          */
1407         cqe = io_get_cqring(ctx);
1408         if (likely(cqe)) {
1409                 WRITE_ONCE(cqe->user_data, req->user_data);
1410                 WRITE_ONCE(cqe->res, res);
1411                 WRITE_ONCE(cqe->flags, cflags);
1412         } else if (ctx->cq_overflow_flushed) {
1413                 WRITE_ONCE(ctx->rings->cq_overflow,
1414                                 atomic_inc_return(&ctx->cached_cq_overflow));
1415         } else {
1416                 if (list_empty(&ctx->cq_overflow_list)) {
1417                         set_bit(0, &ctx->sq_check_overflow);
1418                         set_bit(0, &ctx->cq_check_overflow);
1419                         ctx->rings->sq_flags |= IORING_SQ_CQ_OVERFLOW;
1420                 }
1421                 io_clean_op(req);
1422                 req->flags |= REQ_F_OVERFLOW;
1423                 req->result = res;
1424                 req->compl.cflags = cflags;
1425                 refcount_inc(&req->refs);
1426                 list_add_tail(&req->compl.list, &ctx->cq_overflow_list);
1427         }
1428 }
1429
1430 static void io_cqring_fill_event(struct io_kiocb *req, long res)
1431 {
1432         __io_cqring_fill_event(req, res, 0);
1433 }
1434
1435 static void io_cqring_add_event(struct io_kiocb *req, long res, long cflags)
1436 {
1437         struct io_ring_ctx *ctx = req->ctx;
1438         unsigned long flags;
1439
1440         spin_lock_irqsave(&ctx->completion_lock, flags);
1441         __io_cqring_fill_event(req, res, cflags);
1442         io_commit_cqring(ctx);
1443         spin_unlock_irqrestore(&ctx->completion_lock, flags);
1444
1445         io_cqring_ev_posted(ctx);
1446 }
1447
1448 static void io_submit_flush_completions(struct io_comp_state *cs)
1449 {
1450         struct io_ring_ctx *ctx = cs->ctx;
1451
1452         spin_lock_irq(&ctx->completion_lock);
1453         while (!list_empty(&cs->list)) {
1454                 struct io_kiocb *req;
1455
1456                 req = list_first_entry(&cs->list, struct io_kiocb, compl.list);
1457                 list_del(&req->compl.list);
1458                 __io_cqring_fill_event(req, req->result, req->compl.cflags);
1459                 if (!(req->flags & REQ_F_LINK_HEAD)) {
1460                         req->flags |= REQ_F_COMP_LOCKED;
1461                         io_put_req(req);
1462                 } else {
1463                         spin_unlock_irq(&ctx->completion_lock);
1464                         io_put_req(req);
1465                         spin_lock_irq(&ctx->completion_lock);
1466                 }
1467         }
1468         io_commit_cqring(ctx);
1469         spin_unlock_irq(&ctx->completion_lock);
1470
1471         io_cqring_ev_posted(ctx);
1472         cs->nr = 0;
1473 }
1474
1475 static void __io_req_complete(struct io_kiocb *req, long res, unsigned cflags,
1476                               struct io_comp_state *cs)
1477 {
1478         if (!cs) {
1479                 io_cqring_add_event(req, res, cflags);
1480                 io_put_req(req);
1481         } else {
1482                 io_clean_op(req);
1483                 req->result = res;
1484                 req->compl.cflags = cflags;
1485                 list_add_tail(&req->compl.list, &cs->list);
1486                 if (++cs->nr >= 32)
1487                         io_submit_flush_completions(cs);
1488         }
1489 }
1490
1491 static void io_req_complete(struct io_kiocb *req, long res)
1492 {
1493         __io_req_complete(req, res, 0, NULL);
1494 }
1495
1496 static inline bool io_is_fallback_req(struct io_kiocb *req)
1497 {
1498         return req == (struct io_kiocb *)
1499                         ((unsigned long) req->ctx->fallback_req & ~1UL);
1500 }
1501
1502 static struct io_kiocb *io_get_fallback_req(struct io_ring_ctx *ctx)
1503 {
1504         struct io_kiocb *req;
1505
1506         req = ctx->fallback_req;
1507         if (!test_and_set_bit_lock(0, (unsigned long *) &ctx->fallback_req))
1508                 return req;
1509
1510         return NULL;
1511 }
1512
1513 static struct io_kiocb *io_alloc_req(struct io_ring_ctx *ctx,
1514                                      struct io_submit_state *state)
1515 {
1516         gfp_t gfp = GFP_KERNEL | __GFP_NOWARN;
1517         struct io_kiocb *req;
1518
1519         if (!state->free_reqs) {
1520                 size_t sz;
1521                 int ret;
1522
1523                 sz = min_t(size_t, state->ios_left, ARRAY_SIZE(state->reqs));
1524                 ret = kmem_cache_alloc_bulk(req_cachep, gfp, sz, state->reqs);
1525
1526                 /*
1527                  * Bulk alloc is all-or-nothing. If we fail to get a batch,
1528                  * retry single alloc to be on the safe side.
1529                  */
1530                 if (unlikely(ret <= 0)) {
1531                         state->reqs[0] = kmem_cache_alloc(req_cachep, gfp);
1532                         if (!state->reqs[0])
1533                                 goto fallback;
1534                         ret = 1;
1535                 }
1536                 state->free_reqs = ret - 1;
1537                 req = state->reqs[ret - 1];
1538         } else {
1539                 state->free_reqs--;
1540                 req = state->reqs[state->free_reqs];
1541         }
1542
1543         return req;
1544 fallback:
1545         return io_get_fallback_req(ctx);
1546 }
1547
1548 static inline void io_put_file(struct io_kiocb *req, struct file *file,
1549                           bool fixed)
1550 {
1551         if (fixed)
1552                 percpu_ref_put(req->fixed_file_refs);
1553         else
1554                 fput(file);
1555 }
1556
1557 static bool io_dismantle_req(struct io_kiocb *req)
1558 {
1559         io_clean_op(req);
1560
1561         if (req->io)
1562                 kfree(req->io);
1563         if (req->file)
1564                 io_put_file(req, req->file, (req->flags & REQ_F_FIXED_FILE));
1565
1566         if (req->flags & REQ_F_INFLIGHT) {
1567                 struct io_ring_ctx *ctx = req->ctx;
1568                 unsigned long flags;
1569
1570                 spin_lock_irqsave(&ctx->inflight_lock, flags);
1571                 list_del(&req->inflight_entry);
1572                 if (waitqueue_active(&ctx->inflight_wait))
1573                         wake_up(&ctx->inflight_wait);
1574                 spin_unlock_irqrestore(&ctx->inflight_lock, flags);
1575         }
1576
1577         return io_req_clean_work(req);
1578 }
1579
1580 static void __io_free_req_finish(struct io_kiocb *req)
1581 {
1582         struct io_ring_ctx *ctx = req->ctx;
1583
1584         __io_put_req_task(req);
1585         if (likely(!io_is_fallback_req(req)))
1586                 kmem_cache_free(req_cachep, req);
1587         else
1588                 clear_bit_unlock(0, (unsigned long *) &ctx->fallback_req);
1589         percpu_ref_put(&ctx->refs);
1590 }
1591
1592 static void io_req_task_file_table_put(struct callback_head *cb)
1593 {
1594         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
1595         struct fs_struct *fs = req->work.fs;
1596
1597         spin_lock(&req->work.fs->lock);
1598         if (--fs->users)
1599                 fs = NULL;
1600         spin_unlock(&req->work.fs->lock);
1601         if (fs)
1602                 free_fs_struct(fs);
1603         req->work.fs = NULL;
1604         __io_free_req_finish(req);
1605 }
1606
1607 static void __io_free_req(struct io_kiocb *req)
1608 {
1609         if (!io_dismantle_req(req)) {
1610                 __io_free_req_finish(req);
1611         } else {
1612                 int ret;
1613
1614                 init_task_work(&req->task_work, io_req_task_file_table_put);
1615                 ret = task_work_add(req->task, &req->task_work, TWA_RESUME);
1616                 if (unlikely(ret)) {
1617                         struct task_struct *tsk;
1618
1619                         tsk = io_wq_get_task(req->ctx->io_wq);
1620                         task_work_add(tsk, &req->task_work, 0);
1621                 }
1622         }
1623 }
1624
1625 static bool io_link_cancel_timeout(struct io_kiocb *req)
1626 {
1627         struct io_ring_ctx *ctx = req->ctx;
1628         int ret;
1629
1630         ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
1631         if (ret != -1) {
1632                 io_cqring_fill_event(req, -ECANCELED);
1633                 io_commit_cqring(ctx);
1634                 req->flags &= ~REQ_F_LINK_HEAD;
1635                 io_put_req(req);
1636                 return true;
1637         }
1638
1639         return false;
1640 }
1641
1642 static bool __io_kill_linked_timeout(struct io_kiocb *req)
1643 {
1644         struct io_kiocb *link;
1645         bool wake_ev;
1646
1647         if (list_empty(&req->link_list))
1648                 return false;
1649         link = list_first_entry(&req->link_list, struct io_kiocb, link_list);
1650         if (link->opcode != IORING_OP_LINK_TIMEOUT)
1651                 return false;
1652
1653         list_del_init(&link->link_list);
1654         link->flags |= REQ_F_COMP_LOCKED;
1655         wake_ev = io_link_cancel_timeout(link);
1656         req->flags &= ~REQ_F_LINK_TIMEOUT;
1657         return wake_ev;
1658 }
1659
1660 static void io_kill_linked_timeout(struct io_kiocb *req)
1661 {
1662         struct io_ring_ctx *ctx = req->ctx;
1663         bool wake_ev;
1664
1665         if (!(req->flags & REQ_F_COMP_LOCKED)) {
1666                 unsigned long flags;
1667
1668                 spin_lock_irqsave(&ctx->completion_lock, flags);
1669                 wake_ev = __io_kill_linked_timeout(req);
1670                 spin_unlock_irqrestore(&ctx->completion_lock, flags);
1671         } else {
1672                 wake_ev = __io_kill_linked_timeout(req);
1673         }
1674
1675         if (wake_ev)
1676                 io_cqring_ev_posted(ctx);
1677 }
1678
1679 static struct io_kiocb *io_req_link_next(struct io_kiocb *req)
1680 {
1681         struct io_kiocb *nxt;
1682
1683         /*
1684          * The list should never be empty when we are called here. But could
1685          * potentially happen if the chain is messed up, check to be on the
1686          * safe side.
1687          */
1688         if (unlikely(list_empty(&req->link_list)))
1689                 return NULL;
1690
1691         nxt = list_first_entry(&req->link_list, struct io_kiocb, link_list);
1692         list_del_init(&req->link_list);
1693         if (!list_empty(&nxt->link_list))
1694                 nxt->flags |= REQ_F_LINK_HEAD;
1695         return nxt;
1696 }
1697
1698 /*
1699  * Called if REQ_F_LINK_HEAD is set, and we fail the head request
1700  */
1701 static void __io_fail_links(struct io_kiocb *req)
1702 {
1703         struct io_ring_ctx *ctx = req->ctx;
1704
1705         while (!list_empty(&req->link_list)) {
1706                 struct io_kiocb *link = list_first_entry(&req->link_list,
1707                                                 struct io_kiocb, link_list);
1708
1709                 list_del_init(&link->link_list);
1710                 trace_io_uring_fail_link(req, link);
1711
1712                 io_cqring_fill_event(link, -ECANCELED);
1713                 link->flags |= REQ_F_COMP_LOCKED;
1714                 __io_double_put_req(link);
1715                 req->flags &= ~REQ_F_LINK_TIMEOUT;
1716         }
1717
1718         io_commit_cqring(ctx);
1719         io_cqring_ev_posted(ctx);
1720 }
1721
1722 static void io_fail_links(struct io_kiocb *req)
1723 {
1724         struct io_ring_ctx *ctx = req->ctx;
1725
1726         if (!(req->flags & REQ_F_COMP_LOCKED)) {
1727                 unsigned long flags;
1728
1729                 spin_lock_irqsave(&ctx->completion_lock, flags);
1730                 __io_fail_links(req);
1731                 spin_unlock_irqrestore(&ctx->completion_lock, flags);
1732         } else {
1733                 __io_fail_links(req);
1734         }
1735
1736         io_cqring_ev_posted(ctx);
1737 }
1738
1739 static struct io_kiocb *__io_req_find_next(struct io_kiocb *req)
1740 {
1741         req->flags &= ~REQ_F_LINK_HEAD;
1742         if (req->flags & REQ_F_LINK_TIMEOUT)
1743                 io_kill_linked_timeout(req);
1744
1745         /*
1746          * If LINK is set, we have dependent requests in this chain. If we
1747          * didn't fail this request, queue the first one up, moving any other
1748          * dependencies to the next request. In case of failure, fail the rest
1749          * of the chain.
1750          */
1751         if (likely(!(req->flags & REQ_F_FAIL_LINK)))
1752                 return io_req_link_next(req);
1753         io_fail_links(req);
1754         return NULL;
1755 }
1756
1757 static struct io_kiocb *io_req_find_next(struct io_kiocb *req)
1758 {
1759         if (likely(!(req->flags & REQ_F_LINK_HEAD)))
1760                 return NULL;
1761         return __io_req_find_next(req);
1762 }
1763
1764 static int io_req_task_work_add(struct io_kiocb *req, struct callback_head *cb)
1765 {
1766         struct task_struct *tsk = req->task;
1767         struct io_ring_ctx *ctx = req->ctx;
1768         int ret, notify;
1769
1770         /*
1771          * SQPOLL kernel thread doesn't need notification, just a wakeup. For
1772          * all other cases, use TWA_SIGNAL unconditionally to ensure we're
1773          * processing task_work. There's no reliable way to tell if TWA_RESUME
1774          * will do the job.
1775          */
1776         notify = 0;
1777         if (!(ctx->flags & IORING_SETUP_SQPOLL))
1778                 notify = TWA_SIGNAL;
1779
1780         ret = task_work_add(tsk, cb, notify);
1781         if (!ret)
1782                 wake_up_process(tsk);
1783
1784         return ret;
1785 }
1786
1787 static void __io_req_task_cancel(struct io_kiocb *req, int error)
1788 {
1789         struct io_ring_ctx *ctx = req->ctx;
1790
1791         spin_lock_irq(&ctx->completion_lock);
1792         io_cqring_fill_event(req, error);
1793         io_commit_cqring(ctx);
1794         spin_unlock_irq(&ctx->completion_lock);
1795
1796         io_cqring_ev_posted(ctx);
1797         req_set_fail_links(req);
1798         io_double_put_req(req);
1799 }
1800
1801 static void io_req_task_cancel(struct callback_head *cb)
1802 {
1803         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
1804
1805         __io_req_task_cancel(req, -ECANCELED);
1806 }
1807
1808 static void __io_req_task_submit(struct io_kiocb *req)
1809 {
1810         struct io_ring_ctx *ctx = req->ctx;
1811
1812         if (!__io_sq_thread_acquire_mm(ctx)) {
1813                 mutex_lock(&ctx->uring_lock);
1814                 __io_queue_sqe(req, NULL, NULL);
1815                 mutex_unlock(&ctx->uring_lock);
1816         } else {
1817                 __io_req_task_cancel(req, -EFAULT);
1818         }
1819 }
1820
1821 static void io_req_task_submit(struct callback_head *cb)
1822 {
1823         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
1824         struct io_ring_ctx *ctx = req->ctx;
1825
1826         __io_req_task_submit(req);
1827         percpu_ref_put(&ctx->refs);
1828 }
1829
1830 static void io_req_task_queue(struct io_kiocb *req)
1831 {
1832         int ret;
1833
1834         init_task_work(&req->task_work, io_req_task_submit);
1835         percpu_ref_get(&req->ctx->refs);
1836
1837         ret = io_req_task_work_add(req, &req->task_work);
1838         if (unlikely(ret)) {
1839                 struct task_struct *tsk;
1840
1841                 init_task_work(&req->task_work, io_req_task_cancel);
1842                 tsk = io_wq_get_task(req->ctx->io_wq);
1843                 task_work_add(tsk, &req->task_work, 0);
1844                 wake_up_process(tsk);
1845         }
1846 }
1847
1848 static void io_queue_next(struct io_kiocb *req)
1849 {
1850         struct io_kiocb *nxt = io_req_find_next(req);
1851
1852         if (nxt)
1853                 io_req_task_queue(nxt);
1854 }
1855
1856 static void io_free_req(struct io_kiocb *req)
1857 {
1858         io_queue_next(req);
1859         __io_free_req(req);
1860 }
1861
1862 struct req_batch {
1863         void *reqs[IO_IOPOLL_BATCH];
1864         int to_free;
1865
1866         struct task_struct      *task;
1867         int                     task_refs;
1868 };
1869
1870 static inline void io_init_req_batch(struct req_batch *rb)
1871 {
1872         rb->to_free = 0;
1873         rb->task_refs = 0;
1874         rb->task = NULL;
1875 }
1876
1877 static void __io_req_free_batch_flush(struct io_ring_ctx *ctx,
1878                                       struct req_batch *rb)
1879 {
1880         kmem_cache_free_bulk(req_cachep, rb->to_free, rb->reqs);
1881         percpu_ref_put_many(&ctx->refs, rb->to_free);
1882         rb->to_free = 0;
1883 }
1884
1885 static void io_req_free_batch_finish(struct io_ring_ctx *ctx,
1886                                      struct req_batch *rb)
1887 {
1888         if (rb->to_free)
1889                 __io_req_free_batch_flush(ctx, rb);
1890         if (rb->task) {
1891                 put_task_struct_many(rb->task, rb->task_refs);
1892                 rb->task = NULL;
1893         }
1894 }
1895
1896 static void io_req_free_batch(struct req_batch *rb, struct io_kiocb *req)
1897 {
1898         if (unlikely(io_is_fallback_req(req))) {
1899                 io_free_req(req);
1900                 return;
1901         }
1902         if (req->flags & REQ_F_LINK_HEAD)
1903                 io_queue_next(req);
1904
1905         if (req->flags & REQ_F_TASK_PINNED) {
1906                 if (req->task != rb->task) {
1907                         if (rb->task)
1908                                 put_task_struct_many(rb->task, rb->task_refs);
1909                         rb->task = req->task;
1910                         rb->task_refs = 0;
1911                 }
1912                 rb->task_refs++;
1913                 req->flags &= ~REQ_F_TASK_PINNED;
1914         }
1915
1916         WARN_ON_ONCE(io_dismantle_req(req));
1917         rb->reqs[rb->to_free++] = req;
1918         if (unlikely(rb->to_free == ARRAY_SIZE(rb->reqs)))
1919                 __io_req_free_batch_flush(req->ctx, rb);
1920 }
1921
1922 /*
1923  * Drop reference to request, return next in chain (if there is one) if this
1924  * was the last reference to this request.
1925  */
1926 static struct io_kiocb *io_put_req_find_next(struct io_kiocb *req)
1927 {
1928         struct io_kiocb *nxt = NULL;
1929
1930         if (refcount_dec_and_test(&req->refs)) {
1931                 nxt = io_req_find_next(req);
1932                 __io_free_req(req);
1933         }
1934         return nxt;
1935 }
1936
1937 static void io_put_req(struct io_kiocb *req)
1938 {
1939         if (refcount_dec_and_test(&req->refs))
1940                 io_free_req(req);
1941 }
1942
1943 static struct io_wq_work *io_steal_work(struct io_kiocb *req)
1944 {
1945         struct io_kiocb *nxt;
1946
1947         /*
1948          * A ref is owned by io-wq in which context we're. So, if that's the
1949          * last one, it's safe to steal next work. False negatives are Ok,
1950          * it just will be re-punted async in io_put_work()
1951          */
1952         if (refcount_read(&req->refs) != 1)
1953                 return NULL;
1954
1955         nxt = io_req_find_next(req);
1956         return nxt ? &nxt->work : NULL;
1957 }
1958
1959 /*
1960  * Must only be used if we don't need to care about links, usually from
1961  * within the completion handling itself.
1962  */
1963 static void __io_double_put_req(struct io_kiocb *req)
1964 {
1965         /* drop both submit and complete references */
1966         if (refcount_sub_and_test(2, &req->refs))
1967                 __io_free_req(req);
1968 }
1969
1970 static void io_double_put_req(struct io_kiocb *req)
1971 {
1972         /* drop both submit and complete references */
1973         if (refcount_sub_and_test(2, &req->refs))
1974                 io_free_req(req);
1975 }
1976
1977 static unsigned io_cqring_events(struct io_ring_ctx *ctx, bool noflush)
1978 {
1979         struct io_rings *rings = ctx->rings;
1980
1981         if (test_bit(0, &ctx->cq_check_overflow)) {
1982                 /*
1983                  * noflush == true is from the waitqueue handler, just ensure
1984                  * we wake up the task, and the next invocation will flush the
1985                  * entries. We cannot safely to it from here.
1986                  */
1987                 if (noflush && !list_empty(&ctx->cq_overflow_list))
1988                         return -1U;
1989
1990                 io_cqring_overflow_flush(ctx, false);
1991         }
1992
1993         /* See comment at the top of this file */
1994         smp_rmb();
1995         return ctx->cached_cq_tail - READ_ONCE(rings->cq.head);
1996 }
1997
1998 static inline unsigned int io_sqring_entries(struct io_ring_ctx *ctx)
1999 {
2000         struct io_rings *rings = ctx->rings;
2001
2002         /* make sure SQ entry isn't read before tail */
2003         return smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;
2004 }
2005
2006 static unsigned int io_put_kbuf(struct io_kiocb *req, struct io_buffer *kbuf)
2007 {
2008         unsigned int cflags;
2009
2010         cflags = kbuf->bid << IORING_CQE_BUFFER_SHIFT;
2011         cflags |= IORING_CQE_F_BUFFER;
2012         req->flags &= ~REQ_F_BUFFER_SELECTED;
2013         kfree(kbuf);
2014         return cflags;
2015 }
2016
2017 static inline unsigned int io_put_rw_kbuf(struct io_kiocb *req)
2018 {
2019         struct io_buffer *kbuf;
2020
2021         kbuf = (struct io_buffer *) (unsigned long) req->rw.addr;
2022         return io_put_kbuf(req, kbuf);
2023 }
2024
2025 static inline bool io_run_task_work(void)
2026 {
2027         if (current->task_works) {
2028                 __set_current_state(TASK_RUNNING);
2029                 task_work_run();
2030                 return true;
2031         }
2032
2033         return false;
2034 }
2035
2036 static void io_iopoll_queue(struct list_head *again)
2037 {
2038         struct io_kiocb *req;
2039
2040         do {
2041                 req = list_first_entry(again, struct io_kiocb, inflight_entry);
2042                 list_del(&req->inflight_entry);
2043                 __io_complete_rw(req, -EAGAIN, 0, NULL);
2044         } while (!list_empty(again));
2045 }
2046
2047 /*
2048  * Find and free completed poll iocbs
2049  */
2050 static void io_iopoll_complete(struct io_ring_ctx *ctx, unsigned int *nr_events,
2051                                struct list_head *done)
2052 {
2053         struct req_batch rb;
2054         struct io_kiocb *req;
2055         LIST_HEAD(again);
2056
2057         /* order with ->result store in io_complete_rw_iopoll() */
2058         smp_rmb();
2059
2060         io_init_req_batch(&rb);
2061         while (!list_empty(done)) {
2062                 int cflags = 0;
2063
2064                 req = list_first_entry(done, struct io_kiocb, inflight_entry);
2065                 if (READ_ONCE(req->result) == -EAGAIN) {
2066                         req->iopoll_completed = 0;
2067                         list_move_tail(&req->inflight_entry, &again);
2068                         continue;
2069                 }
2070                 list_del(&req->inflight_entry);
2071
2072                 if (req->flags & REQ_F_BUFFER_SELECTED)
2073                         cflags = io_put_rw_kbuf(req);
2074
2075                 __io_cqring_fill_event(req, req->result, cflags);
2076                 (*nr_events)++;
2077
2078                 if (refcount_dec_and_test(&req->refs))
2079                         io_req_free_batch(&rb, req);
2080         }
2081
2082         io_commit_cqring(ctx);
2083         if (ctx->flags & IORING_SETUP_SQPOLL)
2084                 io_cqring_ev_posted(ctx);
2085         io_req_free_batch_finish(ctx, &rb);
2086
2087         if (!list_empty(&again))
2088                 io_iopoll_queue(&again);
2089 }
2090
2091 static int io_do_iopoll(struct io_ring_ctx *ctx, unsigned int *nr_events,
2092                         long min)
2093 {
2094         struct io_kiocb *req, *tmp;
2095         LIST_HEAD(done);
2096         bool spin;
2097         int ret;
2098
2099         /*
2100          * Only spin for completions if we don't have multiple devices hanging
2101          * off our complete list, and we're under the requested amount.
2102          */
2103         spin = !ctx->poll_multi_file && *nr_events < min;
2104
2105         ret = 0;
2106         list_for_each_entry_safe(req, tmp, &ctx->iopoll_list, inflight_entry) {
2107                 struct kiocb *kiocb = &req->rw.kiocb;
2108
2109                 /*
2110                  * Move completed and retryable entries to our local lists.
2111                  * If we find a request that requires polling, break out
2112                  * and complete those lists first, if we have entries there.
2113                  */
2114                 if (READ_ONCE(req->iopoll_completed)) {
2115                         list_move_tail(&req->inflight_entry, &done);
2116                         continue;
2117                 }
2118                 if (!list_empty(&done))
2119                         break;
2120
2121                 ret = kiocb->ki_filp->f_op->iopoll(kiocb, spin);
2122                 if (ret < 0)
2123                         break;
2124
2125                 /* iopoll may have completed current req */
2126                 if (READ_ONCE(req->iopoll_completed))
2127                         list_move_tail(&req->inflight_entry, &done);
2128
2129                 if (ret && spin)
2130                         spin = false;
2131                 ret = 0;
2132         }
2133
2134         if (!list_empty(&done))
2135                 io_iopoll_complete(ctx, nr_events, &done);
2136
2137         return ret;
2138 }
2139
2140 /*
2141  * Poll for a minimum of 'min' events. Note that if min == 0 we consider that a
2142  * non-spinning poll check - we'll still enter the driver poll loop, but only
2143  * as a non-spinning completion check.
2144  */
2145 static int io_iopoll_getevents(struct io_ring_ctx *ctx, unsigned int *nr_events,
2146                                 long min)
2147 {
2148         while (!list_empty(&ctx->iopoll_list) && !need_resched()) {
2149                 int ret;
2150
2151                 ret = io_do_iopoll(ctx, nr_events, min);
2152                 if (ret < 0)
2153                         return ret;
2154                 if (*nr_events >= min)
2155                         return 0;
2156         }
2157
2158         return 1;
2159 }
2160
2161 /*
2162  * We can't just wait for polled events to come to us, we have to actively
2163  * find and complete them.
2164  */
2165 static void io_iopoll_try_reap_events(struct io_ring_ctx *ctx)
2166 {
2167         if (!(ctx->flags & IORING_SETUP_IOPOLL))
2168                 return;
2169
2170         mutex_lock(&ctx->uring_lock);
2171         while (!list_empty(&ctx->iopoll_list)) {
2172                 unsigned int nr_events = 0;
2173
2174                 io_do_iopoll(ctx, &nr_events, 0);
2175
2176                 /* let it sleep and repeat later if can't complete a request */
2177                 if (nr_events == 0)
2178                         break;
2179                 /*
2180                  * Ensure we allow local-to-the-cpu processing to take place,
2181                  * in this case we need to ensure that we reap all events.
2182                  * Also let task_work, etc. to progress by releasing the mutex
2183                  */
2184                 if (need_resched()) {
2185                         mutex_unlock(&ctx->uring_lock);
2186                         cond_resched();
2187                         mutex_lock(&ctx->uring_lock);
2188                 }
2189         }
2190         mutex_unlock(&ctx->uring_lock);
2191 }
2192
2193 static int io_iopoll_check(struct io_ring_ctx *ctx, long min)
2194 {
2195         unsigned int nr_events = 0;
2196         int iters = 0, ret = 0;
2197
2198         /*
2199          * We disallow the app entering submit/complete with polling, but we
2200          * still need to lock the ring to prevent racing with polled issue
2201          * that got punted to a workqueue.
2202          */
2203         mutex_lock(&ctx->uring_lock);
2204         do {
2205                 /*
2206                  * Don't enter poll loop if we already have events pending.
2207                  * If we do, we can potentially be spinning for commands that
2208                  * already triggered a CQE (eg in error).
2209                  */
2210                 if (io_cqring_events(ctx, false))
2211                         break;
2212
2213                 /*
2214                  * If a submit got punted to a workqueue, we can have the
2215                  * application entering polling for a command before it gets
2216                  * issued. That app will hold the uring_lock for the duration
2217                  * of the poll right here, so we need to take a breather every
2218                  * now and then to ensure that the issue has a chance to add
2219                  * the poll to the issued list. Otherwise we can spin here
2220                  * forever, while the workqueue is stuck trying to acquire the
2221                  * very same mutex.
2222                  */
2223                 if (!(++iters & 7)) {
2224                         mutex_unlock(&ctx->uring_lock);
2225                         io_run_task_work();
2226                         mutex_lock(&ctx->uring_lock);
2227                 }
2228
2229                 ret = io_iopoll_getevents(ctx, &nr_events, min);
2230                 if (ret <= 0)
2231                         break;
2232                 ret = 0;
2233         } while (min && !nr_events && !need_resched());
2234
2235         mutex_unlock(&ctx->uring_lock);
2236         return ret;
2237 }
2238
2239 static void kiocb_end_write(struct io_kiocb *req)
2240 {
2241         /*
2242          * Tell lockdep we inherited freeze protection from submission
2243          * thread.
2244          */
2245         if (req->flags & REQ_F_ISREG) {
2246                 struct inode *inode = file_inode(req->file);
2247
2248                 __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
2249         }
2250         file_end_write(req->file);
2251 }
2252
2253 static void io_complete_rw_common(struct kiocb *kiocb, long res,
2254                                   struct io_comp_state *cs)
2255 {
2256         struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
2257         int cflags = 0;
2258
2259         if (kiocb->ki_flags & IOCB_WRITE)
2260                 kiocb_end_write(req);
2261
2262         if (res != req->result)
2263                 req_set_fail_links(req);
2264         if (req->flags & REQ_F_BUFFER_SELECTED)
2265                 cflags = io_put_rw_kbuf(req);
2266         __io_req_complete(req, res, cflags, cs);
2267 }
2268
2269 #ifdef CONFIG_BLOCK
2270 static bool io_resubmit_prep(struct io_kiocb *req, int error)
2271 {
2272         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
2273         ssize_t ret = -ECANCELED;
2274         struct iov_iter iter;
2275         int rw;
2276
2277         if (error) {
2278                 ret = error;
2279                 goto end_req;
2280         }
2281
2282         switch (req->opcode) {
2283         case IORING_OP_READV:
2284         case IORING_OP_READ_FIXED:
2285         case IORING_OP_READ:
2286                 rw = READ;
2287                 break;
2288         case IORING_OP_WRITEV:
2289         case IORING_OP_WRITE_FIXED:
2290         case IORING_OP_WRITE:
2291                 rw = WRITE;
2292                 break;
2293         default:
2294                 printk_once(KERN_WARNING "io_uring: bad opcode in resubmit %d\n",
2295                                 req->opcode);
2296                 goto end_req;
2297         }
2298
2299         ret = io_import_iovec(rw, req, &iovec, &iter, false);
2300         if (ret < 0)
2301                 goto end_req;
2302         ret = io_setup_async_rw(req, ret, iovec, inline_vecs, &iter);
2303         if (!ret)
2304                 return true;
2305         kfree(iovec);
2306 end_req:
2307         req_set_fail_links(req);
2308         io_req_complete(req, ret);
2309         return false;
2310 }
2311
2312 static void io_rw_resubmit(struct callback_head *cb)
2313 {
2314         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
2315         struct io_ring_ctx *ctx = req->ctx;
2316         int err;
2317
2318         err = io_sq_thread_acquire_mm(ctx, req);
2319
2320         if (io_resubmit_prep(req, err)) {
2321                 refcount_inc(&req->refs);
2322                 io_queue_async_work(req);
2323         }
2324
2325         percpu_ref_put(&ctx->refs);
2326 }
2327 #endif
2328
2329 static bool io_rw_reissue(struct io_kiocb *req, long res)
2330 {
2331 #ifdef CONFIG_BLOCK
2332         int ret;
2333
2334         if ((res != -EAGAIN && res != -EOPNOTSUPP) || io_wq_current_is_worker())
2335                 return false;
2336
2337         init_task_work(&req->task_work, io_rw_resubmit);
2338         percpu_ref_get(&req->ctx->refs);
2339
2340         ret = io_req_task_work_add(req, &req->task_work);
2341         if (!ret)
2342                 return true;
2343 #endif
2344         return false;
2345 }
2346
2347 static void __io_complete_rw(struct io_kiocb *req, long res, long res2,
2348                              struct io_comp_state *cs)
2349 {
2350         if (!io_rw_reissue(req, res))
2351                 io_complete_rw_common(&req->rw.kiocb, res, cs);
2352 }
2353
2354 static void io_complete_rw(struct kiocb *kiocb, long res, long res2)
2355 {
2356         struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
2357
2358         __io_complete_rw(req, res, res2, NULL);
2359 }
2360
2361 static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2)
2362 {
2363         struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
2364
2365         if (kiocb->ki_flags & IOCB_WRITE)
2366                 kiocb_end_write(req);
2367
2368         if (res != -EAGAIN && res != req->result)
2369                 req_set_fail_links(req);
2370
2371         WRITE_ONCE(req->result, res);
2372         /* order with io_poll_complete() checking ->result */
2373         smp_wmb();
2374         WRITE_ONCE(req->iopoll_completed, 1);
2375 }
2376
2377 /*
2378  * After the iocb has been issued, it's safe to be found on the poll list.
2379  * Adding the kiocb to the list AFTER submission ensures that we don't
2380  * find it from a io_iopoll_getevents() thread before the issuer is done
2381  * accessing the kiocb cookie.
2382  */
2383 static void io_iopoll_req_issued(struct io_kiocb *req)
2384 {
2385         struct io_ring_ctx *ctx = req->ctx;
2386
2387         /*
2388          * Track whether we have multiple files in our lists. This will impact
2389          * how we do polling eventually, not spinning if we're on potentially
2390          * different devices.
2391          */
2392         if (list_empty(&ctx->iopoll_list)) {
2393                 ctx->poll_multi_file = false;
2394         } else if (!ctx->poll_multi_file) {
2395                 struct io_kiocb *list_req;
2396
2397                 list_req = list_first_entry(&ctx->iopoll_list, struct io_kiocb,
2398                                                 inflight_entry);
2399                 if (list_req->file != req->file)
2400                         ctx->poll_multi_file = true;
2401         }
2402
2403         /*
2404          * For fast devices, IO may have already completed. If it has, add
2405          * it to the front so we find it first.
2406          */
2407         if (READ_ONCE(req->iopoll_completed))
2408                 list_add(&req->inflight_entry, &ctx->iopoll_list);
2409         else
2410                 list_add_tail(&req->inflight_entry, &ctx->iopoll_list);
2411
2412         if ((ctx->flags & IORING_SETUP_SQPOLL) &&
2413             wq_has_sleeper(&ctx->sqo_wait))
2414                 wake_up(&ctx->sqo_wait);
2415 }
2416
2417 static void __io_state_file_put(struct io_submit_state *state)
2418 {
2419         if (state->has_refs)
2420                 fput_many(state->file, state->has_refs);
2421         state->file = NULL;
2422 }
2423
2424 static inline void io_state_file_put(struct io_submit_state *state)
2425 {
2426         if (state->file)
2427                 __io_state_file_put(state);
2428 }
2429
2430 /*
2431  * Get as many references to a file as we have IOs left in this submission,
2432  * assuming most submissions are for one file, or at least that each file
2433  * has more than one submission.
2434  */
2435 static struct file *__io_file_get(struct io_submit_state *state, int fd)
2436 {
2437         if (!state)
2438                 return fget(fd);
2439
2440         if (state->file) {
2441                 if (state->fd == fd) {
2442                         state->has_refs--;
2443                         state->ios_left--;
2444                         return state->file;
2445                 }
2446                 __io_state_file_put(state);
2447         }
2448         state->file = fget_many(fd, state->ios_left);
2449         if (!state->file)
2450                 return NULL;
2451
2452         state->fd = fd;
2453         state->ios_left--;
2454         state->has_refs = state->ios_left;
2455         return state->file;
2456 }
2457
2458 static bool io_bdev_nowait(struct block_device *bdev)
2459 {
2460 #ifdef CONFIG_BLOCK
2461         return !bdev || queue_is_mq(bdev_get_queue(bdev));
2462 #else
2463         return true;
2464 #endif
2465 }
2466
2467 /*
2468  * If we tracked the file through the SCM inflight mechanism, we could support
2469  * any file. For now, just ensure that anything potentially problematic is done
2470  * inline.
2471  */
2472 static bool io_file_supports_async(struct file *file, int rw)
2473 {
2474         umode_t mode = file_inode(file)->i_mode;
2475
2476         if (S_ISBLK(mode)) {
2477                 if (io_bdev_nowait(file->f_inode->i_bdev))
2478                         return true;
2479                 return false;
2480         }
2481         if (S_ISCHR(mode) || S_ISSOCK(mode))
2482                 return true;
2483         if (S_ISREG(mode)) {
2484                 if (io_bdev_nowait(file->f_inode->i_sb->s_bdev) &&
2485                     file->f_op != &io_uring_fops)
2486                         return true;
2487                 return false;
2488         }
2489
2490         /* any ->read/write should understand O_NONBLOCK */
2491         if (file->f_flags & O_NONBLOCK)
2492                 return true;
2493
2494         if (!(file->f_mode & FMODE_NOWAIT))
2495                 return false;
2496
2497         if (rw == READ)
2498                 return file->f_op->read_iter != NULL;
2499
2500         return file->f_op->write_iter != NULL;
2501 }
2502
2503 static int io_prep_rw(struct io_kiocb *req, const struct io_uring_sqe *sqe,
2504                       bool force_nonblock)
2505 {
2506         struct io_ring_ctx *ctx = req->ctx;
2507         struct kiocb *kiocb = &req->rw.kiocb;
2508         unsigned ioprio;
2509         int ret;
2510
2511         if (S_ISREG(file_inode(req->file)->i_mode))
2512                 req->flags |= REQ_F_ISREG;
2513
2514         kiocb->ki_pos = READ_ONCE(sqe->off);
2515         if (kiocb->ki_pos == -1 && !(req->file->f_mode & FMODE_STREAM)) {
2516                 req->flags |= REQ_F_CUR_POS;
2517                 kiocb->ki_pos = req->file->f_pos;
2518         }
2519         kiocb->ki_hint = ki_hint_validate(file_write_hint(kiocb->ki_filp));
2520         kiocb->ki_flags = iocb_flags(kiocb->ki_filp);
2521         ret = kiocb_set_rw_flags(kiocb, READ_ONCE(sqe->rw_flags));
2522         if (unlikely(ret))
2523                 return ret;
2524
2525         ioprio = READ_ONCE(sqe->ioprio);
2526         if (ioprio) {
2527                 ret = ioprio_check_cap(ioprio);
2528                 if (ret)
2529                         return ret;
2530
2531                 kiocb->ki_ioprio = ioprio;
2532         } else
2533                 kiocb->ki_ioprio = get_current_ioprio();
2534
2535         /* don't allow async punt if RWF_NOWAIT was requested */
2536         if (kiocb->ki_flags & IOCB_NOWAIT)
2537                 req->flags |= REQ_F_NOWAIT;
2538
2539         if (kiocb->ki_flags & IOCB_DIRECT)
2540                 io_get_req_task(req);
2541
2542         if (force_nonblock)
2543                 kiocb->ki_flags |= IOCB_NOWAIT;
2544
2545         if (ctx->flags & IORING_SETUP_IOPOLL) {
2546                 if (!(kiocb->ki_flags & IOCB_DIRECT) ||
2547                     !kiocb->ki_filp->f_op->iopoll)
2548                         return -EOPNOTSUPP;
2549
2550                 kiocb->ki_flags |= IOCB_HIPRI;
2551                 kiocb->ki_complete = io_complete_rw_iopoll;
2552                 req->iopoll_completed = 0;
2553                 io_get_req_task(req);
2554         } else {
2555                 if (kiocb->ki_flags & IOCB_HIPRI)
2556                         return -EINVAL;
2557                 kiocb->ki_complete = io_complete_rw;
2558         }
2559
2560         req->rw.addr = READ_ONCE(sqe->addr);
2561         req->rw.len = READ_ONCE(sqe->len);
2562         req->buf_index = READ_ONCE(sqe->buf_index);
2563         return 0;
2564 }
2565
2566 static inline void io_rw_done(struct kiocb *kiocb, ssize_t ret)
2567 {
2568         switch (ret) {
2569         case -EIOCBQUEUED:
2570                 break;
2571         case -ERESTARTSYS:
2572         case -ERESTARTNOINTR:
2573         case -ERESTARTNOHAND:
2574         case -ERESTART_RESTARTBLOCK:
2575                 /*
2576                  * We can't just restart the syscall, since previously
2577                  * submitted sqes may already be in progress. Just fail this
2578                  * IO with EINTR.
2579                  */
2580                 ret = -EINTR;
2581                 /* fall through */
2582         default:
2583                 kiocb->ki_complete(kiocb, ret, 0);
2584         }
2585 }
2586
2587 static void kiocb_done(struct kiocb *kiocb, ssize_t ret,
2588                        struct io_comp_state *cs)
2589 {
2590         struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
2591
2592         if (req->flags & REQ_F_CUR_POS)
2593                 req->file->f_pos = kiocb->ki_pos;
2594         if (ret >= 0 && kiocb->ki_complete == io_complete_rw)
2595                 __io_complete_rw(req, ret, 0, cs);
2596         else
2597                 io_rw_done(kiocb, ret);
2598 }
2599
2600 static ssize_t io_import_fixed(struct io_kiocb *req, int rw,
2601                                struct iov_iter *iter)
2602 {
2603         struct io_ring_ctx *ctx = req->ctx;
2604         size_t len = req->rw.len;
2605         struct io_mapped_ubuf *imu;
2606         u16 index, buf_index;
2607         size_t offset;
2608         u64 buf_addr;
2609
2610         /* attempt to use fixed buffers without having provided iovecs */
2611         if (unlikely(!ctx->user_bufs))
2612                 return -EFAULT;
2613
2614         buf_index = req->buf_index;
2615         if (unlikely(buf_index >= ctx->nr_user_bufs))
2616                 return -EFAULT;
2617
2618         index = array_index_nospec(buf_index, ctx->nr_user_bufs);
2619         imu = &ctx->user_bufs[index];
2620         buf_addr = req->rw.addr;
2621
2622         /* overflow */
2623         if (buf_addr + len < buf_addr)
2624                 return -EFAULT;
2625         /* not inside the mapped region */
2626         if (buf_addr < imu->ubuf || buf_addr + len > imu->ubuf + imu->len)
2627                 return -EFAULT;
2628
2629         /*
2630          * May not be a start of buffer, set size appropriately
2631          * and advance us to the beginning.
2632          */
2633         offset = buf_addr - imu->ubuf;
2634         iov_iter_bvec(iter, rw, imu->bvec, imu->nr_bvecs, offset + len);
2635
2636         if (offset) {
2637                 /*
2638                  * Don't use iov_iter_advance() here, as it's really slow for
2639                  * using the latter parts of a big fixed buffer - it iterates
2640                  * over each segment manually. We can cheat a bit here, because
2641                  * we know that:
2642                  *
2643                  * 1) it's a BVEC iter, we set it up
2644                  * 2) all bvecs are PAGE_SIZE in size, except potentially the
2645                  *    first and last bvec
2646                  *
2647                  * So just find our index, and adjust the iterator afterwards.
2648                  * If the offset is within the first bvec (or the whole first
2649                  * bvec, just use iov_iter_advance(). This makes it easier
2650                  * since we can just skip the first segment, which may not
2651                  * be PAGE_SIZE aligned.
2652                  */
2653                 const struct bio_vec *bvec = imu->bvec;
2654
2655                 if (offset <= bvec->bv_len) {
2656                         iov_iter_advance(iter, offset);
2657                 } else {
2658                         unsigned long seg_skip;
2659
2660                         /* skip first vec */
2661                         offset -= bvec->bv_len;
2662                         seg_skip = 1 + (offset >> PAGE_SHIFT);
2663
2664                         iter->bvec = bvec + seg_skip;
2665                         iter->nr_segs -= seg_skip;
2666                         iter->count -= bvec->bv_len + offset;
2667                         iter->iov_offset = offset & ~PAGE_MASK;
2668                 }
2669         }
2670
2671         return len;
2672 }
2673
2674 static void io_ring_submit_unlock(struct io_ring_ctx *ctx, bool needs_lock)
2675 {
2676         if (needs_lock)
2677                 mutex_unlock(&ctx->uring_lock);
2678 }
2679
2680 static void io_ring_submit_lock(struct io_ring_ctx *ctx, bool needs_lock)
2681 {
2682         /*
2683          * "Normal" inline submissions always hold the uring_lock, since we
2684          * grab it from the system call. Same is true for the SQPOLL offload.
2685          * The only exception is when we've detached the request and issue it
2686          * from an async worker thread, grab the lock for that case.
2687          */
2688         if (needs_lock)
2689                 mutex_lock(&ctx->uring_lock);
2690 }
2691
2692 static struct io_buffer *io_buffer_select(struct io_kiocb *req, size_t *len,
2693                                           int bgid, struct io_buffer *kbuf,
2694                                           bool needs_lock)
2695 {
2696         struct io_buffer *head;
2697
2698         if (req->flags & REQ_F_BUFFER_SELECTED)
2699                 return kbuf;
2700
2701         io_ring_submit_lock(req->ctx, needs_lock);
2702
2703         lockdep_assert_held(&req->ctx->uring_lock);
2704
2705         head = idr_find(&req->ctx->io_buffer_idr, bgid);
2706         if (head) {
2707                 if (!list_empty(&head->list)) {
2708                         kbuf = list_last_entry(&head->list, struct io_buffer,
2709                                                         list);
2710                         list_del(&kbuf->list);
2711                 } else {
2712                         kbuf = head;
2713                         idr_remove(&req->ctx->io_buffer_idr, bgid);
2714                 }
2715                 if (*len > kbuf->len)
2716                         *len = kbuf->len;
2717         } else {
2718                 kbuf = ERR_PTR(-ENOBUFS);
2719         }
2720
2721         io_ring_submit_unlock(req->ctx, needs_lock);
2722
2723         return kbuf;
2724 }
2725
2726 static void __user *io_rw_buffer_select(struct io_kiocb *req, size_t *len,
2727                                         bool needs_lock)
2728 {
2729         struct io_buffer *kbuf;
2730         u16 bgid;
2731
2732         kbuf = (struct io_buffer *) (unsigned long) req->rw.addr;
2733         bgid = req->buf_index;
2734         kbuf = io_buffer_select(req, len, bgid, kbuf, needs_lock);
2735         if (IS_ERR(kbuf))
2736                 return kbuf;
2737         req->rw.addr = (u64) (unsigned long) kbuf;
2738         req->flags |= REQ_F_BUFFER_SELECTED;
2739         return u64_to_user_ptr(kbuf->addr);
2740 }
2741
2742 #ifdef CONFIG_COMPAT
2743 static ssize_t io_compat_import(struct io_kiocb *req, struct iovec *iov,
2744                                 bool needs_lock)
2745 {
2746         struct compat_iovec __user *uiov;
2747         compat_ssize_t clen;
2748         void __user *buf;
2749         ssize_t len;
2750
2751         uiov = u64_to_user_ptr(req->rw.addr);
2752         if (!access_ok(uiov, sizeof(*uiov)))
2753                 return -EFAULT;
2754         if (__get_user(clen, &uiov->iov_len))
2755                 return -EFAULT;
2756         if (clen < 0)
2757                 return -EINVAL;
2758
2759         len = clen;
2760         buf = io_rw_buffer_select(req, &len, needs_lock);
2761         if (IS_ERR(buf))
2762                 return PTR_ERR(buf);
2763         iov[0].iov_base = buf;
2764         iov[0].iov_len = (compat_size_t) len;
2765         return 0;
2766 }
2767 #endif
2768
2769 static ssize_t __io_iov_buffer_select(struct io_kiocb *req, struct iovec *iov,
2770                                       bool needs_lock)
2771 {
2772         struct iovec __user *uiov = u64_to_user_ptr(req->rw.addr);
2773         void __user *buf;
2774         ssize_t len;
2775
2776         if (copy_from_user(iov, uiov, sizeof(*uiov)))
2777                 return -EFAULT;
2778
2779         len = iov[0].iov_len;
2780         if (len < 0)
2781                 return -EINVAL;
2782         buf = io_rw_buffer_select(req, &len, needs_lock);
2783         if (IS_ERR(buf))
2784                 return PTR_ERR(buf);
2785         iov[0].iov_base = buf;
2786         iov[0].iov_len = len;
2787         return 0;
2788 }
2789
2790 static ssize_t io_iov_buffer_select(struct io_kiocb *req, struct iovec *iov,
2791                                     bool needs_lock)
2792 {
2793         if (req->flags & REQ_F_BUFFER_SELECTED) {
2794                 struct io_buffer *kbuf;
2795
2796                 kbuf = (struct io_buffer *) (unsigned long) req->rw.addr;
2797                 iov[0].iov_base = u64_to_user_ptr(kbuf->addr);
2798                 iov[0].iov_len = kbuf->len;
2799                 return 0;
2800         }
2801         if (!req->rw.len)
2802                 return 0;
2803         else if (req->rw.len > 1)
2804                 return -EINVAL;
2805
2806 #ifdef CONFIG_COMPAT
2807         if (req->ctx->compat)
2808                 return io_compat_import(req, iov, needs_lock);
2809 #endif
2810
2811         return __io_iov_buffer_select(req, iov, needs_lock);
2812 }
2813
2814 static ssize_t io_import_iovec(int rw, struct io_kiocb *req,
2815                                struct iovec **iovec, struct iov_iter *iter,
2816                                bool needs_lock)
2817 {
2818         void __user *buf = u64_to_user_ptr(req->rw.addr);
2819         size_t sqe_len = req->rw.len;
2820         ssize_t ret;
2821         u8 opcode;
2822
2823         opcode = req->opcode;
2824         if (opcode == IORING_OP_READ_FIXED || opcode == IORING_OP_WRITE_FIXED) {
2825                 *iovec = NULL;
2826                 return io_import_fixed(req, rw, iter);
2827         }
2828
2829         /* buffer index only valid with fixed read/write, or buffer select  */
2830         if (req->buf_index && !(req->flags & REQ_F_BUFFER_SELECT))
2831                 return -EINVAL;
2832
2833         if (opcode == IORING_OP_READ || opcode == IORING_OP_WRITE) {
2834                 if (req->flags & REQ_F_BUFFER_SELECT) {
2835                         buf = io_rw_buffer_select(req, &sqe_len, needs_lock);
2836                         if (IS_ERR(buf)) {
2837                                 *iovec = NULL;
2838                                 return PTR_ERR(buf);
2839                         }
2840                         req->rw.len = sqe_len;
2841                 }
2842
2843                 ret = import_single_range(rw, buf, sqe_len, *iovec, iter);
2844                 *iovec = NULL;
2845                 return ret < 0 ? ret : sqe_len;
2846         }
2847
2848         if (req->io) {
2849                 struct io_async_rw *iorw = &req->io->rw;
2850
2851                 iov_iter_init(iter, rw, iorw->iov, iorw->nr_segs, iorw->size);
2852                 *iovec = NULL;
2853                 return iorw->size;
2854         }
2855
2856         if (req->flags & REQ_F_BUFFER_SELECT) {
2857                 ret = io_iov_buffer_select(req, *iovec, needs_lock);
2858                 if (!ret) {
2859                         ret = (*iovec)->iov_len;
2860                         iov_iter_init(iter, rw, *iovec, 1, ret);
2861                 }
2862                 *iovec = NULL;
2863                 return ret;
2864         }
2865
2866 #ifdef CONFIG_COMPAT
2867         if (req->ctx->compat)
2868                 return compat_import_iovec(rw, buf, sqe_len, UIO_FASTIOV,
2869                                                 iovec, iter);
2870 #endif
2871
2872         return import_iovec(rw, buf, sqe_len, UIO_FASTIOV, iovec, iter);
2873 }
2874
2875 /*
2876  * For files that don't have ->read_iter() and ->write_iter(), handle them
2877  * by looping over ->read() or ->write() manually.
2878  */
2879 static ssize_t loop_rw_iter(int rw, struct file *file, struct kiocb *kiocb,
2880                            struct iov_iter *iter)
2881 {
2882         ssize_t ret = 0;
2883
2884         /*
2885          * Don't support polled IO through this interface, and we can't
2886          * support non-blocking either. For the latter, this just causes
2887          * the kiocb to be handled from an async context.
2888          */
2889         if (kiocb->ki_flags & IOCB_HIPRI)
2890                 return -EOPNOTSUPP;
2891         if (kiocb->ki_flags & IOCB_NOWAIT)
2892                 return -EAGAIN;
2893
2894         while (iov_iter_count(iter)) {
2895                 struct iovec iovec;
2896                 ssize_t nr;
2897
2898                 if (!iov_iter_is_bvec(iter)) {
2899                         iovec = iov_iter_iovec(iter);
2900                 } else {
2901                         /* fixed buffers import bvec */
2902                         iovec.iov_base = kmap(iter->bvec->bv_page)
2903                                                 + iter->iov_offset;
2904                         iovec.iov_len = min(iter->count,
2905                                         iter->bvec->bv_len - iter->iov_offset);
2906                 }
2907
2908                 if (rw == READ) {
2909                         nr = file->f_op->read(file, iovec.iov_base,
2910                                               iovec.iov_len, &kiocb->ki_pos);
2911                 } else {
2912                         nr = file->f_op->write(file, iovec.iov_base,
2913                                                iovec.iov_len, &kiocb->ki_pos);
2914                 }
2915
2916                 if (iov_iter_is_bvec(iter))
2917                         kunmap(iter->bvec->bv_page);
2918
2919                 if (nr < 0) {
2920                         if (!ret)
2921                                 ret = nr;
2922                         break;
2923                 }
2924                 ret += nr;
2925                 if (nr != iovec.iov_len)
2926                         break;
2927                 iov_iter_advance(iter, nr);
2928         }
2929
2930         return ret;
2931 }
2932
2933 static void io_req_map_rw(struct io_kiocb *req, ssize_t io_size,
2934                           struct iovec *iovec, struct iovec *fast_iov,
2935                           struct iov_iter *iter)
2936 {
2937         struct io_async_rw *rw = &req->io->rw;
2938
2939         rw->nr_segs = iter->nr_segs;
2940         rw->size = io_size;
2941         if (!iovec) {
2942                 rw->iov = rw->fast_iov;
2943                 if (rw->iov != fast_iov)
2944                         memcpy(rw->iov, fast_iov,
2945                                sizeof(struct iovec) * iter->nr_segs);
2946         } else {
2947                 rw->iov = iovec;
2948                 req->flags |= REQ_F_NEED_CLEANUP;
2949         }
2950 }
2951
2952 static inline int __io_alloc_async_ctx(struct io_kiocb *req)
2953 {
2954         req->io = kmalloc(sizeof(*req->io), GFP_KERNEL);
2955         return req->io == NULL;
2956 }
2957
2958 static int io_alloc_async_ctx(struct io_kiocb *req)
2959 {
2960         if (!io_op_defs[req->opcode].async_ctx)
2961                 return 0;
2962
2963         return  __io_alloc_async_ctx(req);
2964 }
2965
2966 static int io_setup_async_rw(struct io_kiocb *req, ssize_t io_size,
2967                              struct iovec *iovec, struct iovec *fast_iov,
2968                              struct iov_iter *iter)
2969 {
2970         if (!io_op_defs[req->opcode].async_ctx)
2971                 return 0;
2972         if (!req->io) {
2973                 if (__io_alloc_async_ctx(req))
2974                         return -ENOMEM;
2975
2976                 io_req_map_rw(req, io_size, iovec, fast_iov, iter);
2977         }
2978         return 0;
2979 }
2980
2981 static inline int io_rw_prep_async(struct io_kiocb *req, int rw,
2982                                    bool force_nonblock)
2983 {
2984         struct io_async_ctx *io = req->io;
2985         struct iov_iter iter;
2986         ssize_t ret;
2987
2988         io->rw.iov = io->rw.fast_iov;
2989         req->io = NULL;
2990         ret = io_import_iovec(rw, req, &io->rw.iov, &iter, !force_nonblock);
2991         req->io = io;
2992         if (unlikely(ret < 0))
2993                 return ret;
2994
2995         io_req_map_rw(req, ret, io->rw.iov, io->rw.fast_iov, &iter);
2996         return 0;
2997 }
2998
2999 static int io_read_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
3000                         bool force_nonblock)
3001 {
3002         ssize_t ret;
3003
3004         ret = io_prep_rw(req, sqe, force_nonblock);
3005         if (ret)
3006                 return ret;
3007
3008         if (unlikely(!(req->file->f_mode & FMODE_READ)))
3009                 return -EBADF;
3010
3011         /* either don't need iovec imported or already have it */
3012         if (!req->io || req->flags & REQ_F_NEED_CLEANUP)
3013                 return 0;
3014         return io_rw_prep_async(req, READ, force_nonblock);
3015 }
3016
3017 /*
3018  * This is our waitqueue callback handler, registered through lock_page_async()
3019  * when we initially tried to do the IO with the iocb armed our waitqueue.
3020  * This gets called when the page is unlocked, and we generally expect that to
3021  * happen when the page IO is completed and the page is now uptodate. This will
3022  * queue a task_work based retry of the operation, attempting to copy the data
3023  * again. If the latter fails because the page was NOT uptodate, then we will
3024  * do a thread based blocking retry of the operation. That's the unexpected
3025  * slow path.
3026  */
3027 static int io_async_buf_func(struct wait_queue_entry *wait, unsigned mode,
3028                              int sync, void *arg)
3029 {
3030         struct wait_page_queue *wpq;
3031         struct io_kiocb *req = wait->private;
3032         struct wait_page_key *key = arg;
3033         int ret;
3034
3035         wpq = container_of(wait, struct wait_page_queue, wait);
3036
3037         if (!wake_page_match(wpq, key))
3038                 return 0;
3039
3040         list_del_init(&wait->entry);
3041
3042         init_task_work(&req->task_work, io_req_task_submit);
3043         percpu_ref_get(&req->ctx->refs);
3044
3045         /* submit ref gets dropped, acquire a new one */
3046         refcount_inc(&req->refs);
3047         ret = io_req_task_work_add(req, &req->task_work);
3048         if (unlikely(ret)) {
3049                 struct task_struct *tsk;
3050
3051                 /* queue just for cancelation */
3052                 init_task_work(&req->task_work, io_req_task_cancel);
3053                 tsk = io_wq_get_task(req->ctx->io_wq);
3054                 task_work_add(tsk, &req->task_work, 0);
3055                 wake_up_process(tsk);
3056         }
3057         return 1;
3058 }
3059
3060 static inline int kiocb_wait_page_queue_init(struct kiocb *kiocb,
3061                                              struct wait_page_queue *wait,
3062                                              wait_queue_func_t func,
3063                                              void *data)
3064 {
3065         /* Can't support async wakeup with polled IO */
3066         if (kiocb->ki_flags & IOCB_HIPRI)
3067                 return -EINVAL;
3068         if (kiocb->ki_filp->f_mode & FMODE_BUF_RASYNC) {
3069                 wait->wait.func = func;
3070                 wait->wait.private = data;
3071                 wait->wait.flags = 0;
3072                 INIT_LIST_HEAD(&wait->wait.entry);
3073                 kiocb->ki_flags |= IOCB_WAITQ;
3074                 kiocb->ki_waitq = wait;
3075                 return 0;
3076         }
3077
3078         return -EOPNOTSUPP;
3079 }
3080
3081 /*
3082  * This controls whether a given IO request should be armed for async page
3083  * based retry. If we return false here, the request is handed to the async
3084  * worker threads for retry. If we're doing buffered reads on a regular file,
3085  * we prepare a private wait_page_queue entry and retry the operation. This
3086  * will either succeed because the page is now uptodate and unlocked, or it
3087  * will register a callback when the page is unlocked at IO completion. Through
3088  * that callback, io_uring uses task_work to setup a retry of the operation.
3089  * That retry will attempt the buffered read again. The retry will generally
3090  * succeed, or in rare cases where it fails, we then fall back to using the
3091  * async worker threads for a blocking retry.
3092  */
3093 static bool io_rw_should_retry(struct io_kiocb *req)
3094 {
3095         struct kiocb *kiocb = &req->rw.kiocb;
3096         int ret;
3097
3098         /* never retry for NOWAIT, we just complete with -EAGAIN */
3099         if (req->flags & REQ_F_NOWAIT)
3100                 return false;
3101
3102         /* already tried, or we're doing O_DIRECT */
3103         if (kiocb->ki_flags & (IOCB_DIRECT | IOCB_WAITQ))
3104                 return false;
3105         /*
3106          * just use poll if we can, and don't attempt if the fs doesn't
3107          * support callback based unlocks
3108          */
3109         if (file_can_poll(req->file) || !(req->file->f_mode & FMODE_BUF_RASYNC))
3110                 return false;
3111
3112         /*
3113          * If request type doesn't require req->io to defer in general,
3114          * we need to allocate it here
3115          */
3116         if (!req->io && __io_alloc_async_ctx(req))
3117                 return false;
3118
3119         ret = kiocb_wait_page_queue_init(kiocb, &req->io->rw.wpq,
3120                                                 io_async_buf_func, req);
3121         if (!ret) {
3122                 io_get_req_task(req);
3123                 return true;
3124         }
3125
3126         return false;
3127 }
3128
3129 static int io_iter_do_read(struct io_kiocb *req, struct iov_iter *iter)
3130 {
3131         if (req->file->f_op->read_iter)
3132                 return call_read_iter(req->file, &req->rw.kiocb, iter);
3133         else if (req->file->f_op->read)
3134                 return loop_rw_iter(READ, req->file, &req->rw.kiocb, iter);
3135         else
3136                 return -EINVAL;
3137 }
3138
3139 static int io_read(struct io_kiocb *req, bool force_nonblock,
3140                    struct io_comp_state *cs)
3141 {
3142         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
3143         struct kiocb *kiocb = &req->rw.kiocb;
3144         struct iov_iter iter;
3145         size_t iov_count;
3146         ssize_t io_size, ret, ret2;
3147         unsigned long nr_segs;
3148
3149         ret = io_import_iovec(READ, req, &iovec, &iter, !force_nonblock);
3150         if (ret < 0)
3151                 return ret;
3152         io_size = ret;
3153         req->result = io_size;
3154
3155         /* Ensure we clear previously set non-block flag */
3156         if (!force_nonblock)
3157                 kiocb->ki_flags &= ~IOCB_NOWAIT;
3158
3159         /* If the file doesn't support async, just async punt */
3160         if (force_nonblock && !io_file_supports_async(req->file, READ))
3161                 goto copy_iov;
3162
3163         iov_count = iov_iter_count(&iter);
3164         nr_segs = iter.nr_segs;
3165         ret = rw_verify_area(READ, req->file, &kiocb->ki_pos, iov_count);
3166         if (unlikely(ret))
3167                 goto out_free;
3168
3169         ret2 = io_iter_do_read(req, &iter);
3170
3171         /* Catch -EAGAIN return for forced non-blocking submission */
3172         if (!force_nonblock || (ret2 != -EAGAIN && ret2 != -EIO)) {
3173                 kiocb_done(kiocb, ret2, cs);
3174         } else {
3175                 iter.count = iov_count;
3176                 iter.nr_segs = nr_segs;
3177 copy_iov:
3178                 ret = io_setup_async_rw(req, io_size, iovec, inline_vecs,
3179                                         &iter);
3180                 if (ret)
3181                         goto out_free;
3182                 /* it's copied and will be cleaned with ->io */
3183                 iovec = NULL;
3184                 /* if we can retry, do so with the callbacks armed */
3185                 if (io_rw_should_retry(req)) {
3186                         ret2 = io_iter_do_read(req, &iter);
3187                         if (ret2 == -EIOCBQUEUED) {
3188                                 goto out_free;
3189                         } else if (ret2 != -EAGAIN) {
3190                                 kiocb_done(kiocb, ret2, cs);
3191                                 goto out_free;
3192                         }
3193                 }
3194                 kiocb->ki_flags &= ~IOCB_WAITQ;
3195                 return -EAGAIN;
3196         }
3197 out_free:
3198         if (iovec)
3199                 kfree(iovec);
3200         return ret;
3201 }
3202
3203 static int io_write_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
3204                          bool force_nonblock)
3205 {
3206         ssize_t ret;
3207
3208         ret = io_prep_rw(req, sqe, force_nonblock);
3209         if (ret)
3210                 return ret;
3211
3212         if (unlikely(!(req->file->f_mode & FMODE_WRITE)))
3213                 return -EBADF;
3214
3215         /* either don't need iovec imported or already have it */
3216         if (!req->io || req->flags & REQ_F_NEED_CLEANUP)
3217                 return 0;
3218         return io_rw_prep_async(req, WRITE, force_nonblock);
3219 }
3220
3221 static int io_write(struct io_kiocb *req, bool force_nonblock,
3222                     struct io_comp_state *cs)
3223 {
3224         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
3225         struct kiocb *kiocb = &req->rw.kiocb;
3226         struct iov_iter iter;
3227         size_t iov_count;
3228         ssize_t ret, ret2, io_size;
3229         unsigned long nr_segs;
3230
3231         ret = io_import_iovec(WRITE, req, &iovec, &iter, !force_nonblock);
3232         if (ret < 0)
3233                 return ret;
3234         io_size = ret;
3235         req->result = io_size;
3236
3237         /* Ensure we clear previously set non-block flag */
3238         if (!force_nonblock)
3239                 req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
3240
3241         /* If the file doesn't support async, just async punt */
3242         if (force_nonblock && !io_file_supports_async(req->file, WRITE))
3243                 goto copy_iov;
3244
3245         /* file path doesn't support NOWAIT for non-direct_IO */
3246         if (force_nonblock && !(kiocb->ki_flags & IOCB_DIRECT) &&
3247             (req->flags & REQ_F_ISREG))
3248                 goto copy_iov;
3249
3250         iov_count = iov_iter_count(&iter);
3251         nr_segs = iter.nr_segs;
3252         ret = rw_verify_area(WRITE, req->file, &kiocb->ki_pos, iov_count);
3253         if (unlikely(ret))
3254                 goto out_free;
3255
3256         /*
3257          * Open-code file_start_write here to grab freeze protection,
3258          * which will be released by another thread in
3259          * io_complete_rw().  Fool lockdep by telling it the lock got
3260          * released so that it doesn't complain about the held lock when
3261          * we return to userspace.
3262          */
3263         if (req->flags & REQ_F_ISREG) {
3264                 __sb_start_write(file_inode(req->file)->i_sb,
3265                                         SB_FREEZE_WRITE, true);
3266                 __sb_writers_release(file_inode(req->file)->i_sb,
3267                                         SB_FREEZE_WRITE);
3268         }
3269         kiocb->ki_flags |= IOCB_WRITE;
3270
3271         if (req->file->f_op->write_iter)
3272                 ret2 = call_write_iter(req->file, kiocb, &iter);
3273         else if (req->file->f_op->write)
3274                 ret2 = loop_rw_iter(WRITE, req->file, kiocb, &iter);
3275         else
3276                 ret2 = -EINVAL;
3277
3278         /*
3279          * Raw bdev writes will return -EOPNOTSUPP for IOCB_NOWAIT. Just
3280          * retry them without IOCB_NOWAIT.
3281          */
3282         if (ret2 == -EOPNOTSUPP && (kiocb->ki_flags & IOCB_NOWAIT))
3283                 ret2 = -EAGAIN;
3284         if (!force_nonblock || ret2 != -EAGAIN) {
3285                 kiocb_done(kiocb, ret2, cs);
3286         } else {
3287                 iter.count = iov_count;
3288                 iter.nr_segs = nr_segs;
3289 copy_iov:
3290                 ret = io_setup_async_rw(req, io_size, iovec, inline_vecs,
3291                                         &iter);
3292                 if (ret)
3293                         goto out_free;
3294                 /* it's copied and will be cleaned with ->io */
3295                 iovec = NULL;
3296                 return -EAGAIN;
3297         }
3298 out_free:
3299         if (iovec)
3300                 kfree(iovec);
3301         return ret;
3302 }
3303
3304 static int __io_splice_prep(struct io_kiocb *req,
3305                             const struct io_uring_sqe *sqe)
3306 {
3307         struct io_splice* sp = &req->splice;
3308         unsigned int valid_flags = SPLICE_F_FD_IN_FIXED | SPLICE_F_ALL;
3309         int ret;
3310
3311         if (req->flags & REQ_F_NEED_CLEANUP)
3312                 return 0;
3313         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3314                 return -EINVAL;
3315
3316         sp->file_in = NULL;
3317         sp->len = READ_ONCE(sqe->len);
3318         sp->flags = READ_ONCE(sqe->splice_flags);
3319
3320         if (unlikely(sp->flags & ~valid_flags))
3321                 return -EINVAL;
3322
3323         ret = io_file_get(NULL, req, READ_ONCE(sqe->splice_fd_in), &sp->file_in,
3324                           (sp->flags & SPLICE_F_FD_IN_FIXED));
3325         if (ret)
3326                 return ret;
3327         req->flags |= REQ_F_NEED_CLEANUP;
3328
3329         if (!S_ISREG(file_inode(sp->file_in)->i_mode)) {
3330                 /*
3331                  * Splice operation will be punted aync, and here need to
3332                  * modify io_wq_work.flags, so initialize io_wq_work firstly.
3333                  */
3334                 io_req_init_async(req);
3335                 req->work.flags |= IO_WQ_WORK_UNBOUND;
3336         }
3337
3338         return 0;
3339 }
3340
3341 static int io_tee_prep(struct io_kiocb *req,
3342                        const struct io_uring_sqe *sqe)
3343 {
3344         if (READ_ONCE(sqe->splice_off_in) || READ_ONCE(sqe->off))
3345                 return -EINVAL;
3346         return __io_splice_prep(req, sqe);
3347 }
3348
3349 static int io_tee(struct io_kiocb *req, bool force_nonblock)
3350 {
3351         struct io_splice *sp = &req->splice;
3352         struct file *in = sp->file_in;
3353         struct file *out = sp->file_out;
3354         unsigned int flags = sp->flags & ~SPLICE_F_FD_IN_FIXED;
3355         long ret = 0;
3356
3357         if (force_nonblock)
3358                 return -EAGAIN;
3359         if (sp->len)
3360                 ret = do_tee(in, out, sp->len, flags);
3361
3362         io_put_file(req, in, (sp->flags & SPLICE_F_FD_IN_FIXED));
3363         req->flags &= ~REQ_F_NEED_CLEANUP;
3364
3365         if (ret != sp->len)
3366                 req_set_fail_links(req);
3367         io_req_complete(req, ret);
3368         return 0;
3369 }
3370
3371 static int io_splice_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3372 {
3373         struct io_splice* sp = &req->splice;
3374
3375         sp->off_in = READ_ONCE(sqe->splice_off_in);
3376         sp->off_out = READ_ONCE(sqe->off);
3377         return __io_splice_prep(req, sqe);
3378 }
3379
3380 static int io_splice(struct io_kiocb *req, bool force_nonblock)
3381 {
3382         struct io_splice *sp = &req->splice;
3383         struct file *in = sp->file_in;
3384         struct file *out = sp->file_out;
3385         unsigned int flags = sp->flags & ~SPLICE_F_FD_IN_FIXED;
3386         loff_t *poff_in, *poff_out;
3387         long ret = 0;
3388
3389         if (force_nonblock)
3390                 return -EAGAIN;
3391
3392         poff_in = (sp->off_in == -1) ? NULL : &sp->off_in;
3393         poff_out = (sp->off_out == -1) ? NULL : &sp->off_out;
3394
3395         if (sp->len)
3396                 ret = do_splice(in, poff_in, out, poff_out, sp->len, flags);
3397
3398         io_put_file(req, in, (sp->flags & SPLICE_F_FD_IN_FIXED));
3399         req->flags &= ~REQ_F_NEED_CLEANUP;
3400
3401         if (ret != sp->len)
3402                 req_set_fail_links(req);
3403         io_req_complete(req, ret);
3404         return 0;
3405 }
3406
3407 /*
3408  * IORING_OP_NOP just posts a completion event, nothing else.
3409  */
3410 static int io_nop(struct io_kiocb *req, struct io_comp_state *cs)
3411 {
3412         struct io_ring_ctx *ctx = req->ctx;
3413
3414         if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
3415                 return -EINVAL;
3416
3417         __io_req_complete(req, 0, 0, cs);
3418         return 0;
3419 }
3420
3421 static int io_prep_fsync(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3422 {
3423         struct io_ring_ctx *ctx = req->ctx;
3424
3425         if (!req->file)
3426                 return -EBADF;
3427
3428         if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
3429                 return -EINVAL;
3430         if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
3431                 return -EINVAL;
3432
3433         req->sync.flags = READ_ONCE(sqe->fsync_flags);
3434         if (unlikely(req->sync.flags & ~IORING_FSYNC_DATASYNC))
3435                 return -EINVAL;
3436
3437         req->sync.off = READ_ONCE(sqe->off);
3438         req->sync.len = READ_ONCE(sqe->len);
3439         return 0;
3440 }
3441
3442 static int io_fsync(struct io_kiocb *req, bool force_nonblock)
3443 {
3444         loff_t end = req->sync.off + req->sync.len;
3445         int ret;
3446
3447         /* fsync always requires a blocking context */
3448         if (force_nonblock)
3449                 return -EAGAIN;
3450
3451         ret = vfs_fsync_range(req->file, req->sync.off,
3452                                 end > 0 ? end : LLONG_MAX,
3453                                 req->sync.flags & IORING_FSYNC_DATASYNC);
3454         if (ret < 0)
3455                 req_set_fail_links(req);
3456         io_req_complete(req, ret);
3457         return 0;
3458 }
3459
3460 static int io_fallocate_prep(struct io_kiocb *req,
3461                              const struct io_uring_sqe *sqe)
3462 {
3463         if (sqe->ioprio || sqe->buf_index || sqe->rw_flags)
3464                 return -EINVAL;
3465         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3466                 return -EINVAL;
3467
3468         req->sync.off = READ_ONCE(sqe->off);
3469         req->sync.len = READ_ONCE(sqe->addr);
3470         req->sync.mode = READ_ONCE(sqe->len);
3471         return 0;
3472 }
3473
3474 static int io_fallocate(struct io_kiocb *req, bool force_nonblock)
3475 {
3476         int ret;
3477
3478         /* fallocate always requiring blocking context */
3479         if (force_nonblock)
3480                 return -EAGAIN;
3481         ret = vfs_fallocate(req->file, req->sync.mode, req->sync.off,
3482                                 req->sync.len);
3483         if (ret < 0)
3484                 req_set_fail_links(req);
3485         io_req_complete(req, ret);
3486         return 0;
3487 }
3488
3489 static int __io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3490 {
3491         const char __user *fname;
3492         int ret;
3493
3494         if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
3495                 return -EINVAL;
3496         if (unlikely(sqe->ioprio || sqe->buf_index))
3497                 return -EINVAL;
3498         if (unlikely(req->flags & REQ_F_FIXED_FILE))
3499                 return -EBADF;
3500
3501         /* open.how should be already initialised */
3502         if (!(req->open.how.flags & O_PATH) && force_o_largefile())
3503                 req->open.how.flags |= O_LARGEFILE;
3504
3505         req->open.dfd = READ_ONCE(sqe->fd);
3506         fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
3507         req->open.filename = getname(fname);
3508         if (IS_ERR(req->open.filename)) {
3509                 ret = PTR_ERR(req->open.filename);
3510                 req->open.filename = NULL;
3511                 return ret;
3512         }
3513         req->open.nofile = rlimit(RLIMIT_NOFILE);
3514         req->flags |= REQ_F_NEED_CLEANUP;
3515         return 0;
3516 }
3517
3518 static int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3519 {
3520         u64 flags, mode;
3521
3522         if (req->flags & REQ_F_NEED_CLEANUP)
3523                 return 0;
3524         mode = READ_ONCE(sqe->len);
3525         flags = READ_ONCE(sqe->open_flags);
3526         req->open.how = build_open_how(flags, mode);
3527         return __io_openat_prep(req, sqe);
3528 }
3529
3530 static int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3531 {
3532         struct open_how __user *how;
3533         size_t len;
3534         int ret;
3535
3536         if (req->flags & REQ_F_NEED_CLEANUP)
3537                 return 0;
3538         how = u64_to_user_ptr(READ_ONCE(sqe->addr2));
3539         len = READ_ONCE(sqe->len);
3540         if (len < OPEN_HOW_SIZE_VER0)
3541                 return -EINVAL;
3542
3543         ret = copy_struct_from_user(&req->open.how, sizeof(req->open.how), how,
3544                                         len);
3545         if (ret)
3546                 return ret;
3547
3548         return __io_openat_prep(req, sqe);
3549 }
3550
3551 static int io_openat2(struct io_kiocb *req, bool force_nonblock)
3552 {
3553         struct open_flags op;
3554         struct file *file;
3555         int ret;
3556
3557         if (force_nonblock)
3558                 return -EAGAIN;
3559
3560         ret = build_open_flags(&req->open.how, &op);
3561         if (ret)
3562                 goto err;
3563
3564         ret = __get_unused_fd_flags(req->open.how.flags, req->open.nofile);
3565         if (ret < 0)
3566                 goto err;
3567
3568         file = do_filp_open(req->open.dfd, req->open.filename, &op);
3569         if (IS_ERR(file)) {
3570                 put_unused_fd(ret);
3571                 ret = PTR_ERR(file);
3572         } else {
3573                 fsnotify_open(file);
3574                 fd_install(ret, file);
3575         }
3576 err:
3577         putname(req->open.filename);
3578         req->flags &= ~REQ_F_NEED_CLEANUP;
3579         if (ret < 0)
3580                 req_set_fail_links(req);
3581         io_req_complete(req, ret);
3582         return 0;
3583 }
3584
3585 static int io_openat(struct io_kiocb *req, bool force_nonblock)
3586 {
3587         return io_openat2(req, force_nonblock);
3588 }
3589
3590 static int io_remove_buffers_prep(struct io_kiocb *req,
3591                                   const struct io_uring_sqe *sqe)
3592 {
3593         struct io_provide_buf *p = &req->pbuf;
3594         u64 tmp;
3595
3596         if (sqe->ioprio || sqe->rw_flags || sqe->addr || sqe->len || sqe->off)
3597                 return -EINVAL;
3598
3599         tmp = READ_ONCE(sqe->fd);
3600         if (!tmp || tmp > USHRT_MAX)
3601                 return -EINVAL;
3602
3603         memset(p, 0, sizeof(*p));
3604         p->nbufs = tmp;
3605         p->bgid = READ_ONCE(sqe->buf_group);
3606         return 0;
3607 }
3608
3609 static int __io_remove_buffers(struct io_ring_ctx *ctx, struct io_buffer *buf,
3610                                int bgid, unsigned nbufs)
3611 {
3612         unsigned i = 0;
3613
3614         /* shouldn't happen */
3615         if (!nbufs)
3616                 return 0;
3617
3618         /* the head kbuf is the list itself */
3619         while (!list_empty(&buf->list)) {
3620                 struct io_buffer *nxt;
3621
3622                 nxt = list_first_entry(&buf->list, struct io_buffer, list);
3623                 list_del(&nxt->list);
3624                 kfree(nxt);
3625                 if (++i == nbufs)
3626                         return i;
3627         }
3628         i++;
3629         kfree(buf);
3630         idr_remove(&ctx->io_buffer_idr, bgid);
3631
3632         return i;
3633 }
3634
3635 static int io_remove_buffers(struct io_kiocb *req, bool force_nonblock,
3636                              struct io_comp_state *cs)
3637 {
3638         struct io_provide_buf *p = &req->pbuf;
3639         struct io_ring_ctx *ctx = req->ctx;
3640         struct io_buffer *head;
3641         int ret = 0;
3642
3643         io_ring_submit_lock(ctx, !force_nonblock);
3644
3645         lockdep_assert_held(&ctx->uring_lock);
3646
3647         ret = -ENOENT;
3648         head = idr_find(&ctx->io_buffer_idr, p->bgid);
3649         if (head)
3650                 ret = __io_remove_buffers(ctx, head, p->bgid, p->nbufs);
3651
3652         io_ring_submit_lock(ctx, !force_nonblock);
3653         if (ret < 0)
3654                 req_set_fail_links(req);
3655         __io_req_complete(req, ret, 0, cs);
3656         return 0;
3657 }
3658
3659 static int io_provide_buffers_prep(struct io_kiocb *req,
3660                                    const struct io_uring_sqe *sqe)
3661 {
3662         struct io_provide_buf *p = &req->pbuf;
3663         u64 tmp;
3664
3665         if (sqe->ioprio || sqe->rw_flags)
3666                 return -EINVAL;
3667
3668         tmp = READ_ONCE(sqe->fd);
3669         if (!tmp || tmp > USHRT_MAX)
3670                 return -E2BIG;
3671         p->nbufs = tmp;
3672         p->addr = READ_ONCE(sqe->addr);
3673         p->len = READ_ONCE(sqe->len);
3674
3675         if (!access_ok(u64_to_user_ptr(p->addr), (p->len * p->nbufs)))
3676                 return -EFAULT;
3677
3678         p->bgid = READ_ONCE(sqe->buf_group);
3679         tmp = READ_ONCE(sqe->off);
3680         if (tmp > USHRT_MAX)
3681                 return -E2BIG;
3682         p->bid = tmp;
3683         return 0;
3684 }
3685
3686 static int io_add_buffers(struct io_provide_buf *pbuf, struct io_buffer **head)
3687 {
3688         struct io_buffer *buf;
3689         u64 addr = pbuf->addr;
3690         int i, bid = pbuf->bid;
3691
3692         for (i = 0; i < pbuf->nbufs; i++) {
3693                 buf = kmalloc(sizeof(*buf), GFP_KERNEL);
3694                 if (!buf)
3695                         break;
3696
3697                 buf->addr = addr;
3698                 buf->len = pbuf->len;
3699                 buf->bid = bid;
3700                 addr += pbuf->len;
3701                 bid++;
3702                 if (!*head) {
3703                         INIT_LIST_HEAD(&buf->list);
3704                         *head = buf;
3705                 } else {
3706                         list_add_tail(&buf->list, &(*head)->list);
3707                 }
3708         }
3709
3710         return i ? i : -ENOMEM;
3711 }
3712
3713 static int io_provide_buffers(struct io_kiocb *req, bool force_nonblock,
3714                               struct io_comp_state *cs)
3715 {
3716         struct io_provide_buf *p = &req->pbuf;
3717         struct io_ring_ctx *ctx = req->ctx;
3718         struct io_buffer *head, *list;
3719         int ret = 0;
3720
3721         io_ring_submit_lock(ctx, !force_nonblock);
3722
3723         lockdep_assert_held(&ctx->uring_lock);
3724
3725         list = head = idr_find(&ctx->io_buffer_idr, p->bgid);
3726
3727         ret = io_add_buffers(p, &head);
3728         if (ret < 0)
3729                 goto out;
3730
3731         if (!list) {
3732                 ret = idr_alloc(&ctx->io_buffer_idr, head, p->bgid, p->bgid + 1,
3733                                         GFP_KERNEL);
3734                 if (ret < 0) {
3735                         __io_remove_buffers(ctx, head, p->bgid, -1U);
3736                         goto out;
3737                 }
3738         }
3739 out:
3740         io_ring_submit_unlock(ctx, !force_nonblock);
3741         if (ret < 0)
3742                 req_set_fail_links(req);
3743         __io_req_complete(req, ret, 0, cs);
3744         return 0;
3745 }
3746
3747 static int io_epoll_ctl_prep(struct io_kiocb *req,
3748                              const struct io_uring_sqe *sqe)
3749 {
3750 #if defined(CONFIG_EPOLL)
3751         if (sqe->ioprio || sqe->buf_index)
3752                 return -EINVAL;
3753         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3754                 return -EINVAL;
3755
3756         req->epoll.epfd = READ_ONCE(sqe->fd);
3757         req->epoll.op = READ_ONCE(sqe->len);
3758         req->epoll.fd = READ_ONCE(sqe->off);
3759
3760         if (ep_op_has_event(req->epoll.op)) {
3761                 struct epoll_event __user *ev;
3762
3763                 ev = u64_to_user_ptr(READ_ONCE(sqe->addr));
3764                 if (copy_from_user(&req->epoll.event, ev, sizeof(*ev)))
3765                         return -EFAULT;
3766         }
3767
3768         return 0;
3769 #else
3770         return -EOPNOTSUPP;
3771 #endif
3772 }
3773
3774 static int io_epoll_ctl(struct io_kiocb *req, bool force_nonblock,
3775                         struct io_comp_state *cs)
3776 {
3777 #if defined(CONFIG_EPOLL)
3778         struct io_epoll *ie = &req->epoll;
3779         int ret;
3780
3781         ret = do_epoll_ctl(ie->epfd, ie->op, ie->fd, &ie->event, force_nonblock);
3782         if (force_nonblock && ret == -EAGAIN)
3783                 return -EAGAIN;
3784
3785         if (ret < 0)
3786                 req_set_fail_links(req);
3787         __io_req_complete(req, ret, 0, cs);
3788         return 0;
3789 #else
3790         return -EOPNOTSUPP;
3791 #endif
3792 }
3793
3794 static int io_madvise_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3795 {
3796 #if defined(CONFIG_ADVISE_SYSCALLS) && defined(CONFIG_MMU)
3797         if (sqe->ioprio || sqe->buf_index || sqe->off)
3798                 return -EINVAL;
3799         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3800                 return -EINVAL;
3801
3802         req->madvise.addr = READ_ONCE(sqe->addr);
3803         req->madvise.len = READ_ONCE(sqe->len);
3804         req->madvise.advice = READ_ONCE(sqe->fadvise_advice);
3805         return 0;
3806 #else
3807         return -EOPNOTSUPP;
3808 #endif
3809 }
3810
3811 static int io_madvise(struct io_kiocb *req, bool force_nonblock)
3812 {
3813 #if defined(CONFIG_ADVISE_SYSCALLS) && defined(CONFIG_MMU)
3814         struct io_madvise *ma = &req->madvise;
3815         int ret;
3816
3817         if (force_nonblock)
3818                 return -EAGAIN;
3819
3820         ret = do_madvise(ma->addr, ma->len, ma->advice);
3821         if (ret < 0)
3822                 req_set_fail_links(req);
3823         io_req_complete(req, ret);
3824         return 0;
3825 #else
3826         return -EOPNOTSUPP;
3827 #endif
3828 }
3829
3830 static int io_fadvise_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3831 {
3832         if (sqe->ioprio || sqe->buf_index || sqe->addr)
3833                 return -EINVAL;
3834         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3835                 return -EINVAL;
3836
3837         req->fadvise.offset = READ_ONCE(sqe->off);
3838         req->fadvise.len = READ_ONCE(sqe->len);
3839         req->fadvise.advice = READ_ONCE(sqe->fadvise_advice);
3840         return 0;
3841 }
3842
3843 static int io_fadvise(struct io_kiocb *req, bool force_nonblock)
3844 {
3845         struct io_fadvise *fa = &req->fadvise;
3846         int ret;
3847
3848         if (force_nonblock) {
3849                 switch (fa->advice) {
3850                 case POSIX_FADV_NORMAL:
3851                 case POSIX_FADV_RANDOM:
3852                 case POSIX_FADV_SEQUENTIAL:
3853                         break;
3854                 default:
3855                         return -EAGAIN;
3856                 }
3857         }
3858
3859         ret = vfs_fadvise(req->file, fa->offset, fa->len, fa->advice);
3860         if (ret < 0)
3861                 req_set_fail_links(req);
3862         io_req_complete(req, ret);
3863         return 0;
3864 }
3865
3866 static int io_statx_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3867 {
3868         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3869                 return -EINVAL;
3870         if (sqe->ioprio || sqe->buf_index)
3871                 return -EINVAL;
3872         if (req->flags & REQ_F_FIXED_FILE)
3873                 return -EBADF;
3874
3875         req->statx.dfd = READ_ONCE(sqe->fd);
3876         req->statx.mask = READ_ONCE(sqe->len);
3877         req->statx.filename = u64_to_user_ptr(READ_ONCE(sqe->addr));
3878         req->statx.buffer = u64_to_user_ptr(READ_ONCE(sqe->addr2));
3879         req->statx.flags = READ_ONCE(sqe->statx_flags);
3880
3881         return 0;
3882 }
3883
3884 static int io_statx(struct io_kiocb *req, bool force_nonblock)
3885 {
3886         struct io_statx *ctx = &req->statx;
3887         int ret;
3888
3889         if (force_nonblock) {
3890                 /* only need file table for an actual valid fd */
3891                 if (ctx->dfd == -1 || ctx->dfd == AT_FDCWD)
3892                         req->flags |= REQ_F_NO_FILE_TABLE;
3893                 return -EAGAIN;
3894         }
3895
3896         ret = do_statx(ctx->dfd, ctx->filename, ctx->flags, ctx->mask,
3897                        ctx->buffer);
3898
3899         if (ret < 0)
3900                 req_set_fail_links(req);
3901         io_req_complete(req, ret);
3902         return 0;
3903 }
3904
3905 static int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3906 {
3907         /*
3908          * If we queue this for async, it must not be cancellable. That would
3909          * leave the 'file' in an undeterminate state, and here need to modify
3910          * io_wq_work.flags, so initialize io_wq_work firstly.
3911          */
3912         io_req_init_async(req);
3913         req->work.flags |= IO_WQ_WORK_NO_CANCEL;
3914
3915         if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
3916                 return -EINVAL;
3917         if (sqe->ioprio || sqe->off || sqe->addr || sqe->len ||
3918             sqe->rw_flags || sqe->buf_index)
3919                 return -EINVAL;
3920         if (req->flags & REQ_F_FIXED_FILE)
3921                 return -EBADF;
3922
3923         req->close.fd = READ_ONCE(sqe->fd);
3924         if ((req->file && req->file->f_op == &io_uring_fops) ||
3925             req->close.fd == req->ctx->ring_fd)
3926                 return -EBADF;
3927
3928         req->close.put_file = NULL;
3929         return 0;
3930 }
3931
3932 static int io_close(struct io_kiocb *req, bool force_nonblock,
3933                     struct io_comp_state *cs)
3934 {
3935         struct io_close *close = &req->close;
3936         int ret;
3937
3938         /* might be already done during nonblock submission */
3939         if (!close->put_file) {
3940                 ret = __close_fd_get_file(close->fd, &close->put_file);
3941                 if (ret < 0)
3942                         return (ret == -ENOENT) ? -EBADF : ret;
3943         }
3944
3945         /* if the file has a flush method, be safe and punt to async */
3946         if (close->put_file->f_op->flush && force_nonblock) {
3947                 /* was never set, but play safe */
3948                 req->flags &= ~REQ_F_NOWAIT;
3949                 /* avoid grabbing files - we don't need the files */
3950                 req->flags |= REQ_F_NO_FILE_TABLE;
3951                 return -EAGAIN;
3952         }
3953
3954         /* No ->flush() or already async, safely close from here */
3955         ret = filp_close(close->put_file, req->work.files);
3956         if (ret < 0)
3957                 req_set_fail_links(req);
3958         fput(close->put_file);
3959         close->put_file = NULL;
3960         __io_req_complete(req, ret, 0, cs);
3961         return 0;
3962 }
3963
3964 static int io_prep_sfr(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3965 {
3966         struct io_ring_ctx *ctx = req->ctx;
3967
3968         if (!req->file)
3969                 return -EBADF;
3970
3971         if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
3972                 return -EINVAL;
3973         if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
3974                 return -EINVAL;
3975
3976         req->sync.off = READ_ONCE(sqe->off);
3977         req->sync.len = READ_ONCE(sqe->len);
3978         req->sync.flags = READ_ONCE(sqe->sync_range_flags);
3979         return 0;
3980 }
3981
3982 static int io_sync_file_range(struct io_kiocb *req, bool force_nonblock)
3983 {
3984         int ret;
3985
3986         /* sync_file_range always requires a blocking context */
3987         if (force_nonblock)
3988                 return -EAGAIN;
3989
3990         ret = sync_file_range(req->file, req->sync.off, req->sync.len,
3991                                 req->sync.flags);
3992         if (ret < 0)
3993                 req_set_fail_links(req);
3994         io_req_complete(req, ret);
3995         return 0;
3996 }
3997
3998 #if defined(CONFIG_NET)
3999 static int io_setup_async_msg(struct io_kiocb *req,
4000                               struct io_async_msghdr *kmsg)
4001 {
4002         if (req->io)
4003                 return -EAGAIN;
4004         if (io_alloc_async_ctx(req)) {
4005                 if (kmsg->iov != kmsg->fast_iov)
4006                         kfree(kmsg->iov);
4007                 return -ENOMEM;
4008         }
4009         req->flags |= REQ_F_NEED_CLEANUP;
4010         memcpy(&req->io->msg, kmsg, sizeof(*kmsg));
4011         return -EAGAIN;
4012 }
4013
4014 static int io_sendmsg_copy_hdr(struct io_kiocb *req,
4015                                struct io_async_msghdr *iomsg)
4016 {
4017         iomsg->iov = iomsg->fast_iov;
4018         iomsg->msg.msg_name = &iomsg->addr;
4019         return sendmsg_copy_msghdr(&iomsg->msg, req->sr_msg.umsg,
4020                                    req->sr_msg.msg_flags, &iomsg->iov);
4021 }
4022
4023 static int io_sendmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4024 {
4025         struct io_sr_msg *sr = &req->sr_msg;
4026         struct io_async_ctx *io = req->io;
4027         int ret;
4028
4029         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
4030                 return -EINVAL;
4031
4032         sr->msg_flags = READ_ONCE(sqe->msg_flags);
4033         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
4034         sr->len = READ_ONCE(sqe->len);
4035
4036 #ifdef CONFIG_COMPAT
4037         if (req->ctx->compat)
4038                 sr->msg_flags |= MSG_CMSG_COMPAT;
4039 #endif
4040
4041         if (!io || req->opcode == IORING_OP_SEND)
4042                 return 0;
4043         /* iovec is already imported */
4044         if (req->flags & REQ_F_NEED_CLEANUP)
4045                 return 0;
4046
4047         ret = io_sendmsg_copy_hdr(req, &io->msg);
4048         if (!ret)
4049                 req->flags |= REQ_F_NEED_CLEANUP;
4050         return ret;
4051 }
4052
4053 static int io_sendmsg(struct io_kiocb *req, bool force_nonblock,
4054                       struct io_comp_state *cs)
4055 {
4056         struct io_async_msghdr iomsg, *kmsg;
4057         struct socket *sock;
4058         unsigned flags;
4059         int ret;
4060
4061         sock = sock_from_file(req->file, &ret);
4062         if (unlikely(!sock))
4063                 return ret;
4064
4065         if (req->io) {
4066                 kmsg = &req->io->msg;
4067                 kmsg->msg.msg_name = &req->io->msg.addr;
4068                 /* if iov is set, it's allocated already */
4069                 if (!kmsg->iov)
4070                         kmsg->iov = kmsg->fast_iov;
4071                 kmsg->msg.msg_iter.iov = kmsg->iov;
4072         } else {
4073                 ret = io_sendmsg_copy_hdr(req, &iomsg);
4074                 if (ret)
4075                         return ret;
4076                 kmsg = &iomsg;
4077         }
4078
4079         flags = req->sr_msg.msg_flags;
4080         if (flags & MSG_DONTWAIT)
4081                 req->flags |= REQ_F_NOWAIT;
4082         else if (force_nonblock)
4083                 flags |= MSG_DONTWAIT;
4084
4085         ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
4086         if (force_nonblock && ret == -EAGAIN)
4087                 return io_setup_async_msg(req, kmsg);
4088         if (ret == -ERESTARTSYS)
4089                 ret = -EINTR;
4090
4091         if (kmsg->iov != kmsg->fast_iov)
4092                 kfree(kmsg->iov);
4093         req->flags &= ~REQ_F_NEED_CLEANUP;
4094         if (ret < 0)
4095                 req_set_fail_links(req);
4096         __io_req_complete(req, ret, 0, cs);
4097         return 0;
4098 }
4099
4100 static int io_send(struct io_kiocb *req, bool force_nonblock,
4101                    struct io_comp_state *cs)
4102 {
4103         struct io_sr_msg *sr = &req->sr_msg;
4104         struct msghdr msg;
4105         struct iovec iov;
4106         struct socket *sock;
4107         unsigned flags;
4108         int ret;
4109
4110         sock = sock_from_file(req->file, &ret);
4111         if (unlikely(!sock))
4112                 return ret;
4113
4114         ret = import_single_range(WRITE, sr->buf, sr->len, &iov, &msg.msg_iter);
4115         if (unlikely(ret))
4116                 return ret;;
4117
4118         msg.msg_name = NULL;
4119         msg.msg_control = NULL;
4120         msg.msg_controllen = 0;
4121         msg.msg_namelen = 0;
4122
4123         flags = req->sr_msg.msg_flags;
4124         if (flags & MSG_DONTWAIT)
4125                 req->flags |= REQ_F_NOWAIT;
4126         else if (force_nonblock)
4127                 flags |= MSG_DONTWAIT;
4128
4129         msg.msg_flags = flags;
4130         ret = sock_sendmsg(sock, &msg);
4131         if (force_nonblock && ret == -EAGAIN)
4132                 return -EAGAIN;
4133         if (ret == -ERESTARTSYS)
4134                 ret = -EINTR;
4135
4136         if (ret < 0)
4137                 req_set_fail_links(req);
4138         __io_req_complete(req, ret, 0, cs);
4139         return 0;
4140 }
4141
4142 static int __io_recvmsg_copy_hdr(struct io_kiocb *req,
4143                                  struct io_async_msghdr *iomsg)
4144 {
4145         struct io_sr_msg *sr = &req->sr_msg;
4146         struct iovec __user *uiov;
4147         size_t iov_len;
4148         int ret;
4149
4150         ret = __copy_msghdr_from_user(&iomsg->msg, sr->umsg,
4151                                         &iomsg->uaddr, &uiov, &iov_len);
4152         if (ret)
4153                 return ret;
4154
4155         if (req->flags & REQ_F_BUFFER_SELECT) {
4156                 if (iov_len > 1)
4157                         return -EINVAL;
4158                 if (copy_from_user(iomsg->iov, uiov, sizeof(*uiov)))
4159                         return -EFAULT;
4160                 sr->len = iomsg->iov[0].iov_len;
4161                 iov_iter_init(&iomsg->msg.msg_iter, READ, iomsg->iov, 1,
4162                                 sr->len);
4163                 iomsg->iov = NULL;
4164         } else {
4165                 ret = import_iovec(READ, uiov, iov_len, UIO_FASTIOV,
4166                                         &iomsg->iov, &iomsg->msg.msg_iter);
4167                 if (ret > 0)
4168                         ret = 0;
4169         }
4170
4171         return ret;
4172 }
4173
4174 #ifdef CONFIG_COMPAT
4175 static int __io_compat_recvmsg_copy_hdr(struct io_kiocb *req,
4176                                         struct io_async_msghdr *iomsg)
4177 {
4178         struct compat_msghdr __user *msg_compat;
4179         struct io_sr_msg *sr = &req->sr_msg;
4180         struct compat_iovec __user *uiov;
4181         compat_uptr_t ptr;
4182         compat_size_t len;
4183         int ret;
4184
4185         msg_compat = (struct compat_msghdr __user *) sr->umsg;
4186         ret = __get_compat_msghdr(&iomsg->msg, msg_compat, &iomsg->uaddr,
4187                                         &ptr, &len);
4188         if (ret)
4189                 return ret;
4190
4191         uiov = compat_ptr(ptr);
4192         if (req->flags & REQ_F_BUFFER_SELECT) {
4193                 compat_ssize_t clen;
4194
4195                 if (len > 1)
4196                         return -EINVAL;
4197                 if (!access_ok(uiov, sizeof(*uiov)))
4198                         return -EFAULT;
4199                 if (__get_user(clen, &uiov->iov_len))
4200                         return -EFAULT;
4201                 if (clen < 0)
4202                         return -EINVAL;
4203                 sr->len = iomsg->iov[0].iov_len;
4204                 iomsg->iov = NULL;
4205         } else {
4206                 ret = compat_import_iovec(READ, uiov, len, UIO_FASTIOV,
4207                                                 &iomsg->iov,
4208                                                 &iomsg->msg.msg_iter);
4209                 if (ret < 0)
4210                         return ret;
4211         }
4212
4213         return 0;
4214 }
4215 #endif
4216
4217 static int io_recvmsg_copy_hdr(struct io_kiocb *req,
4218                                struct io_async_msghdr *iomsg)
4219 {
4220         iomsg->msg.msg_name = &iomsg->addr;
4221         iomsg->iov = iomsg->fast_iov;
4222
4223 #ifdef CONFIG_COMPAT
4224         if (req->ctx->compat)
4225                 return __io_compat_recvmsg_copy_hdr(req, iomsg);
4226 #endif
4227
4228         return __io_recvmsg_copy_hdr(req, iomsg);
4229 }
4230
4231 static struct io_buffer *io_recv_buffer_select(struct io_kiocb *req,
4232                                                bool needs_lock)
4233 {
4234         struct io_sr_msg *sr = &req->sr_msg;
4235         struct io_buffer *kbuf;
4236
4237         kbuf = io_buffer_select(req, &sr->len, sr->bgid, sr->kbuf, needs_lock);
4238         if (IS_ERR(kbuf))
4239                 return kbuf;
4240
4241         sr->kbuf = kbuf;
4242         req->flags |= REQ_F_BUFFER_SELECTED;
4243         return kbuf;
4244 }
4245
4246 static inline unsigned int io_put_recv_kbuf(struct io_kiocb *req)
4247 {
4248         return io_put_kbuf(req, req->sr_msg.kbuf);
4249 }
4250
4251 static int io_recvmsg_prep(struct io_kiocb *req,
4252                            const struct io_uring_sqe *sqe)
4253 {
4254         struct io_sr_msg *sr = &req->sr_msg;
4255         struct io_async_ctx *io = req->io;
4256         int ret;
4257
4258         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
4259                 return -EINVAL;
4260
4261         sr->msg_flags = READ_ONCE(sqe->msg_flags);
4262         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
4263         sr->len = READ_ONCE(sqe->len);
4264         sr->bgid = READ_ONCE(sqe->buf_group);
4265
4266 #ifdef CONFIG_COMPAT
4267         if (req->ctx->compat)
4268                 sr->msg_flags |= MSG_CMSG_COMPAT;
4269 #endif
4270
4271         if (!io || req->opcode == IORING_OP_RECV)
4272                 return 0;
4273         /* iovec is already imported */
4274         if (req->flags & REQ_F_NEED_CLEANUP)
4275                 return 0;
4276
4277         ret = io_recvmsg_copy_hdr(req, &io->msg);
4278         if (!ret)
4279                 req->flags |= REQ_F_NEED_CLEANUP;
4280         return ret;
4281 }
4282
4283 static int io_recvmsg(struct io_kiocb *req, bool force_nonblock,
4284                       struct io_comp_state *cs)
4285 {
4286         struct io_async_msghdr iomsg, *kmsg;
4287         struct socket *sock;
4288         struct io_buffer *kbuf;
4289         unsigned flags;
4290         int ret, cflags = 0;
4291
4292         sock = sock_from_file(req->file, &ret);
4293         if (unlikely(!sock))
4294                 return ret;
4295
4296         if (req->io) {
4297                 kmsg = &req->io->msg;
4298                 kmsg->msg.msg_name = &req->io->msg.addr;
4299                 /* if iov is set, it's allocated already */
4300                 if (!kmsg->iov)
4301                         kmsg->iov = kmsg->fast_iov;
4302                 kmsg->msg.msg_iter.iov = kmsg->iov;
4303         } else {
4304                 ret = io_recvmsg_copy_hdr(req, &iomsg);
4305                 if (ret)
4306                         return ret;
4307                 kmsg = &iomsg;
4308         }
4309
4310         if (req->flags & REQ_F_BUFFER_SELECT) {
4311                 kbuf = io_recv_buffer_select(req, !force_nonblock);
4312                 if (IS_ERR(kbuf))
4313                         return PTR_ERR(kbuf);
4314                 kmsg->fast_iov[0].iov_base = u64_to_user_ptr(kbuf->addr);
4315                 iov_iter_init(&kmsg->msg.msg_iter, READ, kmsg->iov,
4316                                 1, req->sr_msg.len);
4317         }
4318
4319         flags = req->sr_msg.msg_flags;
4320         if (flags & MSG_DONTWAIT)
4321                 req->flags |= REQ_F_NOWAIT;
4322         else if (force_nonblock)
4323                 flags |= MSG_DONTWAIT;
4324
4325         ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.umsg,
4326                                         kmsg->uaddr, flags);
4327         if (force_nonblock && ret == -EAGAIN)
4328                 return io_setup_async_msg(req, kmsg);
4329         if (ret == -ERESTARTSYS)
4330                 ret = -EINTR;
4331
4332         if (req->flags & REQ_F_BUFFER_SELECTED)
4333                 cflags = io_put_recv_kbuf(req);
4334         if (kmsg->iov != kmsg->fast_iov)
4335                 kfree(kmsg->iov);
4336         req->flags &= ~REQ_F_NEED_CLEANUP;
4337         if (ret < 0)
4338                 req_set_fail_links(req);
4339         __io_req_complete(req, ret, cflags, cs);
4340         return 0;
4341 }
4342
4343 static int io_recv(struct io_kiocb *req, bool force_nonblock,
4344                    struct io_comp_state *cs)
4345 {
4346         struct io_buffer *kbuf;
4347         struct io_sr_msg *sr = &req->sr_msg;
4348         struct msghdr msg;
4349         void __user *buf = sr->buf;
4350         struct socket *sock;
4351         struct iovec iov;
4352         unsigned flags;
4353         int ret, cflags = 0;
4354
4355         sock = sock_from_file(req->file, &ret);
4356         if (unlikely(!sock))
4357                 return ret;
4358
4359         if (req->flags & REQ_F_BUFFER_SELECT) {
4360                 kbuf = io_recv_buffer_select(req, !force_nonblock);
4361                 if (IS_ERR(kbuf))
4362                         return PTR_ERR(kbuf);
4363                 buf = u64_to_user_ptr(kbuf->addr);
4364         }
4365
4366         ret = import_single_range(READ, buf, sr->len, &iov, &msg.msg_iter);
4367         if (unlikely(ret))
4368                 goto out_free;
4369
4370         msg.msg_name = NULL;
4371         msg.msg_control = NULL;
4372         msg.msg_controllen = 0;
4373         msg.msg_namelen = 0;
4374         msg.msg_iocb = NULL;
4375         msg.msg_flags = 0;
4376
4377         flags = req->sr_msg.msg_flags;
4378         if (flags & MSG_DONTWAIT)
4379                 req->flags |= REQ_F_NOWAIT;
4380         else if (force_nonblock)
4381                 flags |= MSG_DONTWAIT;
4382
4383         ret = sock_recvmsg(sock, &msg, flags);
4384         if (force_nonblock && ret == -EAGAIN)
4385                 return -EAGAIN;
4386         if (ret == -ERESTARTSYS)
4387                 ret = -EINTR;
4388 out_free:
4389         if (req->flags & REQ_F_BUFFER_SELECTED)
4390                 cflags = io_put_recv_kbuf(req);
4391         if (ret < 0)
4392                 req_set_fail_links(req);
4393         __io_req_complete(req, ret, cflags, cs);
4394         return 0;
4395 }
4396
4397 static int io_accept_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4398 {
4399         struct io_accept *accept = &req->accept;
4400
4401         if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
4402                 return -EINVAL;
4403         if (sqe->ioprio || sqe->len || sqe->buf_index)
4404                 return -EINVAL;
4405
4406         accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
4407         accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
4408         accept->flags = READ_ONCE(sqe->accept_flags);
4409         accept->nofile = rlimit(RLIMIT_NOFILE);
4410         return 0;
4411 }
4412
4413 static int io_accept(struct io_kiocb *req, bool force_nonblock,
4414                      struct io_comp_state *cs)
4415 {
4416         struct io_accept *accept = &req->accept;
4417         unsigned int file_flags = force_nonblock ? O_NONBLOCK : 0;
4418         int ret;
4419
4420         if (req->file->f_flags & O_NONBLOCK)
4421                 req->flags |= REQ_F_NOWAIT;
4422
4423         ret = __sys_accept4_file(req->file, file_flags, accept->addr,
4424                                         accept->addr_len, accept->flags,
4425                                         accept->nofile);
4426         if (ret == -EAGAIN && force_nonblock)
4427                 return -EAGAIN;
4428         if (ret < 0) {
4429                 if (ret == -ERESTARTSYS)
4430                         ret = -EINTR;
4431                 req_set_fail_links(req);
4432         }
4433         __io_req_complete(req, ret, 0, cs);
4434         return 0;
4435 }
4436
4437 static int io_connect_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4438 {
4439         struct io_connect *conn = &req->connect;
4440         struct io_async_ctx *io = req->io;
4441
4442         if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
4443                 return -EINVAL;
4444         if (sqe->ioprio || sqe->len || sqe->buf_index || sqe->rw_flags)
4445                 return -EINVAL;
4446
4447         conn->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
4448         conn->addr_len =  READ_ONCE(sqe->addr2);
4449
4450         if (!io)
4451                 return 0;
4452
4453         return move_addr_to_kernel(conn->addr, conn->addr_len,
4454                                         &io->connect.address);
4455 }
4456
4457 static int io_connect(struct io_kiocb *req, bool force_nonblock,
4458                       struct io_comp_state *cs)
4459 {
4460         struct io_async_ctx __io, *io;
4461         unsigned file_flags;
4462         int ret;
4463
4464         if (req->io) {
4465                 io = req->io;
4466         } else {
4467                 ret = move_addr_to_kernel(req->connect.addr,
4468                                                 req->connect.addr_len,
4469                                                 &__io.connect.address);
4470                 if (ret)
4471                         goto out;
4472                 io = &__io;
4473         }
4474
4475         file_flags = force_nonblock ? O_NONBLOCK : 0;
4476
4477         ret = __sys_connect_file(req->file, &io->connect.address,
4478                                         req->connect.addr_len, file_flags);
4479         if ((ret == -EAGAIN || ret == -EINPROGRESS) && force_nonblock) {
4480                 if (req->io)
4481                         return -EAGAIN;
4482                 if (io_alloc_async_ctx(req)) {
4483                         ret = -ENOMEM;
4484                         goto out;
4485                 }
4486                 memcpy(&req->io->connect, &__io.connect, sizeof(__io.connect));
4487                 return -EAGAIN;
4488         }
4489         if (ret == -ERESTARTSYS)
4490                 ret = -EINTR;
4491 out:
4492         if (ret < 0)
4493                 req_set_fail_links(req);
4494         __io_req_complete(req, ret, 0, cs);
4495         return 0;
4496 }
4497 #else /* !CONFIG_NET */
4498 static int io_sendmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4499 {
4500         return -EOPNOTSUPP;
4501 }
4502
4503 static int io_sendmsg(struct io_kiocb *req, bool force_nonblock,
4504                       struct io_comp_state *cs)
4505 {
4506         return -EOPNOTSUPP;
4507 }
4508
4509 static int io_send(struct io_kiocb *req, bool force_nonblock,
4510                    struct io_comp_state *cs)
4511 {
4512         return -EOPNOTSUPP;
4513 }
4514
4515 static int io_recvmsg_prep(struct io_kiocb *req,
4516                            const struct io_uring_sqe *sqe)
4517 {
4518         return -EOPNOTSUPP;
4519 }
4520
4521 static int io_recvmsg(struct io_kiocb *req, bool force_nonblock,
4522                       struct io_comp_state *cs)
4523 {
4524         return -EOPNOTSUPP;
4525 }
4526
4527 static int io_recv(struct io_kiocb *req, bool force_nonblock,
4528                    struct io_comp_state *cs)
4529 {
4530         return -EOPNOTSUPP;
4531 }
4532
4533 static int io_accept_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4534 {
4535         return -EOPNOTSUPP;
4536 }
4537
4538 static int io_accept(struct io_kiocb *req, bool force_nonblock,
4539                      struct io_comp_state *cs)
4540 {
4541         return -EOPNOTSUPP;
4542 }
4543
4544 static int io_connect_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4545 {
4546         return -EOPNOTSUPP;
4547 }
4548
4549 static int io_connect(struct io_kiocb *req, bool force_nonblock,
4550                       struct io_comp_state *cs)
4551 {
4552         return -EOPNOTSUPP;
4553 }
4554 #endif /* CONFIG_NET */
4555
4556 struct io_poll_table {
4557         struct poll_table_struct pt;
4558         struct io_kiocb *req;
4559         int error;
4560 };
4561
4562 static int __io_async_wake(struct io_kiocb *req, struct io_poll_iocb *poll,
4563                            __poll_t mask, task_work_func_t func)
4564 {
4565         int ret;
4566
4567         /* for instances that support it check for an event match first: */
4568         if (mask && !(mask & poll->events))
4569                 return 0;
4570
4571         trace_io_uring_task_add(req->ctx, req->opcode, req->user_data, mask);
4572
4573         list_del_init(&poll->wait.entry);
4574
4575         req->result = mask;
4576         init_task_work(&req->task_work, func);
4577         percpu_ref_get(&req->ctx->refs);
4578
4579         /*
4580          * If this fails, then the task is exiting. When a task exits, the
4581          * work gets canceled, so just cancel this request as well instead
4582          * of executing it. We can't safely execute it anyway, as we may not
4583          * have the needed state needed for it anyway.
4584          */
4585         ret = io_req_task_work_add(req, &req->task_work);
4586         if (unlikely(ret)) {
4587                 struct task_struct *tsk;
4588
4589                 WRITE_ONCE(poll->canceled, true);
4590                 tsk = io_wq_get_task(req->ctx->io_wq);
4591                 task_work_add(tsk, &req->task_work, 0);
4592                 wake_up_process(tsk);
4593         }
4594         return 1;
4595 }
4596
4597 static bool io_poll_rewait(struct io_kiocb *req, struct io_poll_iocb *poll)
4598         __acquires(&req->ctx->completion_lock)
4599 {
4600         struct io_ring_ctx *ctx = req->ctx;
4601
4602         if (!req->result && !READ_ONCE(poll->canceled)) {
4603                 struct poll_table_struct pt = { ._key = poll->events };
4604
4605                 req->result = vfs_poll(req->file, &pt) & poll->events;
4606         }
4607
4608         spin_lock_irq(&ctx->completion_lock);
4609         if (!req->result && !READ_ONCE(poll->canceled)) {
4610                 add_wait_queue(poll->head, &poll->wait);
4611                 return true;
4612         }
4613
4614         return false;
4615 }
4616
4617 static void io_poll_remove_double(struct io_kiocb *req, void *data)
4618 {
4619         struct io_poll_iocb *poll = data;
4620
4621         lockdep_assert_held(&req->ctx->completion_lock);
4622
4623         if (poll && poll->head) {
4624                 struct wait_queue_head *head = poll->head;
4625
4626                 spin_lock(&head->lock);
4627                 list_del_init(&poll->wait.entry);
4628                 if (poll->wait.private)
4629                         refcount_dec(&req->refs);
4630                 poll->head = NULL;
4631                 spin_unlock(&head->lock);
4632         }
4633 }
4634
4635 static void io_poll_complete(struct io_kiocb *req, __poll_t mask, int error)
4636 {
4637         struct io_ring_ctx *ctx = req->ctx;
4638
4639         io_poll_remove_double(req, req->io);
4640         req->poll.done = true;
4641         io_cqring_fill_event(req, error ? error : mangle_poll(mask));
4642         io_commit_cqring(ctx);
4643 }
4644
4645 static void io_poll_task_handler(struct io_kiocb *req, struct io_kiocb **nxt)
4646 {
4647         struct io_ring_ctx *ctx = req->ctx;
4648
4649         if (io_poll_rewait(req, &req->poll)) {
4650                 spin_unlock_irq(&ctx->completion_lock);
4651                 return;
4652         }
4653
4654         hash_del(&req->hash_node);
4655         io_poll_complete(req, req->result, 0);
4656         req->flags |= REQ_F_COMP_LOCKED;
4657         *nxt = io_put_req_find_next(req);
4658         spin_unlock_irq(&ctx->completion_lock);
4659
4660         io_cqring_ev_posted(ctx);
4661 }
4662
4663 static void io_poll_task_func(struct callback_head *cb)
4664 {
4665         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
4666         struct io_ring_ctx *ctx = req->ctx;
4667         struct io_kiocb *nxt = NULL;
4668
4669         io_poll_task_handler(req, &nxt);
4670         if (nxt)
4671                 __io_req_task_submit(nxt);
4672         percpu_ref_put(&ctx->refs);
4673 }
4674
4675 static int io_poll_double_wake(struct wait_queue_entry *wait, unsigned mode,
4676                                int sync, void *key)
4677 {
4678         struct io_kiocb *req = wait->private;
4679         struct io_poll_iocb *poll = req->apoll->double_poll;
4680         __poll_t mask = key_to_poll(key);
4681
4682         /* for instances that support it check for an event match first: */
4683         if (mask && !(mask & poll->events))
4684                 return 0;
4685
4686         if (poll && poll->head) {
4687                 bool done;
4688
4689                 spin_lock(&poll->head->lock);
4690                 done = list_empty(&poll->wait.entry);
4691                 if (!done)
4692                         list_del_init(&poll->wait.entry);
4693                 spin_unlock(&poll->head->lock);
4694                 if (!done)
4695                         __io_async_wake(req, poll, mask, io_poll_task_func);
4696         }
4697         refcount_dec(&req->refs);
4698         return 1;
4699 }
4700
4701 static void io_init_poll_iocb(struct io_poll_iocb *poll, __poll_t events,
4702                               wait_queue_func_t wake_func)
4703 {
4704         poll->head = NULL;
4705         poll->done = false;
4706         poll->canceled = false;
4707         poll->events = events;
4708         INIT_LIST_HEAD(&poll->wait.entry);
4709         init_waitqueue_func_entry(&poll->wait, wake_func);
4710 }
4711
4712 static void __io_queue_proc(struct io_poll_iocb *poll, struct io_poll_table *pt,
4713                             struct wait_queue_head *head,
4714                             struct io_poll_iocb **poll_ptr)
4715 {
4716         struct io_kiocb *req = pt->req;
4717
4718         /*
4719          * If poll->head is already set, it's because the file being polled
4720          * uses multiple waitqueues for poll handling (eg one for read, one
4721          * for write). Setup a separate io_poll_iocb if this happens.
4722          */
4723         if (unlikely(poll->head)) {
4724                 /* already have a 2nd entry, fail a third attempt */
4725                 if (*poll_ptr) {
4726                         pt->error = -EINVAL;
4727                         return;
4728                 }
4729                 poll = kmalloc(sizeof(*poll), GFP_ATOMIC);
4730                 if (!poll) {
4731                         pt->error = -ENOMEM;
4732                         return;
4733                 }
4734                 io_init_poll_iocb(poll, req->poll.events, io_poll_double_wake);
4735                 refcount_inc(&req->refs);
4736                 poll->wait.private = req;
4737                 *poll_ptr = poll;
4738         }
4739
4740         pt->error = 0;
4741         poll->head = head;
4742
4743         if (poll->events & EPOLLEXCLUSIVE)
4744                 add_wait_queue_exclusive(head, &poll->wait);
4745         else
4746                 add_wait_queue(head, &poll->wait);
4747 }
4748
4749 static void io_async_queue_proc(struct file *file, struct wait_queue_head *head,
4750                                struct poll_table_struct *p)
4751 {
4752         struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);
4753         struct async_poll *apoll = pt->req->apoll;
4754
4755         __io_queue_proc(&apoll->poll, pt, head, &apoll->double_poll);
4756 }
4757
4758 static void io_async_task_func(struct callback_head *cb)
4759 {
4760         struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work);
4761         struct async_poll *apoll = req->apoll;
4762         struct io_ring_ctx *ctx = req->ctx;
4763
4764         trace_io_uring_task_run(req->ctx, req->opcode, req->user_data);
4765
4766         if (io_poll_rewait(req, &apoll->poll)) {
4767                 spin_unlock_irq(&ctx->completion_lock);
4768                 percpu_ref_put(&ctx->refs);
4769                 return;
4770         }
4771
4772         /* If req is still hashed, it cannot have been canceled. Don't check. */
4773         if (hash_hashed(&req->hash_node))
4774                 hash_del(&req->hash_node);
4775
4776         io_poll_remove_double(req, apoll->double_poll);
4777         spin_unlock_irq(&ctx->completion_lock);
4778
4779         if (!READ_ONCE(apoll->poll.canceled))
4780                 __io_req_task_submit(req);
4781         else
4782                 __io_req_task_cancel(req, -ECANCELED);
4783
4784         percpu_ref_put(&ctx->refs);
4785         kfree(apoll->double_poll);
4786         kfree(apoll);
4787 }
4788
4789 static int io_async_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
4790                         void *key)
4791 {
4792         struct io_kiocb *req = wait->private;
4793         struct io_poll_iocb *poll = &req->apoll->poll;
4794
4795         trace_io_uring_poll_wake(req->ctx, req->opcode, req->user_data,
4796                                         key_to_poll(key));
4797
4798         return __io_async_wake(req, poll, key_to_poll(key), io_async_task_func);
4799 }
4800
4801 static void io_poll_req_insert(struct io_kiocb *req)
4802 {
4803         struct io_ring_ctx *ctx = req->ctx;
4804         struct hlist_head *list;
4805
4806         list = &ctx->cancel_hash[hash_long(req->user_data, ctx->cancel_hash_bits)];
4807         hlist_add_head(&req->hash_node, list);
4808 }
4809
4810 static __poll_t __io_arm_poll_handler(struct io_kiocb *req,
4811                                       struct io_poll_iocb *poll,
4812                                       struct io_poll_table *ipt, __poll_t mask,
4813                                       wait_queue_func_t wake_func)
4814         __acquires(&ctx->completion_lock)
4815 {
4816         struct io_ring_ctx *ctx = req->ctx;
4817         bool cancel = false;
4818
4819         io_init_poll_iocb(poll, mask, wake_func);
4820         poll->file = req->file;
4821         poll->wait.private = req;
4822
4823         ipt->pt._key = mask;
4824         ipt->req = req;
4825         ipt->error = -EINVAL;
4826
4827         mask = vfs_poll(req->file, &ipt->pt) & poll->events;
4828
4829         spin_lock_irq(&ctx->completion_lock);
4830         if (likely(poll->head)) {
4831                 spin_lock(&poll->head->lock);
4832                 if (unlikely(list_empty(&poll->wait.entry))) {
4833                         if (ipt->error)
4834                                 cancel = true;
4835                         ipt->error = 0;
4836                         mask = 0;
4837                 }
4838                 if (mask || ipt->error)
4839                         list_del_init(&poll->wait.entry);
4840                 else if (cancel)
4841                         WRITE_ONCE(poll->canceled, true);
4842                 else if (!poll->done) /* actually waiting for an event */
4843                         io_poll_req_insert(req);
4844                 spin_unlock(&poll->head->lock);
4845         }
4846
4847         return mask;
4848 }
4849
4850 static bool io_arm_poll_handler(struct io_kiocb *req)
4851 {
4852         const struct io_op_def *def = &io_op_defs[req->opcode];
4853         struct io_ring_ctx *ctx = req->ctx;
4854         struct async_poll *apoll;
4855         struct io_poll_table ipt;
4856         __poll_t mask, ret;
4857
4858         if (!req->file || !file_can_poll(req->file))
4859                 return false;
4860         if (req->flags & REQ_F_POLLED)
4861                 return false;
4862         if (!def->pollin && !def->pollout)
4863                 return false;
4864
4865         apoll = kmalloc(sizeof(*apoll), GFP_ATOMIC);
4866         if (unlikely(!apoll))
4867                 return false;
4868         apoll->double_poll = NULL;
4869
4870         req->flags |= REQ_F_POLLED;
4871         io_get_req_task(req);
4872         req->apoll = apoll;
4873         INIT_HLIST_NODE(&req->hash_node);
4874
4875         mask = 0;
4876         if (def->pollin)
4877                 mask |= POLLIN | POLLRDNORM;
4878         if (def->pollout)
4879                 mask |= POLLOUT | POLLWRNORM;
4880         mask |= POLLERR | POLLPRI;
4881
4882         ipt.pt._qproc = io_async_queue_proc;
4883
4884         ret = __io_arm_poll_handler(req, &apoll->poll, &ipt, mask,
4885                                         io_async_wake);
4886         if (ret) {
4887                 io_poll_remove_double(req, apoll->double_poll);
4888                 spin_unlock_irq(&ctx->completion_lock);
4889                 kfree(apoll->double_poll);
4890                 kfree(apoll);
4891                 return false;
4892         }
4893         spin_unlock_irq(&ctx->completion_lock);
4894         trace_io_uring_poll_arm(ctx, req->opcode, req->user_data, mask,
4895                                         apoll->poll.events);
4896         return true;
4897 }
4898
4899 static bool __io_poll_remove_one(struct io_kiocb *req,
4900                                  struct io_poll_iocb *poll)
4901 {
4902         bool do_complete = false;
4903
4904         spin_lock(&poll->head->lock);
4905         WRITE_ONCE(poll->canceled, true);
4906         if (!list_empty(&poll->wait.entry)) {
4907                 list_del_init(&poll->wait.entry);
4908                 do_complete = true;
4909         }
4910         spin_unlock(&poll->head->lock);
4911         hash_del(&req->hash_node);
4912         return do_complete;
4913 }
4914
4915 static bool io_poll_remove_one(struct io_kiocb *req)
4916 {
4917         bool do_complete;
4918
4919         if (req->opcode == IORING_OP_POLL_ADD) {
4920                 io_poll_remove_double(req, req->io);
4921                 do_complete = __io_poll_remove_one(req, &req->poll);
4922         } else {
4923                 struct async_poll *apoll = req->apoll;
4924
4925                 io_poll_remove_double(req, apoll->double_poll);
4926
4927                 /* non-poll requests have submit ref still */
4928                 do_complete = __io_poll_remove_one(req, &apoll->poll);
4929                 if (do_complete) {
4930                         io_put_req(req);
4931                         kfree(apoll->double_poll);
4932                         kfree(apoll);
4933                 }
4934         }
4935
4936         if (do_complete) {
4937                 io_cqring_fill_event(req, -ECANCELED);
4938                 io_commit_cqring(req->ctx);
4939                 req->flags |= REQ_F_COMP_LOCKED;
4940                 io_put_req(req);
4941         }
4942
4943         return do_complete;
4944 }
4945
4946 static void io_poll_remove_all(struct io_ring_ctx *ctx)
4947 {
4948         struct hlist_node *tmp;
4949         struct io_kiocb *req;
4950         int posted = 0, i;
4951
4952         spin_lock_irq(&ctx->completion_lock);
4953         for (i = 0; i < (1U << ctx->cancel_hash_bits); i++) {
4954                 struct hlist_head *list;
4955
4956                 list = &ctx->cancel_hash[i];
4957                 hlist_for_each_entry_safe(req, tmp, list, hash_node)
4958                         posted += io_poll_remove_one(req);
4959         }
4960         spin_unlock_irq(&ctx->completion_lock);
4961
4962         if (posted)
4963                 io_cqring_ev_posted(ctx);
4964 }
4965
4966 static int io_poll_cancel(struct io_ring_ctx *ctx, __u64 sqe_addr)
4967 {
4968         struct hlist_head *list;
4969         struct io_kiocb *req;
4970
4971         list = &ctx->cancel_hash[hash_long(sqe_addr, ctx->cancel_hash_bits)];
4972         hlist_for_each_entry(req, list, hash_node) {
4973                 if (sqe_addr != req->user_data)
4974                         continue;
4975                 if (io_poll_remove_one(req))
4976                         return 0;
4977                 return -EALREADY;
4978         }
4979
4980         return -ENOENT;
4981 }
4982
4983 static int io_poll_remove_prep(struct io_kiocb *req,
4984                                const struct io_uring_sqe *sqe)
4985 {
4986         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
4987                 return -EINVAL;
4988         if (sqe->ioprio || sqe->off || sqe->len || sqe->buf_index ||
4989             sqe->poll_events)
4990                 return -EINVAL;
4991
4992         req->poll.addr = READ_ONCE(sqe->addr);
4993         return 0;
4994 }
4995
4996 /*
4997  * Find a running poll command that matches one specified in sqe->addr,
4998  * and remove it if found.
4999  */
5000 static int io_poll_remove(struct io_kiocb *req)
5001 {
5002         struct io_ring_ctx *ctx = req->ctx;
5003         u64 addr;
5004         int ret;
5005
5006         addr = req->poll.addr;
5007         spin_lock_irq(&ctx->completion_lock);
5008         ret = io_poll_cancel(ctx, addr);
5009         spin_unlock_irq(&ctx->completion_lock);
5010
5011         if (ret < 0)
5012                 req_set_fail_links(req);
5013         io_req_complete(req, ret);
5014         return 0;
5015 }
5016
5017 static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
5018                         void *key)
5019 {
5020         struct io_kiocb *req = wait->private;
5021         struct io_poll_iocb *poll = &req->poll;
5022
5023         return __io_async_wake(req, poll, key_to_poll(key), io_poll_task_func);
5024 }
5025
5026 static void io_poll_queue_proc(struct file *file, struct wait_queue_head *head,
5027                                struct poll_table_struct *p)
5028 {
5029         struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);
5030
5031         __io_queue_proc(&pt->req->poll, pt, head, (struct io_poll_iocb **) &pt->req->io);
5032 }
5033
5034 static int io_poll_add_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
5035 {
5036         struct io_poll_iocb *poll = &req->poll;
5037         u32 events;
5038
5039         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
5040                 return -EINVAL;
5041         if (sqe->addr || sqe->ioprio || sqe->off || sqe->len || sqe->buf_index)
5042                 return -EINVAL;
5043         if (!poll->file)
5044                 return -EBADF;
5045
5046         events = READ_ONCE(sqe->poll32_events);
5047 #ifdef __BIG_ENDIAN
5048         events = swahw32(events);
5049 #endif
5050         poll->events = demangle_poll(events) | EPOLLERR | EPOLLHUP |
5051                        (events & EPOLLEXCLUSIVE);
5052
5053         io_get_req_task(req);
5054         return 0;
5055 }
5056
5057 static int io_poll_add(struct io_kiocb *req)
5058 {
5059         struct io_poll_iocb *poll = &req->poll;
5060         struct io_ring_ctx *ctx = req->ctx;
5061         struct io_poll_table ipt;
5062         __poll_t mask;
5063
5064         INIT_HLIST_NODE(&req->hash_node);
5065         ipt.pt._qproc = io_poll_queue_proc;
5066
5067         mask = __io_arm_poll_handler(req, &req->poll, &ipt, poll->events,
5068                                         io_poll_wake);
5069
5070         if (mask) { /* no async, we'd stolen it */
5071                 ipt.error = 0;
5072                 io_poll_complete(req, mask, 0);
5073         }
5074         spin_unlock_irq(&ctx->completion_lock);
5075
5076         if (mask) {
5077                 io_cqring_ev_posted(ctx);
5078                 io_put_req(req);
5079         }
5080         return ipt.error;
5081 }
5082
5083 static enum hrtimer_restart io_timeout_fn(struct hrtimer *timer)
5084 {
5085         struct io_timeout_data *data = container_of(timer,
5086                                                 struct io_timeout_data, timer);
5087         struct io_kiocb *req = data->req;
5088         struct io_ring_ctx *ctx = req->ctx;
5089         unsigned long flags;
5090
5091         spin_lock_irqsave(&ctx->completion_lock, flags);
5092         atomic_set(&req->ctx->cq_timeouts,
5093                 atomic_read(&req->ctx->cq_timeouts) + 1);
5094
5095         /*
5096          * We could be racing with timeout deletion. If the list is empty,
5097          * then timeout lookup already found it and will be handling it.
5098          */
5099         if (!list_empty(&req->timeout.list))
5100                 list_del_init(&req->timeout.list);
5101
5102         io_cqring_fill_event(req, -ETIME);
5103         io_commit_cqring(ctx);
5104         spin_unlock_irqrestore(&ctx->completion_lock, flags);
5105
5106         io_cqring_ev_posted(ctx);
5107         req_set_fail_links(req);
5108         io_put_req(req);
5109         return HRTIMER_NORESTART;
5110 }
5111
5112 static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data)
5113 {
5114         struct io_kiocb *req;
5115         int ret = -ENOENT;
5116
5117         list_for_each_entry(req, &ctx->timeout_list, timeout.list) {
5118                 if (user_data == req->user_data) {
5119                         list_del_init(&req->timeout.list);
5120                         ret = 0;
5121                         break;
5122                 }
5123         }
5124
5125         if (ret == -ENOENT)
5126                 return ret;
5127
5128         ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
5129         if (ret == -1)
5130                 return -EALREADY;
5131
5132         req_set_fail_links(req);
5133         req->flags |= REQ_F_COMP_LOCKED;
5134         io_cqring_fill_event(req, -ECANCELED);
5135         io_put_req(req);
5136         return 0;
5137 }
5138
5139 static int io_timeout_remove_prep(struct io_kiocb *req,
5140                                   const struct io_uring_sqe *sqe)
5141 {
5142         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
5143                 return -EINVAL;
5144         if (unlikely(req->flags & (REQ_F_FIXED_FILE | REQ_F_BUFFER_SELECT)))
5145                 return -EINVAL;
5146         if (sqe->ioprio || sqe->buf_index || sqe->len)
5147                 return -EINVAL;
5148
5149         req->timeout.addr = READ_ONCE(sqe->addr);
5150         req->timeout.flags = READ_ONCE(sqe->timeout_flags);
5151         if (req->timeout.flags)
5152                 return -EINVAL;
5153
5154         return 0;
5155 }
5156
5157 /*
5158  * Remove or update an existing timeout command
5159  */
5160 static int io_timeout_remove(struct io_kiocb *req)
5161 {
5162         struct io_ring_ctx *ctx = req->ctx;
5163         int ret;
5164
5165         spin_lock_irq(&ctx->completion_lock);
5166         ret = io_timeout_cancel(ctx, req->timeout.addr);
5167
5168         io_cqring_fill_event(req, ret);
5169         io_commit_cqring(ctx);
5170         spin_unlock_irq(&ctx->completion_lock);
5171         io_cqring_ev_posted(ctx);
5172         if (ret < 0)
5173                 req_set_fail_links(req);
5174         io_put_req(req);
5175         return 0;
5176 }
5177
5178 static int io_timeout_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
5179                            bool is_timeout_link)
5180 {
5181         struct io_timeout_data *data;
5182         unsigned flags;
5183         u32 off = READ_ONCE(sqe->off);
5184
5185         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
5186                 return -EINVAL;
5187         if (sqe->ioprio || sqe->buf_index || sqe->len != 1)
5188                 return -EINVAL;
5189         if (off && is_timeout_link)
5190                 return -EINVAL;
5191         flags = READ_ONCE(sqe->timeout_flags);
5192         if (flags & ~IORING_TIMEOUT_ABS)
5193                 return -EINVAL;
5194
5195         req->timeout.off = off;
5196
5197         if (!req->io && io_alloc_async_ctx(req))
5198                 return -ENOMEM;
5199
5200         data = &req->io->timeout;
5201         data->req = req;
5202
5203         if (get_timespec64(&data->ts, u64_to_user_ptr(sqe->addr)))
5204                 return -EFAULT;
5205
5206         if (flags & IORING_TIMEOUT_ABS)
5207                 data->mode = HRTIMER_MODE_ABS;
5208         else
5209                 data->mode = HRTIMER_MODE_REL;
5210
5211         hrtimer_init(&data->timer, CLOCK_MONOTONIC, data->mode);
5212         return 0;
5213 }
5214
5215 static int io_timeout(struct io_kiocb *req)
5216 {
5217         struct io_ring_ctx *ctx = req->ctx;
5218         struct io_timeout_data *data = &req->io->timeout;
5219         struct list_head *entry;
5220         u32 tail, off = req->timeout.off;
5221
5222         spin_lock_irq(&ctx->completion_lock);
5223
5224         /*
5225          * sqe->off holds how many events that need to occur for this
5226          * timeout event to be satisfied. If it isn't set, then this is
5227          * a pure timeout request, sequence isn't used.
5228          */
5229         if (io_is_timeout_noseq(req)) {
5230                 entry = ctx->timeout_list.prev;
5231                 goto add;
5232         }
5233
5234         tail = ctx->cached_cq_tail - atomic_read(&ctx->cq_timeouts);
5235         req->timeout.target_seq = tail + off;
5236
5237         /*
5238          * Insertion sort, ensuring the first entry in the list is always
5239          * the one we need first.
5240          */
5241         list_for_each_prev(entry, &ctx->timeout_list) {
5242                 struct io_kiocb *nxt = list_entry(entry, struct io_kiocb,
5243                                                   timeout.list);
5244
5245                 if (io_is_timeout_noseq(nxt))
5246                         continue;
5247                 /* nxt.seq is behind @tail, otherwise would've been completed */
5248                 if (off >= nxt->timeout.target_seq - tail)
5249                         break;
5250         }
5251 add:
5252         list_add(&req->timeout.list, entry);
5253         data->timer.function = io_timeout_fn;
5254         hrtimer_start(&data->timer, timespec64_to_ktime(data->ts), data->mode);
5255         spin_unlock_irq(&ctx->completion_lock);
5256         return 0;
5257 }
5258
5259 static bool io_cancel_cb(struct io_wq_work *work, void *data)
5260 {
5261         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
5262
5263         return req->user_data == (unsigned long) data;
5264 }
5265
5266 static int io_async_cancel_one(struct io_ring_ctx *ctx, void *sqe_addr)
5267 {
5268         enum io_wq_cancel cancel_ret;
5269         int ret = 0;
5270
5271         cancel_ret = io_wq_cancel_cb(ctx->io_wq, io_cancel_cb, sqe_addr, false);
5272         switch (cancel_ret) {
5273         case IO_WQ_CANCEL_OK:
5274                 ret = 0;
5275                 break;
5276         case IO_WQ_CANCEL_RUNNING:
5277                 ret = -EALREADY;
5278                 break;
5279         case IO_WQ_CANCEL_NOTFOUND:
5280                 ret = -ENOENT;
5281                 break;
5282         }
5283
5284         return ret;
5285 }
5286
5287 static void io_async_find_and_cancel(struct io_ring_ctx *ctx,
5288                                      struct io_kiocb *req, __u64 sqe_addr,
5289                                      int success_ret)
5290 {
5291         unsigned long flags;
5292         int ret;
5293
5294         ret = io_async_cancel_one(ctx, (void *) (unsigned long) sqe_addr);
5295         if (ret != -ENOENT) {
5296                 spin_lock_irqsave(&ctx->completion_lock, flags);
5297                 goto done;
5298         }
5299
5300         spin_lock_irqsave(&ctx->completion_lock, flags);
5301         ret = io_timeout_cancel(ctx, sqe_addr);
5302         if (ret != -ENOENT)
5303                 goto done;
5304         ret = io_poll_cancel(ctx, sqe_addr);
5305 done:
5306         if (!ret)
5307                 ret = success_ret;
5308         io_cqring_fill_event(req, ret);
5309         io_commit_cqring(ctx);
5310         spin_unlock_irqrestore(&ctx->completion_lock, flags);
5311         io_cqring_ev_posted(ctx);
5312
5313         if (ret < 0)
5314                 req_set_fail_links(req);
5315         io_put_req(req);
5316 }
5317
5318 static int io_async_cancel_prep(struct io_kiocb *req,
5319                                 const struct io_uring_sqe *sqe)
5320 {
5321         if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
5322                 return -EINVAL;
5323         if (unlikely(req->flags & (REQ_F_FIXED_FILE | REQ_F_BUFFER_SELECT)))
5324                 return -EINVAL;
5325         if (sqe->ioprio || sqe->off || sqe->len || sqe->cancel_flags)
5326                 return -EINVAL;
5327
5328         req->cancel.addr = READ_ONCE(sqe->addr);
5329         return 0;
5330 }
5331
5332 static int io_async_cancel(struct io_kiocb *req)
5333 {
5334         struct io_ring_ctx *ctx = req->ctx;
5335
5336         io_async_find_and_cancel(ctx, req, req->cancel.addr, 0);
5337         return 0;
5338 }
5339
5340 static int io_files_update_prep(struct io_kiocb *req,
5341                                 const struct io_uring_sqe *sqe)
5342 {
5343         if (unlikely(req->flags & (REQ_F_FIXED_FILE | REQ_F_BUFFER_SELECT)))
5344                 return -EINVAL;
5345         if (sqe->ioprio || sqe->rw_flags)
5346                 return -EINVAL;
5347
5348         req->files_update.offset = READ_ONCE(sqe->off);
5349         req->files_update.nr_args = READ_ONCE(sqe->len);
5350         if (!req->files_update.nr_args)
5351                 return -EINVAL;
5352         req->files_update.arg = READ_ONCE(sqe->addr);
5353         return 0;
5354 }
5355
5356 static int io_files_update(struct io_kiocb *req, bool force_nonblock,
5357                            struct io_comp_state *cs)
5358 {
5359         struct io_ring_ctx *ctx = req->ctx;
5360         struct io_uring_files_update up;
5361         int ret;
5362
5363         if (force_nonblock)
5364                 return -EAGAIN;
5365
5366         up.offset = req->files_update.offset;
5367         up.fds = req->files_update.arg;
5368
5369         mutex_lock(&ctx->uring_lock);
5370         ret = __io_sqe_files_update(ctx, &up, req->files_update.nr_args);
5371         mutex_unlock(&ctx->uring_lock);
5372
5373         if (ret < 0)
5374                 req_set_fail_links(req);
5375         __io_req_complete(req, ret, 0, cs);
5376         return 0;
5377 }
5378
5379 static int io_req_defer_prep(struct io_kiocb *req,
5380                              const struct io_uring_sqe *sqe)
5381 {
5382         ssize_t ret = 0;
5383
5384         if (!sqe)
5385                 return 0;
5386
5387         if (io_alloc_async_ctx(req))
5388                 return -EAGAIN;
5389         ret = io_prep_work_files(req);
5390         if (unlikely(ret))
5391                 return ret;
5392
5393         switch (req->opcode) {
5394         case IORING_OP_NOP:
5395                 break;
5396         case IORING_OP_READV:
5397         case IORING_OP_READ_FIXED:
5398         case IORING_OP_READ:
5399                 ret = io_read_prep(req, sqe, true);
5400                 break;
5401         case IORING_OP_WRITEV:
5402         case IORING_OP_WRITE_FIXED:
5403         case IORING_OP_WRITE:
5404                 ret = io_write_prep(req, sqe, true);
5405                 break;
5406         case IORING_OP_POLL_ADD:
5407                 ret = io_poll_add_prep(req, sqe);
5408                 break;
5409         case IORING_OP_POLL_REMOVE:
5410                 ret = io_poll_remove_prep(req, sqe);
5411                 break;
5412         case IORING_OP_FSYNC:
5413                 ret = io_prep_fsync(req, sqe);
5414                 break;
5415         case IORING_OP_SYNC_FILE_RANGE:
5416                 ret = io_prep_sfr(req, sqe);
5417                 break;
5418         case IORING_OP_SENDMSG:
5419         case IORING_OP_SEND:
5420                 ret = io_sendmsg_prep(req, sqe);
5421                 break;
5422         case IORING_OP_RECVMSG:
5423         case IORING_OP_RECV:
5424                 ret = io_recvmsg_prep(req, sqe);
5425                 break;
5426         case IORING_OP_CONNECT:
5427                 ret = io_connect_prep(req, sqe);
5428                 break;
5429         case IORING_OP_TIMEOUT:
5430                 ret = io_timeout_prep(req, sqe, false);
5431                 break;
5432         case IORING_OP_TIMEOUT_REMOVE:
5433                 ret = io_timeout_remove_prep(req, sqe);
5434                 break;
5435         case IORING_OP_ASYNC_CANCEL:
5436                 ret = io_async_cancel_prep(req, sqe);
5437                 break;
5438         case IORING_OP_LINK_TIMEOUT:
5439                 ret = io_timeout_prep(req, sqe, true);
5440                 break;
5441         case IORING_OP_ACCEPT:
5442                 ret = io_accept_prep(req, sqe);
5443                 break;
5444         case IORING_OP_FALLOCATE:
5445                 ret = io_fallocate_prep(req, sqe);
5446                 break;
5447         case IORING_OP_OPENAT:
5448                 ret = io_openat_prep(req, sqe);
5449                 break;
5450         case IORING_OP_CLOSE:
5451                 ret = io_close_prep(req, sqe);
5452                 break;
5453         case IORING_OP_FILES_UPDATE:
5454                 ret = io_files_update_prep(req, sqe);
5455                 break;
5456         case IORING_OP_STATX:
5457                 ret = io_statx_prep(req, sqe);
5458                 break;
5459         case IORING_OP_FADVISE:
5460                 ret = io_fadvise_prep(req, sqe);
5461                 break;
5462         case IORING_OP_MADVISE:
5463                 ret = io_madvise_prep(req, sqe);
5464                 break;
5465         case IORING_OP_OPENAT2:
5466                 ret = io_openat2_prep(req, sqe);
5467                 break;
5468         case IORING_OP_EPOLL_CTL:
5469                 ret = io_epoll_ctl_prep(req, sqe);
5470                 break;
5471         case IORING_OP_SPLICE:
5472                 ret = io_splice_prep(req, sqe);
5473                 break;
5474         case IORING_OP_PROVIDE_BUFFERS:
5475                 ret = io_provide_buffers_prep(req, sqe);
5476                 break;
5477         case IORING_OP_REMOVE_BUFFERS:
5478                 ret = io_remove_buffers_prep(req, sqe);
5479                 break;
5480         case IORING_OP_TEE:
5481                 ret = io_tee_prep(req, sqe);
5482                 break;
5483         default:
5484                 printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
5485                                 req->opcode);
5486                 ret = -EINVAL;
5487                 break;
5488         }
5489
5490         return ret;
5491 }
5492
5493 static u32 io_get_sequence(struct io_kiocb *req)
5494 {
5495         struct io_kiocb *pos;
5496         struct io_ring_ctx *ctx = req->ctx;
5497         u32 total_submitted, nr_reqs = 1;
5498
5499         if (req->flags & REQ_F_LINK_HEAD)
5500                 list_for_each_entry(pos, &req->link_list, link_list)
5501                         nr_reqs++;
5502
5503         total_submitted = ctx->cached_sq_head - ctx->cached_sq_dropped;
5504         return total_submitted - nr_reqs;
5505 }
5506
5507 static int io_req_defer(struct io_kiocb *req, const struct io_uring_sqe *sqe)
5508 {
5509         struct io_ring_ctx *ctx = req->ctx;
5510         struct io_defer_entry *de;
5511         int ret;
5512         u32 seq;
5513
5514         /* Still need defer if there is pending req in defer list. */
5515         if (likely(list_empty_careful(&ctx->defer_list) &&
5516                 !(req->flags & REQ_F_IO_DRAIN)))
5517                 return 0;
5518
5519         seq = io_get_sequence(req);
5520         /* Still a chance to pass the sequence check */
5521         if (!req_need_defer(req, seq) && list_empty_careful(&ctx->defer_list))
5522                 return 0;
5523
5524         if (!req->io) {
5525                 ret = io_req_defer_prep(req, sqe);
5526                 if (ret)
5527                         return ret;
5528         }
5529         io_prep_async_link(req);
5530         de = kmalloc(sizeof(*de), GFP_KERNEL);
5531         if (!de)
5532                 return -ENOMEM;
5533
5534         spin_lock_irq(&ctx->completion_lock);
5535         if (!req_need_defer(req, seq) && list_empty(&ctx->defer_list)) {
5536                 spin_unlock_irq(&ctx->completion_lock);
5537                 kfree(de);
5538                 io_queue_async_work(req);
5539                 return -EIOCBQUEUED;
5540         }
5541
5542         trace_io_uring_defer(ctx, req, req->user_data);
5543         de->req = req;
5544         de->seq = seq;
5545         list_add_tail(&de->list, &ctx->defer_list);
5546         spin_unlock_irq(&ctx->completion_lock);
5547         return -EIOCBQUEUED;
5548 }
5549
5550 static void __io_clean_op(struct io_kiocb *req)
5551 {
5552         struct io_async_ctx *io = req->io;
5553
5554         if (req->flags & REQ_F_BUFFER_SELECTED) {
5555                 switch (req->opcode) {
5556                 case IORING_OP_READV:
5557                 case IORING_OP_READ_FIXED:
5558                 case IORING_OP_READ:
5559                         kfree((void *)(unsigned long)req->rw.addr);
5560                         break;
5561                 case IORING_OP_RECVMSG:
5562                 case IORING_OP_RECV:
5563                         kfree(req->sr_msg.kbuf);
5564                         break;
5565                 }
5566                 req->flags &= ~REQ_F_BUFFER_SELECTED;
5567         }
5568
5569         if (req->flags & REQ_F_NEED_CLEANUP) {
5570                 switch (req->opcode) {
5571                 case IORING_OP_READV:
5572                 case IORING_OP_READ_FIXED:
5573                 case IORING_OP_READ:
5574                 case IORING_OP_WRITEV:
5575                 case IORING_OP_WRITE_FIXED:
5576                 case IORING_OP_WRITE:
5577                         if (io->rw.iov != io->rw.fast_iov)
5578                                 kfree(io->rw.iov);
5579                         break;
5580                 case IORING_OP_RECVMSG:
5581                 case IORING_OP_SENDMSG:
5582                         if (io->msg.iov != io->msg.fast_iov)
5583                                 kfree(io->msg.iov);
5584                         break;
5585                 case IORING_OP_SPLICE:
5586                 case IORING_OP_TEE:
5587                         io_put_file(req, req->splice.file_in,
5588                                     (req->splice.flags & SPLICE_F_FD_IN_FIXED));
5589                         break;
5590                 }
5591                 req->flags &= ~REQ_F_NEED_CLEANUP;
5592         }
5593 }
5594
5595 static int io_issue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
5596                         bool force_nonblock, struct io_comp_state *cs)
5597 {
5598         struct io_ring_ctx *ctx = req->ctx;
5599         int ret;
5600
5601         switch (req->opcode) {
5602         case IORING_OP_NOP:
5603                 ret = io_nop(req, cs);
5604                 break;
5605         case IORING_OP_READV:
5606         case IORING_OP_READ_FIXED:
5607         case IORING_OP_READ:
5608                 if (sqe) {
5609                         ret = io_read_prep(req, sqe, force_nonblock);
5610                         if (ret < 0)
5611                                 break;
5612                 }
5613                 ret = io_read(req, force_nonblock, cs);
5614                 break;
5615         case IORING_OP_WRITEV:
5616         case IORING_OP_WRITE_FIXED:
5617         case IORING_OP_WRITE:
5618                 if (sqe) {
5619                         ret = io_write_prep(req, sqe, force_nonblock);
5620                         if (ret < 0)
5621                                 break;
5622                 }
5623                 ret = io_write(req, force_nonblock, cs);
5624                 break;
5625         case IORING_OP_FSYNC:
5626                 if (sqe) {
5627                         ret = io_prep_fsync(req, sqe);
5628                         if (ret < 0)
5629                                 break;
5630                 }
5631                 ret = io_fsync(req, force_nonblock);
5632                 break;
5633         case IORING_OP_POLL_ADD:
5634                 if (sqe) {
5635                         ret = io_poll_add_prep(req, sqe);
5636                         if (ret)
5637                                 break;
5638                 }
5639                 ret = io_poll_add(req);
5640                 break;
5641         case IORING_OP_POLL_REMOVE:
5642                 if (sqe) {
5643                         ret = io_poll_remove_prep(req, sqe);
5644                         if (ret < 0)
5645                                 break;
5646                 }
5647                 ret = io_poll_remove(req);
5648                 break;
5649         case IORING_OP_SYNC_FILE_RANGE:
5650                 if (sqe) {
5651                         ret = io_prep_sfr(req, sqe);
5652                         if (ret < 0)
5653                                 break;
5654                 }
5655                 ret = io_sync_file_range(req, force_nonblock);
5656                 break;
5657         case IORING_OP_SENDMSG:
5658         case IORING_OP_SEND:
5659                 if (sqe) {
5660                         ret = io_sendmsg_prep(req, sqe);
5661                         if (ret < 0)
5662                                 break;
5663                 }
5664                 if (req->opcode == IORING_OP_SENDMSG)
5665                         ret = io_sendmsg(req, force_nonblock, cs);
5666                 else
5667                         ret = io_send(req, force_nonblock, cs);
5668                 break;
5669         case IORING_OP_RECVMSG:
5670         case IORING_OP_RECV:
5671                 if (sqe) {
5672                         ret = io_recvmsg_prep(req, sqe);
5673                         if (ret)
5674                                 break;
5675                 }
5676                 if (req->opcode == IORING_OP_RECVMSG)
5677                         ret = io_recvmsg(req, force_nonblock, cs);
5678                 else
5679                         ret = io_recv(req, force_nonblock, cs);
5680                 break;
5681         case IORING_OP_TIMEOUT:
5682                 if (sqe) {
5683                         ret = io_timeout_prep(req, sqe, false);
5684                         if (ret)
5685                                 break;
5686                 }
5687                 ret = io_timeout(req);
5688                 break;
5689         case IORING_OP_TIMEOUT_REMOVE:
5690                 if (sqe) {
5691                         ret = io_timeout_remove_prep(req, sqe);
5692                         if (ret)
5693                                 break;
5694                 }
5695                 ret = io_timeout_remove(req);
5696                 break;
5697         case IORING_OP_ACCEPT:
5698                 if (sqe) {
5699                         ret = io_accept_prep(req, sqe);
5700                         if (ret)
5701                                 break;
5702                 }
5703                 ret = io_accept(req, force_nonblock, cs);
5704                 break;
5705         case IORING_OP_CONNECT:
5706                 if (sqe) {
5707                         ret = io_connect_prep(req, sqe);
5708                         if (ret)
5709                                 break;
5710                 }
5711                 ret = io_connect(req, force_nonblock, cs);
5712                 break;
5713         case IORING_OP_ASYNC_CANCEL:
5714                 if (sqe) {
5715                         ret = io_async_cancel_prep(req, sqe);
5716                         if (ret)
5717                                 break;
5718                 }
5719                 ret = io_async_cancel(req);
5720                 break;
5721         case IORING_OP_FALLOCATE:
5722                 if (sqe) {
5723                         ret = io_fallocate_prep(req, sqe);
5724                         if (ret)
5725                                 break;
5726                 }
5727                 ret = io_fallocate(req, force_nonblock);
5728                 break;
5729         case IORING_OP_OPENAT:
5730                 if (sqe) {
5731                         ret = io_openat_prep(req, sqe);
5732                         if (ret)
5733                                 break;
5734                 }
5735                 ret = io_openat(req, force_nonblock);
5736                 break;
5737         case IORING_OP_CLOSE:
5738                 if (sqe) {
5739                         ret = io_close_prep(req, sqe);
5740                         if (ret)
5741                                 break;
5742                 }
5743                 ret = io_close(req, force_nonblock, cs);
5744                 break;
5745         case IORING_OP_FILES_UPDATE:
5746                 if (sqe) {
5747                         ret = io_files_update_prep(req, sqe);
5748                         if (ret)
5749                                 break;
5750                 }
5751                 ret = io_files_update(req, force_nonblock, cs);
5752                 break;
5753         case IORING_OP_STATX:
5754                 if (sqe) {
5755                         ret = io_statx_prep(req, sqe);
5756                         if (ret)
5757                                 break;
5758                 }
5759                 ret = io_statx(req, force_nonblock);
5760                 break;
5761         case IORING_OP_FADVISE:
5762                 if (sqe) {
5763                         ret = io_fadvise_prep(req, sqe);
5764                         if (ret)
5765                                 break;
5766                 }
5767                 ret = io_fadvise(req, force_nonblock);
5768                 break;
5769         case IORING_OP_MADVISE:
5770                 if (sqe) {
5771                         ret = io_madvise_prep(req, sqe);
5772                         if (ret)
5773                                 break;
5774                 }
5775                 ret = io_madvise(req, force_nonblock);
5776                 break;
5777         case IORING_OP_OPENAT2:
5778                 if (sqe) {
5779                         ret = io_openat2_prep(req, sqe);
5780                         if (ret)
5781                                 break;
5782                 }
5783                 ret = io_openat2(req, force_nonblock);
5784                 break;
5785         case IORING_OP_EPOLL_CTL:
5786                 if (sqe) {
5787                         ret = io_epoll_ctl_prep(req, sqe);
5788                         if (ret)
5789                                 break;
5790                 }
5791                 ret = io_epoll_ctl(req, force_nonblock, cs);
5792                 break;
5793         case IORING_OP_SPLICE:
5794                 if (sqe) {
5795                         ret = io_splice_prep(req, sqe);
5796                         if (ret < 0)
5797                                 break;
5798                 }
5799                 ret = io_splice(req, force_nonblock);
5800                 break;
5801         case IORING_OP_PROVIDE_BUFFERS:
5802                 if (sqe) {
5803                         ret = io_provide_buffers_prep(req, sqe);
5804                         if (ret)
5805                                 break;
5806                 }
5807                 ret = io_provide_buffers(req, force_nonblock, cs);
5808                 break;
5809         case IORING_OP_REMOVE_BUFFERS:
5810                 if (sqe) {
5811                         ret = io_remove_buffers_prep(req, sqe);
5812                         if (ret)
5813                                 break;
5814                 }
5815                 ret = io_remove_buffers(req, force_nonblock, cs);
5816                 break;
5817         case IORING_OP_TEE:
5818                 if (sqe) {
5819                         ret = io_tee_prep(req, sqe);
5820                         if (ret < 0)
5821                                 break;
5822                 }
5823                 ret = io_tee(req, force_nonblock);
5824                 break;
5825         default:
5826                 ret = -EINVAL;
5827                 break;
5828         }
5829
5830         if (ret)
5831                 return ret;
5832
5833         /* If the op doesn't have a file, we're not polling for it */
5834         if ((ctx->flags & IORING_SETUP_IOPOLL) && req->file) {
5835                 const bool in_async = io_wq_current_is_worker();
5836
5837                 /* workqueue context doesn't hold uring_lock, grab it now */
5838                 if (in_async)
5839                         mutex_lock(&ctx->uring_lock);
5840
5841                 io_iopoll_req_issued(req);
5842
5843                 if (in_async)
5844                         mutex_unlock(&ctx->uring_lock);
5845         }
5846
5847         return 0;
5848 }
5849
5850 static struct io_wq_work *io_wq_submit_work(struct io_wq_work *work)
5851 {
5852         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
5853         struct io_kiocb *timeout;
5854         int ret = 0;
5855
5856         timeout = io_prep_linked_timeout(req);
5857         if (timeout)
5858                 io_queue_linked_timeout(timeout);
5859
5860         /* if NO_CANCEL is set, we must still run the work */
5861         if ((work->flags & (IO_WQ_WORK_CANCEL|IO_WQ_WORK_NO_CANCEL)) ==
5862                                 IO_WQ_WORK_CANCEL) {
5863                 ret = -ECANCELED;
5864         }
5865
5866         if (!ret) {
5867                 do {
5868                         ret = io_issue_sqe(req, NULL, false, NULL);
5869                         /*
5870                          * We can get EAGAIN for polled IO even though we're
5871                          * forcing a sync submission from here, since we can't
5872                          * wait for request slots on the block side.
5873                          */
5874                         if (ret != -EAGAIN)
5875                                 break;
5876                         cond_resched();
5877                 } while (1);
5878         }
5879
5880         if (ret) {
5881                 req_set_fail_links(req);
5882                 io_req_complete(req, ret);
5883         }
5884
5885         return io_steal_work(req);
5886 }
5887
5888 static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
5889                                               int index)
5890 {
5891         struct fixed_file_table *table;
5892
5893         table = &ctx->file_data->table[index >> IORING_FILE_TABLE_SHIFT];
5894         return table->files[index & IORING_FILE_TABLE_MASK];
5895 }
5896
5897 static int io_file_get(struct io_submit_state *state, struct io_kiocb *req,
5898                         int fd, struct file **out_file, bool fixed)
5899 {
5900         struct io_ring_ctx *ctx = req->ctx;
5901         struct file *file;
5902
5903         if (fixed) {
5904                 if (unlikely(!ctx->file_data ||
5905                     (unsigned) fd >= ctx->nr_user_files))
5906                         return -EBADF;
5907                 fd = array_index_nospec(fd, ctx->nr_user_files);
5908                 file = io_file_from_index(ctx, fd);
5909                 if (file) {
5910                         req->fixed_file_refs = ctx->file_data->cur_refs;
5911                         percpu_ref_get(req->fixed_file_refs);
5912                 }
5913         } else {
5914                 trace_io_uring_file_get(ctx, fd);
5915                 file = __io_file_get(state, fd);
5916         }
5917
5918         if (file || io_op_defs[req->opcode].needs_file_no_error) {
5919                 *out_file = file;
5920                 return 0;
5921         }
5922         return -EBADF;
5923 }
5924
5925 static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
5926                            int fd)
5927 {
5928         bool fixed;
5929
5930         fixed = (req->flags & REQ_F_FIXED_FILE) != 0;
5931         if (unlikely(!fixed && io_async_submit(req->ctx)))
5932                 return -EBADF;
5933
5934         return io_file_get(state, req, fd, &req->file, fixed);
5935 }
5936
5937 static int io_grab_files(struct io_kiocb *req)
5938 {
5939         int ret = -EBADF;
5940         struct io_ring_ctx *ctx = req->ctx;
5941
5942         io_req_init_async(req);
5943
5944         if (req->work.files || (req->flags & REQ_F_NO_FILE_TABLE))
5945                 return 0;
5946         if (!ctx->ring_file)
5947                 return -EBADF;
5948
5949         rcu_read_lock();
5950         spin_lock_irq(&ctx->inflight_lock);
5951         /*
5952          * We use the f_ops->flush() handler to ensure that we can flush
5953          * out work accessing these files if the fd is closed. Check if
5954          * the fd has changed since we started down this path, and disallow
5955          * this operation if it has.
5956          */
5957         if (fcheck(ctx->ring_fd) == ctx->ring_file) {
5958                 list_add(&req->inflight_entry, &ctx->inflight_list);
5959                 req->flags |= REQ_F_INFLIGHT;
5960                 req->work.files = current->files;
5961                 ret = 0;
5962         }
5963         spin_unlock_irq(&ctx->inflight_lock);
5964         rcu_read_unlock();
5965
5966         return ret;
5967 }
5968
5969 static inline int io_prep_work_files(struct io_kiocb *req)
5970 {
5971         if (!io_op_defs[req->opcode].file_table)
5972                 return 0;
5973         return io_grab_files(req);
5974 }
5975
5976 static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer)
5977 {
5978         struct io_timeout_data *data = container_of(timer,
5979                                                 struct io_timeout_data, timer);
5980         struct io_kiocb *req = data->req;
5981         struct io_ring_ctx *ctx = req->ctx;
5982         struct io_kiocb *prev = NULL;
5983         unsigned long flags;
5984
5985         spin_lock_irqsave(&ctx->completion_lock, flags);
5986
5987         /*
5988          * We don't expect the list to be empty, that will only happen if we
5989          * race with the completion of the linked work.
5990          */
5991         if (!list_empty(&req->link_list)) {
5992                 prev = list_entry(req->link_list.prev, struct io_kiocb,
5993                                   link_list);
5994                 if (refcount_inc_not_zero(&prev->refs)) {
5995                         list_del_init(&req->link_list);
5996                         prev->flags &= ~REQ_F_LINK_TIMEOUT;
5997                 } else
5998                         prev = NULL;
5999         }
6000
6001         spin_unlock_irqrestore(&ctx->completion_lock, flags);
6002
6003         if (prev) {
6004                 req_set_fail_links(prev);
6005                 io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);
6006                 io_put_req(prev);
6007         } else {
6008                 io_req_complete(req, -ETIME);
6009         }
6010         return HRTIMER_NORESTART;
6011 }
6012
6013 static void __io_queue_linked_timeout(struct io_kiocb *req)
6014 {
6015         /*
6016          * If the list is now empty, then our linked request finished before
6017          * we got a chance to setup the timer
6018          */
6019         if (!list_empty(&req->link_list)) {
6020                 struct io_timeout_data *data = &req->io->timeout;
6021
6022                 data->timer.function = io_link_timeout_fn;
6023                 hrtimer_start(&data->timer, timespec64_to_ktime(data->ts),
6024                                 data->mode);
6025         }
6026 }
6027
6028 static void io_queue_linked_timeout(struct io_kiocb *req)
6029 {
6030         struct io_ring_ctx *ctx = req->ctx;
6031
6032         spin_lock_irq(&ctx->completion_lock);
6033         __io_queue_linked_timeout(req);
6034         spin_unlock_irq(&ctx->completion_lock);
6035
6036         /* drop submission reference */
6037         io_put_req(req);
6038 }
6039
6040 static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req)
6041 {
6042         struct io_kiocb *nxt;
6043
6044         if (!(req->flags & REQ_F_LINK_HEAD))
6045                 return NULL;
6046         if (req->flags & REQ_F_LINK_TIMEOUT)
6047                 return NULL;
6048
6049         nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb,
6050                                         link_list);
6051         if (!nxt || nxt->opcode != IORING_OP_LINK_TIMEOUT)
6052                 return NULL;
6053
6054         req->flags |= REQ_F_LINK_TIMEOUT;
6055         return nxt;
6056 }
6057
6058 static void __io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
6059                            struct io_comp_state *cs)
6060 {
6061         struct io_kiocb *linked_timeout;
6062         struct io_kiocb *nxt;
6063         const struct cred *old_creds = NULL;
6064         int ret;
6065
6066 again:
6067         linked_timeout = io_prep_linked_timeout(req);
6068
6069         if ((req->flags & REQ_F_WORK_INITIALIZED) && req->work.creds &&
6070             req->work.creds != current_cred()) {
6071                 if (old_creds)
6072                         revert_creds(old_creds);
6073                 if (old_creds == req->work.creds)
6074                         old_creds = NULL; /* restored original creds */
6075                 else
6076                         old_creds = override_creds(req->work.creds);
6077         }
6078
6079         ret = io_issue_sqe(req, sqe, true, cs);
6080
6081         /*
6082          * We async punt it if the file wasn't marked NOWAIT, or if the file
6083          * doesn't support non-blocking read/write attempts
6084          */
6085         if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
6086                 if (!io_arm_poll_handler(req)) {
6087 punt:
6088                         ret = io_prep_work_files(req);
6089                         if (unlikely(ret))
6090                                 goto err;
6091                         /*
6092                          * Queued up for async execution, worker will release
6093                          * submit reference when the iocb is actually submitted.
6094                          */
6095                         io_queue_async_work(req);
6096                 }
6097
6098                 if (linked_timeout)
6099                         io_queue_linked_timeout(linked_timeout);
6100                 goto exit;
6101         }
6102
6103         if (unlikely(ret)) {
6104 err:
6105                 /* un-prep timeout, so it'll be killed as any other linked */
6106                 req->flags &= ~REQ_F_LINK_TIMEOUT;
6107                 req_set_fail_links(req);
6108                 io_put_req(req);
6109                 io_req_complete(req, ret);
6110                 goto exit;
6111         }
6112
6113         /* drop submission reference */
6114         nxt = io_put_req_find_next(req);
6115         if (linked_timeout)
6116                 io_queue_linked_timeout(linked_timeout);
6117
6118         if (nxt) {
6119                 req = nxt;
6120
6121                 if (req->flags & REQ_F_FORCE_ASYNC)
6122                         goto punt;
6123                 goto again;
6124         }
6125 exit:
6126         if (old_creds)
6127                 revert_creds(old_creds);
6128 }
6129
6130 static void io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
6131                          struct io_comp_state *cs)
6132 {
6133         int ret;
6134
6135         ret = io_req_defer(req, sqe);
6136         if (ret) {
6137                 if (ret != -EIOCBQUEUED) {
6138 fail_req:
6139                         req_set_fail_links(req);
6140                         io_put_req(req);
6141                         io_req_complete(req, ret);
6142                 }
6143         } else if (req->flags & REQ_F_FORCE_ASYNC) {
6144                 if (!req->io) {
6145                         ret = io_req_defer_prep(req, sqe);
6146                         if (unlikely(ret))
6147                                 goto fail_req;
6148                 }
6149
6150                 /*
6151                  * Never try inline submit of IOSQE_ASYNC is set, go straight
6152                  * to async execution.
6153                  */
6154                 io_req_init_async(req);
6155                 req->work.flags |= IO_WQ_WORK_CONCURRENT;
6156                 io_queue_async_work(req);
6157         } else {
6158                 __io_queue_sqe(req, sqe, cs);
6159         }
6160 }
6161
6162 static inline void io_queue_link_head(struct io_kiocb *req,
6163                                       struct io_comp_state *cs)
6164 {
6165         if (unlikely(req->flags & REQ_F_FAIL_LINK)) {
6166                 io_put_req(req);
6167                 io_req_complete(req, -ECANCELED);
6168         } else
6169                 io_queue_sqe(req, NULL, cs);
6170 }
6171
6172 static int io_submit_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
6173                          struct io_kiocb **link, struct io_comp_state *cs)
6174 {
6175         struct io_ring_ctx *ctx = req->ctx;
6176         int ret;
6177
6178         /*
6179          * If we already have a head request, queue this one for async
6180          * submittal once the head completes. If we don't have a head but
6181          * IOSQE_IO_LINK is set in the sqe, start a new head. This one will be
6182          * submitted sync once the chain is complete. If none of those
6183          * conditions are true (normal request), then just queue it.
6184          */
6185         if (*link) {
6186                 struct io_kiocb *head = *link;
6187
6188                 /*
6189                  * Taking sequential execution of a link, draining both sides
6190                  * of the link also fullfils IOSQE_IO_DRAIN semantics for all
6191                  * requests in the link. So, it drains the head and the
6192                  * next after the link request. The last one is done via
6193                  * drain_next flag to persist the effect across calls.
6194                  */
6195                 if (req->flags & REQ_F_IO_DRAIN) {
6196                         head->flags |= REQ_F_IO_DRAIN;
6197                         ctx->drain_next = 1;
6198                 }
6199                 ret = io_req_defer_prep(req, sqe);
6200                 if (unlikely(ret)) {
6201                         /* fail even hard links since we don't submit */
6202                         head->flags |= REQ_F_FAIL_LINK;
6203                         return ret;
6204                 }
6205                 trace_io_uring_link(ctx, req, head);
6206                 io_get_req_task(req);
6207                 list_add_tail(&req->link_list, &head->link_list);
6208
6209                 /* last request of a link, enqueue the link */
6210                 if (!(req->flags & (REQ_F_LINK | REQ_F_HARDLINK))) {
6211                         io_queue_link_head(head, cs);
6212                         *link = NULL;
6213                 }
6214         } else {
6215                 if (unlikely(ctx->drain_next)) {
6216                         req->flags |= REQ_F_IO_DRAIN;
6217                         ctx->drain_next = 0;
6218                 }
6219                 if (req->flags & (REQ_F_LINK | REQ_F_HARDLINK)) {
6220                         req->flags |= REQ_F_LINK_HEAD;
6221                         INIT_LIST_HEAD(&req->link_list);
6222
6223                         ret = io_req_defer_prep(req, sqe);
6224                         if (unlikely(ret))
6225                                 req->flags |= REQ_F_FAIL_LINK;
6226                         *link = req;
6227                 } else {
6228                         io_queue_sqe(req, sqe, cs);
6229                 }
6230         }
6231
6232         return 0;
6233 }
6234
6235 /*
6236  * Batched submission is done, ensure local IO is flushed out.
6237  */
6238 static void io_submit_state_end(struct io_submit_state *state)
6239 {
6240         if (!list_empty(&state->comp.list))
6241                 io_submit_flush_completions(&state->comp);
6242         blk_finish_plug(&state->plug);
6243         io_state_file_put(state);
6244         if (state->free_reqs)
6245                 kmem_cache_free_bulk(req_cachep, state->free_reqs, state->reqs);
6246 }
6247
6248 /*
6249  * Start submission side cache.
6250  */
6251 static void io_submit_state_start(struct io_submit_state *state,
6252                                   struct io_ring_ctx *ctx, unsigned int max_ios)
6253 {
6254         blk_start_plug(&state->plug);
6255 #ifdef CONFIG_BLOCK
6256         state->plug.nowait = true;
6257 #endif
6258         state->comp.nr = 0;
6259         INIT_LIST_HEAD(&state->comp.list);
6260         state->comp.ctx = ctx;
6261         state->free_reqs = 0;
6262         state->file = NULL;
6263         state->ios_left = max_ios;
6264 }
6265
6266 static void io_commit_sqring(struct io_ring_ctx *ctx)
6267 {
6268         struct io_rings *rings = ctx->rings;
6269
6270         /*
6271          * Ensure any loads from the SQEs are done at this point,
6272          * since once we write the new head, the application could
6273          * write new data to them.
6274          */
6275         smp_store_release(&rings->sq.head, ctx->cached_sq_head);
6276 }
6277
6278 /*
6279  * Fetch an sqe, if one is available. Note that sqe_ptr will point to memory
6280  * that is mapped by userspace. This means that care needs to be taken to
6281  * ensure that reads are stable, as we cannot rely on userspace always
6282  * being a good citizen. If members of the sqe are validated and then later
6283  * used, it's important that those reads are done through READ_ONCE() to
6284  * prevent a re-load down the line.
6285  */
6286 static const struct io_uring_sqe *io_get_sqe(struct io_ring_ctx *ctx)
6287 {
6288         u32 *sq_array = ctx->sq_array;
6289         unsigned head;
6290
6291         /*
6292          * The cached sq head (or cq tail) serves two purposes:
6293          *
6294          * 1) allows us to batch the cost of updating the user visible
6295          *    head updates.
6296          * 2) allows the kernel side to track the head on its own, even
6297          *    though the application is the one updating it.
6298          */
6299         head = READ_ONCE(sq_array[ctx->cached_sq_head & ctx->sq_mask]);
6300         if (likely(head < ctx->sq_entries))
6301                 return &ctx->sq_sqes[head];
6302
6303         /* drop invalid entries */
6304         ctx->cached_sq_dropped++;
6305         WRITE_ONCE(ctx->rings->sq_dropped, ctx->cached_sq_dropped);
6306         return NULL;
6307 }
6308
6309 static inline void io_consume_sqe(struct io_ring_ctx *ctx)
6310 {
6311         ctx->cached_sq_head++;
6312 }
6313
6314 #define SQE_VALID_FLAGS (IOSQE_FIXED_FILE|IOSQE_IO_DRAIN|IOSQE_IO_LINK| \
6315                                 IOSQE_IO_HARDLINK | IOSQE_ASYNC | \
6316                                 IOSQE_BUFFER_SELECT)
6317
6318 static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req,
6319                        const struct io_uring_sqe *sqe,
6320                        struct io_submit_state *state)
6321 {
6322         unsigned int sqe_flags;
6323         int id;
6324
6325         req->opcode = READ_ONCE(sqe->opcode);
6326         req->user_data = READ_ONCE(sqe->user_data);
6327         req->io = NULL;
6328         req->file = NULL;
6329         req->ctx = ctx;
6330         req->flags = 0;
6331         /* one is dropped after submission, the other at completion */
6332         refcount_set(&req->refs, 2);
6333         req->task = current;
6334         req->result = 0;
6335
6336         if (unlikely(req->opcode >= IORING_OP_LAST))
6337                 return -EINVAL;
6338
6339         if (unlikely(io_sq_thread_acquire_mm(ctx, req)))
6340                 return -EFAULT;
6341
6342         sqe_flags = READ_ONCE(sqe->flags);
6343         /* enforce forwards compatibility on users */
6344         if (unlikely(sqe_flags & ~SQE_VALID_FLAGS))
6345                 return -EINVAL;
6346
6347         if ((sqe_flags & IOSQE_BUFFER_SELECT) &&
6348             !io_op_defs[req->opcode].buffer_select)
6349                 return -EOPNOTSUPP;
6350
6351         id = READ_ONCE(sqe->personality);
6352         if (id) {
6353                 io_req_init_async(req);
6354                 req->work.creds = idr_find(&ctx->personality_idr, id);
6355                 if (unlikely(!req->work.creds))
6356                         return -EINVAL;
6357                 get_cred(req->work.creds);
6358         }
6359
6360         /* same numerical values with corresponding REQ_F_*, safe to copy */
6361         req->flags |= sqe_flags;
6362
6363         if (!io_op_defs[req->opcode].needs_file)
6364                 return 0;
6365
6366         return io_req_set_file(state, req, READ_ONCE(sqe->fd));
6367 }
6368
6369 static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr,
6370                           struct file *ring_file, int ring_fd)
6371 {
6372         struct io_submit_state state;
6373         struct io_kiocb *link = NULL;
6374         int i, submitted = 0;
6375
6376         /* if we have a backlog and couldn't flush it all, return BUSY */
6377         if (test_bit(0, &ctx->sq_check_overflow)) {
6378                 if (!list_empty(&ctx->cq_overflow_list) &&
6379                     !io_cqring_overflow_flush(ctx, false))
6380                         return -EBUSY;
6381         }
6382
6383         /* make sure SQ entry isn't read before tail */
6384         nr = min3(nr, ctx->sq_entries, io_sqring_entries(ctx));
6385
6386         if (!percpu_ref_tryget_many(&ctx->refs, nr))
6387                 return -EAGAIN;
6388
6389         io_submit_state_start(&state, ctx, nr);
6390
6391         ctx->ring_fd = ring_fd;
6392         ctx->ring_file = ring_file;
6393
6394         for (i = 0; i < nr; i++) {
6395                 const struct io_uring_sqe *sqe;
6396                 struct io_kiocb *req;
6397                 int err;
6398
6399                 sqe = io_get_sqe(ctx);
6400                 if (unlikely(!sqe)) {
6401                         io_consume_sqe(ctx);
6402                         break;
6403                 }
6404                 req = io_alloc_req(ctx, &state);
6405                 if (unlikely(!req)) {
6406                         if (!submitted)
6407                                 submitted = -EAGAIN;
6408                         break;
6409                 }
6410
6411                 err = io_init_req(ctx, req, sqe, &state);
6412                 io_consume_sqe(ctx);
6413                 /* will complete beyond this point, count as submitted */
6414                 submitted++;
6415
6416                 if (unlikely(err)) {
6417 fail_req:
6418                         io_put_req(req);
6419                         io_req_complete(req, err);
6420                         break;
6421                 }
6422
6423                 trace_io_uring_submit_sqe(ctx, req->opcode, req->user_data,
6424                                                 true, io_async_submit(ctx));
6425                 err = io_submit_sqe(req, sqe, &link, &state.comp);
6426                 if (err)
6427                         goto fail_req;
6428         }
6429
6430         if (unlikely(submitted != nr)) {
6431                 int ref_used = (submitted == -EAGAIN) ? 0 : submitted;
6432
6433                 percpu_ref_put_many(&ctx->refs, nr - ref_used);
6434         }
6435         if (link)
6436                 io_queue_link_head(link, &state.comp);
6437         io_submit_state_end(&state);
6438
6439          /* Commit SQ ring head once we've consumed and submitted all SQEs */
6440         io_commit_sqring(ctx);
6441
6442         return submitted;
6443 }
6444
6445 static inline void io_ring_set_wakeup_flag(struct io_ring_ctx *ctx)
6446 {
6447         /* Tell userspace we may need a wakeup call */
6448         spin_lock_irq(&ctx->completion_lock);
6449         ctx->rings->sq_flags |= IORING_SQ_NEED_WAKEUP;
6450         spin_unlock_irq(&ctx->completion_lock);
6451 }
6452
6453 static inline void io_ring_clear_wakeup_flag(struct io_ring_ctx *ctx)
6454 {
6455         spin_lock_irq(&ctx->completion_lock);
6456         ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
6457         spin_unlock_irq(&ctx->completion_lock);
6458 }
6459
6460 static int io_sq_thread(void *data)
6461 {
6462         struct io_ring_ctx *ctx = data;
6463         const struct cred *old_cred;
6464         DEFINE_WAIT(wait);
6465         unsigned long timeout;
6466         int ret = 0;
6467
6468         complete(&ctx->sq_thread_comp);
6469
6470         old_cred = override_creds(ctx->creds);
6471
6472         timeout = jiffies + ctx->sq_thread_idle;
6473         while (!kthread_should_park()) {
6474                 unsigned int to_submit;
6475
6476                 if (!list_empty(&ctx->iopoll_list)) {
6477                         unsigned nr_events = 0;
6478
6479                         mutex_lock(&ctx->uring_lock);
6480                         if (!list_empty(&ctx->iopoll_list) && !need_resched())
6481                                 io_do_iopoll(ctx, &nr_events, 0);
6482                         else
6483                                 timeout = jiffies + ctx->sq_thread_idle;
6484                         mutex_unlock(&ctx->uring_lock);
6485                 }
6486
6487                 to_submit = io_sqring_entries(ctx);
6488
6489                 /*
6490                  * If submit got -EBUSY, flag us as needing the application
6491                  * to enter the kernel to reap and flush events.
6492                  */
6493                 if (!to_submit || ret == -EBUSY || need_resched()) {
6494                         /*
6495                          * Drop cur_mm before scheduling, we can't hold it for
6496                          * long periods (or over schedule()). Do this before
6497                          * adding ourselves to the waitqueue, as the unuse/drop
6498                          * may sleep.
6499                          */
6500                         io_sq_thread_drop_mm();
6501
6502                         /*
6503                          * We're polling. If we're within the defined idle
6504                          * period, then let us spin without work before going
6505                          * to sleep. The exception is if we got EBUSY doing
6506                          * more IO, we should wait for the application to
6507                          * reap events and wake us up.
6508                          */
6509                         if (!list_empty(&ctx->iopoll_list) || need_resched() ||
6510                             (!time_after(jiffies, timeout) && ret != -EBUSY &&
6511                             !percpu_ref_is_dying(&ctx->refs))) {
6512                                 io_run_task_work();
6513                                 cond_resched();
6514                                 continue;
6515                         }
6516
6517                         prepare_to_wait(&ctx->sqo_wait, &wait,
6518                                                 TASK_INTERRUPTIBLE);
6519
6520                         /*
6521                          * While doing polled IO, before going to sleep, we need
6522                          * to check if there are new reqs added to iopoll_list,
6523                          * it is because reqs may have been punted to io worker
6524                          * and will be added to iopoll_list later, hence check
6525                          * the iopoll_list again.
6526                          */
6527                         if ((ctx->flags & IORING_SETUP_IOPOLL) &&
6528                             !list_empty_careful(&ctx->iopoll_list)) {
6529                                 finish_wait(&ctx->sqo_wait, &wait);
6530                                 continue;
6531                         }
6532
6533                         io_ring_set_wakeup_flag(ctx);
6534
6535                         to_submit = io_sqring_entries(ctx);
6536                         if (!to_submit || ret == -EBUSY) {
6537                                 if (kthread_should_park()) {
6538                                         finish_wait(&ctx->sqo_wait, &wait);
6539                                         break;
6540                                 }
6541                                 if (io_run_task_work()) {
6542                                         finish_wait(&ctx->sqo_wait, &wait);
6543                                         io_ring_clear_wakeup_flag(ctx);
6544                                         continue;
6545                                 }
6546                                 if (signal_pending(current))
6547                                         flush_signals(current);
6548                                 schedule();
6549                                 finish_wait(&ctx->sqo_wait, &wait);
6550
6551                                 io_ring_clear_wakeup_flag(ctx);
6552                                 ret = 0;
6553                                 continue;
6554                         }
6555                         finish_wait(&ctx->sqo_wait, &wait);
6556
6557                         io_ring_clear_wakeup_flag(ctx);
6558                 }
6559
6560                 mutex_lock(&ctx->uring_lock);
6561                 if (likely(!percpu_ref_is_dying(&ctx->refs)))
6562                         ret = io_submit_sqes(ctx, to_submit, NULL, -1);
6563                 mutex_unlock(&ctx->uring_lock);
6564                 timeout = jiffies + ctx->sq_thread_idle;
6565         }
6566
6567         io_run_task_work();
6568
6569         io_sq_thread_drop_mm();
6570         revert_creds(old_cred);
6571
6572         kthread_parkme();
6573
6574         return 0;
6575 }
6576
6577 struct io_wait_queue {
6578         struct wait_queue_entry wq;
6579         struct io_ring_ctx *ctx;
6580         unsigned to_wait;
6581         unsigned nr_timeouts;
6582 };
6583
6584 static inline bool io_should_wake(struct io_wait_queue *iowq, bool noflush)
6585 {
6586         struct io_ring_ctx *ctx = iowq->ctx;
6587
6588         /*
6589          * Wake up if we have enough events, or if a timeout occurred since we
6590          * started waiting. For timeouts, we always want to return to userspace,
6591          * regardless of event count.
6592          */
6593         return io_cqring_events(ctx, noflush) >= iowq->to_wait ||
6594                         atomic_read(&ctx->cq_timeouts) != iowq->nr_timeouts;
6595 }
6596
6597 static int io_wake_function(struct wait_queue_entry *curr, unsigned int mode,
6598                             int wake_flags, void *key)
6599 {
6600         struct io_wait_queue *iowq = container_of(curr, struct io_wait_queue,
6601                                                         wq);
6602
6603         /* use noflush == true, as we can't safely rely on locking context */
6604         if (!io_should_wake(iowq, true))
6605                 return -1;
6606
6607         return autoremove_wake_function(curr, mode, wake_flags, key);
6608 }
6609
6610 /*
6611  * Wait until events become available, if we don't already have some. The
6612  * application must reap them itself, as they reside on the shared cq ring.
6613  */
6614 static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
6615                           const sigset_t __user *sig, size_t sigsz)
6616 {
6617         struct io_wait_queue iowq = {
6618                 .wq = {
6619                         .private        = current,
6620                         .func           = io_wake_function,
6621                         .entry          = LIST_HEAD_INIT(iowq.wq.entry),
6622                 },
6623                 .ctx            = ctx,
6624                 .to_wait        = min_events,
6625         };
6626         struct io_rings *rings = ctx->rings;
6627         int ret = 0;
6628
6629         do {
6630                 if (io_cqring_events(ctx, false) >= min_events)
6631                         return 0;
6632                 if (!io_run_task_work())
6633                         break;
6634         } while (1);
6635
6636         if (sig) {
6637 #ifdef CONFIG_COMPAT
6638                 if (in_compat_syscall())
6639                         ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
6640                                                       sigsz);
6641                 else
6642 #endif
6643                         ret = set_user_sigmask(sig, sigsz);
6644
6645                 if (ret)
6646                         return ret;
6647         }
6648
6649         iowq.nr_timeouts = atomic_read(&ctx->cq_timeouts);
6650         trace_io_uring_cqring_wait(ctx, min_events);
6651         do {
6652                 prepare_to_wait_exclusive(&ctx->wait, &iowq.wq,
6653                                                 TASK_INTERRUPTIBLE);
6654                 /* make sure we run task_work before checking for signals */
6655                 if (io_run_task_work())
6656                         continue;
6657                 if (signal_pending(current)) {
6658                         if (current->jobctl & JOBCTL_TASK_WORK) {
6659                                 spin_lock_irq(&current->sighand->siglock);
6660                                 current->jobctl &= ~JOBCTL_TASK_WORK;
6661                                 recalc_sigpending();
6662                                 spin_unlock_irq(&current->sighand->siglock);
6663                                 continue;
6664                         }
6665                         ret = -EINTR;
6666                         break;
6667                 }
6668                 if (io_should_wake(&iowq, false))
6669                         break;
6670                 schedule();
6671         } while (1);
6672         finish_wait(&ctx->wait, &iowq.wq);
6673
6674         restore_saved_sigmask_unless(ret == -EINTR);
6675
6676         return READ_ONCE(rings->cq.head) == READ_ONCE(rings->cq.tail) ? ret : 0;
6677 }
6678
6679 static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
6680 {
6681 #if defined(CONFIG_UNIX)
6682         if (ctx->ring_sock) {
6683                 struct sock *sock = ctx->ring_sock->sk;
6684                 struct sk_buff *skb;
6685
6686                 while ((skb = skb_dequeue(&sock->sk_receive_queue)) != NULL)
6687                         kfree_skb(skb);
6688         }
6689 #else
6690         int i;
6691
6692         for (i = 0; i < ctx->nr_user_files; i++) {
6693                 struct file *file;
6694
6695                 file = io_file_from_index(ctx, i);
6696                 if (file)
6697                         fput(file);
6698         }
6699 #endif
6700 }
6701
6702 static void io_file_ref_kill(struct percpu_ref *ref)
6703 {
6704         struct fixed_file_data *data;
6705
6706         data = container_of(ref, struct fixed_file_data, refs);
6707         complete(&data->done);
6708 }
6709
6710 static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
6711 {
6712         struct fixed_file_data *data = ctx->file_data;
6713         struct fixed_file_ref_node *ref_node = NULL;
6714         unsigned nr_tables, i;
6715
6716         if (!data)
6717                 return -ENXIO;
6718
6719         spin_lock(&data->lock);
6720         if (!list_empty(&data->ref_list))
6721                 ref_node = list_first_entry(&data->ref_list,
6722                                 struct fixed_file_ref_node, node);
6723         spin_unlock(&data->lock);
6724         if (ref_node)
6725                 percpu_ref_kill(&ref_node->refs);
6726
6727         percpu_ref_kill(&data->refs);
6728
6729         /* wait for all refs nodes to complete */
6730         flush_delayed_work(&ctx->file_put_work);
6731         wait_for_completion(&data->done);
6732
6733         __io_sqe_files_unregister(ctx);
6734         nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE);
6735         for (i = 0; i < nr_tables; i++)
6736                 kfree(data->table[i].files);
6737         kfree(data->table);
6738         percpu_ref_exit(&data->refs);
6739         kfree(data);
6740         ctx->file_data = NULL;
6741         ctx->nr_user_files = 0;
6742         return 0;
6743 }
6744
6745 static void io_sq_thread_stop(struct io_ring_ctx *ctx)
6746 {
6747         if (ctx->sqo_thread) {
6748                 wait_for_completion(&ctx->sq_thread_comp);
6749                 /*
6750                  * The park is a bit of a work-around, without it we get
6751                  * warning spews on shutdown with SQPOLL set and affinity
6752                  * set to a single CPU.
6753                  */
6754                 kthread_park(ctx->sqo_thread);
6755                 kthread_stop(ctx->sqo_thread);
6756                 ctx->sqo_thread = NULL;
6757         }
6758 }
6759
6760 static void io_finish_async(struct io_ring_ctx *ctx)
6761 {
6762         io_sq_thread_stop(ctx);
6763
6764         if (ctx->io_wq) {
6765                 io_wq_destroy(ctx->io_wq);
6766                 ctx->io_wq = NULL;
6767         }
6768 }
6769
6770 #if defined(CONFIG_UNIX)
6771 /*
6772  * Ensure the UNIX gc is aware of our file set, so we are certain that
6773  * the io_uring can be safely unregistered on process exit, even if we have
6774  * loops in the file referencing.
6775  */
6776 static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset)
6777 {
6778         struct sock *sk = ctx->ring_sock->sk;
6779         struct scm_fp_list *fpl;
6780         struct sk_buff *skb;
6781         int i, nr_files;
6782
6783         fpl = kzalloc(sizeof(*fpl), GFP_KERNEL);
6784         if (!fpl)
6785                 return -ENOMEM;
6786
6787         skb = alloc_skb(0, GFP_KERNEL);
6788         if (!skb) {
6789                 kfree(fpl);
6790                 return -ENOMEM;
6791         }
6792
6793         skb->sk = sk;
6794
6795         nr_files = 0;
6796         fpl->user = get_uid(ctx->user);
6797         for (i = 0; i < nr; i++) {
6798                 struct file *file = io_file_from_index(ctx, i + offset);
6799
6800                 if (!file)
6801                         continue;
6802                 fpl->fp[nr_files] = get_file(file);
6803                 unix_inflight(fpl->user, fpl->fp[nr_files]);
6804                 nr_files++;
6805         }
6806
6807         if (nr_files) {
6808                 fpl->max = SCM_MAX_FD;
6809                 fpl->count = nr_files;
6810                 UNIXCB(skb).fp = fpl;
6811                 skb->destructor = unix_destruct_scm;
6812                 refcount_add(skb->truesize, &sk->sk_wmem_alloc);
6813                 skb_queue_head(&sk->sk_receive_queue, skb);
6814
6815                 for (i = 0; i < nr_files; i++)
6816                         fput(fpl->fp[i]);
6817         } else {
6818                 kfree_skb(skb);
6819                 kfree(fpl);
6820         }
6821
6822         return 0;
6823 }
6824
6825 /*
6826  * If UNIX sockets are enabled, fd passing can cause a reference cycle which
6827  * causes regular reference counting to break down. We rely on the UNIX
6828  * garbage collection to take care of this problem for us.
6829  */
6830 static int io_sqe_files_scm(struct io_ring_ctx *ctx)
6831 {
6832         unsigned left, total;
6833         int ret = 0;
6834
6835         total = 0;
6836         left = ctx->nr_user_files;
6837         while (left) {
6838                 unsigned this_files = min_t(unsigned, left, SCM_MAX_FD);
6839
6840                 ret = __io_sqe_files_scm(ctx, this_files, total);
6841                 if (ret)
6842                         break;
6843                 left -= this_files;
6844                 total += this_files;
6845         }
6846
6847         if (!ret)
6848                 return 0;
6849
6850         while (total < ctx->nr_user_files) {
6851                 struct file *file = io_file_from_index(ctx, total);
6852
6853                 if (file)
6854                         fput(file);
6855                 total++;
6856         }
6857
6858         return ret;
6859 }
6860 #else
6861 static int io_sqe_files_scm(struct io_ring_ctx *ctx)
6862 {
6863         return 0;
6864 }
6865 #endif
6866
6867 static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
6868                                     unsigned nr_files)
6869 {
6870         int i;
6871
6872         for (i = 0; i < nr_tables; i++) {
6873                 struct fixed_file_table *table = &ctx->file_data->table[i];
6874                 unsigned this_files;
6875
6876                 this_files = min(nr_files, IORING_MAX_FILES_TABLE);
6877                 table->files = kcalloc(this_files, sizeof(struct file *),
6878                                         GFP_KERNEL);
6879                 if (!table->files)
6880                         break;
6881                 nr_files -= this_files;
6882         }
6883
6884         if (i == nr_tables)
6885                 return 0;
6886
6887         for (i = 0; i < nr_tables; i++) {
6888                 struct fixed_file_table *table = &ctx->file_data->table[i];
6889                 kfree(table->files);
6890         }
6891         return 1;
6892 }
6893
6894 static void io_ring_file_put(struct io_ring_ctx *ctx, struct file *file)
6895 {
6896 #if defined(CONFIG_UNIX)
6897         struct sock *sock = ctx->ring_sock->sk;
6898         struct sk_buff_head list, *head = &sock->sk_receive_queue;
6899         struct sk_buff *skb;
6900         int i;
6901
6902         __skb_queue_head_init(&list);
6903
6904         /*
6905          * Find the skb that holds this file in its SCM_RIGHTS. When found,
6906          * remove this entry and rearrange the file array.
6907          */
6908         skb = skb_dequeue(head);
6909         while (skb) {
6910                 struct scm_fp_list *fp;
6911
6912                 fp = UNIXCB(skb).fp;
6913                 for (i = 0; i < fp->count; i++) {
6914                         int left;
6915
6916                         if (fp->fp[i] != file)
6917                                 continue;
6918
6919                         unix_notinflight(fp->user, fp->fp[i]);
6920                         left = fp->count - 1 - i;
6921                         if (left) {
6922                                 memmove(&fp->fp[i], &fp->fp[i + 1],
6923                                                 left * sizeof(struct file *));
6924                         }
6925                         fp->count--;
6926                         if (!fp->count) {
6927                                 kfree_skb(skb);
6928                                 skb = NULL;
6929                         } else {
6930                                 __skb_queue_tail(&list, skb);
6931                         }
6932                         fput(file);
6933                         file = NULL;
6934                         break;
6935                 }
6936
6937                 if (!file)
6938                         break;
6939
6940                 __skb_queue_tail(&list, skb);
6941
6942                 skb = skb_dequeue(head);
6943         }
6944
6945         if (skb_peek(&list)) {
6946                 spin_lock_irq(&head->lock);
6947                 while ((skb = __skb_dequeue(&list)) != NULL)
6948                         __skb_queue_tail(head, skb);
6949                 spin_unlock_irq(&head->lock);
6950         }
6951 #else
6952         fput(file);
6953 #endif
6954 }
6955
6956 struct io_file_put {
6957         struct list_head list;
6958         struct file *file;
6959 };
6960
6961 static void __io_file_put_work(struct fixed_file_ref_node *ref_node)
6962 {
6963         struct fixed_file_data *file_data = ref_node->file_data;
6964         struct io_ring_ctx *ctx = file_data->ctx;
6965         struct io_file_put *pfile, *tmp;
6966
6967         list_for_each_entry_safe(pfile, tmp, &ref_node->file_list, list) {
6968                 list_del(&pfile->list);
6969                 io_ring_file_put(ctx, pfile->file);
6970                 kfree(pfile);
6971         }
6972
6973         spin_lock(&file_data->lock);
6974         list_del(&ref_node->node);
6975         spin_unlock(&file_data->lock);
6976
6977         percpu_ref_exit(&ref_node->refs);
6978         kfree(ref_node);
6979         percpu_ref_put(&file_data->refs);
6980 }
6981
6982 static void io_file_put_work(struct work_struct *work)
6983 {
6984         struct io_ring_ctx *ctx;
6985         struct llist_node *node;
6986
6987         ctx = container_of(work, struct io_ring_ctx, file_put_work.work);
6988         node = llist_del_all(&ctx->file_put_llist);
6989
6990         while (node) {
6991                 struct fixed_file_ref_node *ref_node;
6992                 struct llist_node *next = node->next;
6993
6994                 ref_node = llist_entry(node, struct fixed_file_ref_node, llist);
6995                 __io_file_put_work(ref_node);
6996                 node = next;
6997         }
6998 }
6999
7000 static void io_file_data_ref_zero(struct percpu_ref *ref)
7001 {
7002         struct fixed_file_ref_node *ref_node;
7003         struct io_ring_ctx *ctx;
7004         bool first_add;
7005         int delay = HZ;
7006
7007         ref_node = container_of(ref, struct fixed_file_ref_node, refs);
7008         ctx = ref_node->file_data->ctx;
7009
7010         if (percpu_ref_is_dying(&ctx->file_data->refs))
7011                 delay = 0;
7012
7013         first_add = llist_add(&ref_node->llist, &ctx->file_put_llist);
7014         if (!delay)
7015                 mod_delayed_work(system_wq, &ctx->file_put_work, 0);
7016         else if (first_add)
7017                 queue_delayed_work(system_wq, &ctx->file_put_work, delay);
7018 }
7019
7020 static struct fixed_file_ref_node *alloc_fixed_file_ref_node(
7021                         struct io_ring_ctx *ctx)
7022 {
7023         struct fixed_file_ref_node *ref_node;
7024
7025         ref_node = kzalloc(sizeof(*ref_node), GFP_KERNEL);
7026         if (!ref_node)
7027                 return ERR_PTR(-ENOMEM);
7028
7029         if (percpu_ref_init(&ref_node->refs, io_file_data_ref_zero,
7030                             0, GFP_KERNEL)) {
7031                 kfree(ref_node);
7032                 return ERR_PTR(-ENOMEM);
7033         }
7034         INIT_LIST_HEAD(&ref_node->node);
7035         INIT_LIST_HEAD(&ref_node->file_list);
7036         ref_node->file_data = ctx->file_data;
7037         return ref_node;
7038 }
7039
7040 static void destroy_fixed_file_ref_node(struct fixed_file_ref_node *ref_node)
7041 {
7042         percpu_ref_exit(&ref_node->refs);
7043         kfree(ref_node);
7044 }
7045
7046 static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
7047                                  unsigned nr_args)
7048 {
7049         __s32 __user *fds = (__s32 __user *) arg;
7050         unsigned nr_tables;
7051         struct file *file;
7052         int fd, ret = 0;
7053         unsigned i;
7054         struct fixed_file_ref_node *ref_node;
7055
7056         if (ctx->file_data)
7057                 return -EBUSY;
7058         if (!nr_args)
7059                 return -EINVAL;
7060         if (nr_args > IORING_MAX_FIXED_FILES)
7061                 return -EMFILE;
7062
7063         ctx->file_data = kzalloc(sizeof(*ctx->file_data), GFP_KERNEL);
7064         if (!ctx->file_data)
7065                 return -ENOMEM;
7066         ctx->file_data->ctx = ctx;
7067         init_completion(&ctx->file_data->done);
7068         INIT_LIST_HEAD(&ctx->file_data->ref_list);
7069         spin_lock_init(&ctx->file_data->lock);
7070
7071         nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE);
7072         ctx->file_data->table = kcalloc(nr_tables,
7073                                         sizeof(struct fixed_file_table),
7074                                         GFP_KERNEL);
7075         if (!ctx->file_data->table) {
7076                 kfree(ctx->file_data);
7077                 ctx->file_data = NULL;
7078                 return -ENOMEM;
7079         }
7080
7081         if (percpu_ref_init(&ctx->file_data->refs, io_file_ref_kill,
7082                                 PERCPU_REF_ALLOW_REINIT, GFP_KERNEL)) {
7083                 kfree(ctx->file_data->table);
7084                 kfree(ctx->file_data);
7085                 ctx->file_data = NULL;
7086                 return -ENOMEM;
7087         }
7088
7089         if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) {
7090                 percpu_ref_exit(&ctx->file_data->refs);
7091                 kfree(ctx->file_data->table);
7092                 kfree(ctx->file_data);
7093                 ctx->file_data = NULL;
7094                 return -ENOMEM;
7095         }
7096
7097         for (i = 0; i < nr_args; i++, ctx->nr_user_files++) {
7098                 struct fixed_file_table *table;
7099                 unsigned index;
7100
7101                 ret = -EFAULT;
7102                 if (copy_from_user(&fd, &fds[i], sizeof(fd)))
7103                         break;
7104                 /* allow sparse sets */
7105                 if (fd == -1) {
7106                         ret = 0;
7107                         continue;
7108                 }
7109
7110                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
7111                 index = i & IORING_FILE_TABLE_MASK;
7112                 file = fget(fd);
7113
7114                 ret = -EBADF;
7115                 if (!file)
7116                         break;
7117
7118                 /*
7119                  * Don't allow io_uring instances to be registered. If UNIX
7120                  * isn't enabled, then this causes a reference cycle and this
7121                  * instance can never get freed. If UNIX is enabled we'll
7122                  * handle it just fine, but there's still no point in allowing
7123                  * a ring fd as it doesn't support regular read/write anyway.
7124                  */
7125                 if (file->f_op == &io_uring_fops) {
7126                         fput(file);
7127                         break;
7128                 }
7129                 ret = 0;
7130                 table->files[index] = file;
7131         }
7132
7133         if (ret) {
7134                 for (i = 0; i < ctx->nr_user_files; i++) {
7135                         file = io_file_from_index(ctx, i);
7136                         if (file)
7137                                 fput(file);
7138                 }
7139                 for (i = 0; i < nr_tables; i++)
7140                         kfree(ctx->file_data->table[i].files);
7141
7142                 percpu_ref_exit(&ctx->file_data->refs);
7143                 kfree(ctx->file_data->table);
7144                 kfree(ctx->file_data);
7145                 ctx->file_data = NULL;
7146                 ctx->nr_user_files = 0;
7147                 return ret;
7148         }
7149
7150         ret = io_sqe_files_scm(ctx);
7151         if (ret) {
7152                 io_sqe_files_unregister(ctx);
7153                 return ret;
7154         }
7155
7156         ref_node = alloc_fixed_file_ref_node(ctx);
7157         if (IS_ERR(ref_node)) {
7158                 io_sqe_files_unregister(ctx);
7159                 return PTR_ERR(ref_node);
7160         }
7161
7162         ctx->file_data->cur_refs = &ref_node->refs;
7163         spin_lock(&ctx->file_data->lock);
7164         list_add(&ref_node->node, &ctx->file_data->ref_list);
7165         spin_unlock(&ctx->file_data->lock);
7166         percpu_ref_get(&ctx->file_data->refs);
7167         return ret;
7168 }
7169
7170 static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
7171                                 int index)
7172 {
7173 #if defined(CONFIG_UNIX)
7174         struct sock *sock = ctx->ring_sock->sk;
7175         struct sk_buff_head *head = &sock->sk_receive_queue;
7176         struct sk_buff *skb;
7177
7178         /*
7179          * See if we can merge this file into an existing skb SCM_RIGHTS
7180          * file set. If there's no room, fall back to allocating a new skb
7181          * and filling it in.
7182          */
7183         spin_lock_irq(&head->lock);
7184         skb = skb_peek(head);
7185         if (skb) {
7186                 struct scm_fp_list *fpl = UNIXCB(skb).fp;
7187
7188                 if (fpl->count < SCM_MAX_FD) {
7189                         __skb_unlink(skb, head);
7190                         spin_unlock_irq(&head->lock);
7191                         fpl->fp[fpl->count] = get_file(file);
7192                         unix_inflight(fpl->user, fpl->fp[fpl->count]);
7193                         fpl->count++;
7194                         spin_lock_irq(&head->lock);
7195                         __skb_queue_head(head, skb);
7196                 } else {
7197                         skb = NULL;
7198                 }
7199         }
7200         spin_unlock_irq(&head->lock);
7201
7202         if (skb) {
7203                 fput(file);
7204                 return 0;
7205         }
7206
7207         return __io_sqe_files_scm(ctx, 1, index);
7208 #else
7209         return 0;
7210 #endif
7211 }
7212
7213 static int io_queue_file_removal(struct fixed_file_data *data,
7214                                  struct file *file)
7215 {
7216         struct io_file_put *pfile;
7217         struct percpu_ref *refs = data->cur_refs;
7218         struct fixed_file_ref_node *ref_node;
7219
7220         pfile = kzalloc(sizeof(*pfile), GFP_KERNEL);
7221         if (!pfile)
7222                 return -ENOMEM;
7223
7224         ref_node = container_of(refs, struct fixed_file_ref_node, refs);
7225         pfile->file = file;
7226         list_add(&pfile->list, &ref_node->file_list);
7227
7228         return 0;
7229 }
7230
7231 static int __io_sqe_files_update(struct io_ring_ctx *ctx,
7232                                  struct io_uring_files_update *up,
7233                                  unsigned nr_args)
7234 {
7235         struct fixed_file_data *data = ctx->file_data;
7236         struct fixed_file_ref_node *ref_node;
7237         struct file *file;
7238         __s32 __user *fds;
7239         int fd, i, err;
7240         __u32 done;
7241         bool needs_switch = false;
7242
7243         if (check_add_overflow(up->offset, nr_args, &done))
7244                 return -EOVERFLOW;
7245         if (done > ctx->nr_user_files)
7246                 return -EINVAL;
7247
7248         ref_node = alloc_fixed_file_ref_node(ctx);
7249         if (IS_ERR(ref_node))
7250                 return PTR_ERR(ref_node);
7251
7252         done = 0;
7253         fds = u64_to_user_ptr(up->fds);
7254         while (nr_args) {
7255                 struct fixed_file_table *table;
7256                 unsigned index;
7257
7258                 err = 0;
7259                 if (copy_from_user(&fd, &fds[done], sizeof(fd))) {
7260                         err = -EFAULT;
7261                         break;
7262                 }
7263                 i = array_index_nospec(up->offset, ctx->nr_user_files);
7264                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
7265                 index = i & IORING_FILE_TABLE_MASK;
7266                 if (table->files[index]) {
7267                         file = io_file_from_index(ctx, index);
7268                         err = io_queue_file_removal(data, file);
7269                         if (err)
7270                                 break;
7271                         table->files[index] = NULL;
7272                         needs_switch = true;
7273                 }
7274                 if (fd != -1) {
7275                         file = fget(fd);
7276                         if (!file) {
7277                                 err = -EBADF;
7278                                 break;
7279                         }
7280                         /*
7281                          * Don't allow io_uring instances to be registered. If
7282                          * UNIX isn't enabled, then this causes a reference
7283                          * cycle and this instance can never get freed. If UNIX
7284                          * is enabled we'll handle it just fine, but there's
7285                          * still no point in allowing a ring fd as it doesn't
7286                          * support regular read/write anyway.
7287                          */
7288                         if (file->f_op == &io_uring_fops) {
7289                                 fput(file);
7290                                 err = -EBADF;
7291                                 break;
7292                         }
7293                         table->files[index] = file;
7294                         err = io_sqe_file_register(ctx, file, i);
7295                         if (err) {
7296                                 fput(file);
7297                                 break;
7298                         }
7299                 }
7300                 nr_args--;
7301                 done++;
7302                 up->offset++;
7303         }
7304
7305         if (needs_switch) {
7306                 percpu_ref_kill(data->cur_refs);
7307                 spin_lock(&data->lock);
7308                 list_add(&ref_node->node, &data->ref_list);
7309                 data->cur_refs = &ref_node->refs;
7310                 spin_unlock(&data->lock);
7311                 percpu_ref_get(&ctx->file_data->refs);
7312         } else
7313                 destroy_fixed_file_ref_node(ref_node);
7314
7315         return done ? done : err;
7316 }
7317
7318 static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
7319                                unsigned nr_args)
7320 {
7321         struct io_uring_files_update up;
7322
7323         if (!ctx->file_data)
7324                 return -ENXIO;
7325         if (!nr_args)
7326                 return -EINVAL;
7327         if (copy_from_user(&up, arg, sizeof(up)))
7328                 return -EFAULT;
7329         if (up.resv)
7330                 return -EINVAL;
7331
7332         return __io_sqe_files_update(ctx, &up, nr_args);
7333 }
7334
7335 static void io_free_work(struct io_wq_work *work)
7336 {
7337         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
7338
7339         /* Consider that io_steal_work() relies on this ref */
7340         io_put_req(req);
7341 }
7342
7343 static int io_init_wq_offload(struct io_ring_ctx *ctx,
7344                               struct io_uring_params *p)
7345 {
7346         struct io_wq_data data;
7347         struct fd f;
7348         struct io_ring_ctx *ctx_attach;
7349         unsigned int concurrency;
7350         int ret = 0;
7351
7352         data.user = ctx->user;
7353         data.free_work = io_free_work;
7354         data.do_work = io_wq_submit_work;
7355
7356         if (!(p->flags & IORING_SETUP_ATTACH_WQ)) {
7357                 /* Do QD, or 4 * CPUS, whatever is smallest */
7358                 concurrency = min(ctx->sq_entries, 4 * num_online_cpus());
7359
7360                 ctx->io_wq = io_wq_create(concurrency, &data);
7361                 if (IS_ERR(ctx->io_wq)) {
7362                         ret = PTR_ERR(ctx->io_wq);
7363                         ctx->io_wq = NULL;
7364                 }
7365                 return ret;
7366         }
7367
7368         f = fdget(p->wq_fd);
7369         if (!f.file)
7370                 return -EBADF;
7371
7372         if (f.file->f_op != &io_uring_fops) {
7373                 ret = -EINVAL;
7374                 goto out_fput;
7375         }
7376
7377         ctx_attach = f.file->private_data;
7378         /* @io_wq is protected by holding the fd */
7379         if (!io_wq_get(ctx_attach->io_wq, &data)) {
7380                 ret = -EINVAL;
7381                 goto out_fput;
7382         }
7383
7384         ctx->io_wq = ctx_attach->io_wq;
7385 out_fput:
7386         fdput(f);
7387         return ret;
7388 }
7389
7390 static int io_sq_offload_start(struct io_ring_ctx *ctx,
7391                                struct io_uring_params *p)
7392 {
7393         int ret;
7394
7395         mmgrab(current->mm);
7396         ctx->sqo_mm = current->mm;
7397
7398         if (ctx->flags & IORING_SETUP_SQPOLL) {
7399                 ret = -EPERM;
7400                 if (!capable(CAP_SYS_ADMIN))
7401                         goto err;
7402
7403                 ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
7404                 if (!ctx->sq_thread_idle)
7405                         ctx->sq_thread_idle = HZ;
7406
7407                 if (p->flags & IORING_SETUP_SQ_AFF) {
7408                         int cpu = p->sq_thread_cpu;
7409
7410                         ret = -EINVAL;
7411                         if (cpu >= nr_cpu_ids)
7412                                 goto err;
7413                         if (!cpu_online(cpu))
7414                                 goto err;
7415
7416                         ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
7417                                                         ctx, cpu,
7418                                                         "io_uring-sq");
7419                 } else {
7420                         ctx->sqo_thread = kthread_create(io_sq_thread, ctx,
7421                                                         "io_uring-sq");
7422                 }
7423                 if (IS_ERR(ctx->sqo_thread)) {
7424                         ret = PTR_ERR(ctx->sqo_thread);
7425                         ctx->sqo_thread = NULL;
7426                         goto err;
7427                 }
7428                 wake_up_process(ctx->sqo_thread);
7429         } else if (p->flags & IORING_SETUP_SQ_AFF) {
7430                 /* Can't have SQ_AFF without SQPOLL */
7431                 ret = -EINVAL;
7432                 goto err;
7433         }
7434
7435         ret = io_init_wq_offload(ctx, p);
7436         if (ret)
7437                 goto err;
7438
7439         return 0;
7440 err:
7441         io_finish_async(ctx);
7442         if (ctx->sqo_mm) {
7443                 mmdrop(ctx->sqo_mm);
7444                 ctx->sqo_mm = NULL;
7445         }
7446         return ret;
7447 }
7448
7449 static inline void __io_unaccount_mem(struct user_struct *user,
7450                                       unsigned long nr_pages)
7451 {
7452         atomic_long_sub(nr_pages, &user->locked_vm);
7453 }
7454
7455 static inline int __io_account_mem(struct user_struct *user,
7456                                    unsigned long nr_pages)
7457 {
7458         unsigned long page_limit, cur_pages, new_pages;
7459
7460         /* Don't allow more pages than we can safely lock */
7461         page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
7462
7463         do {
7464                 cur_pages = atomic_long_read(&user->locked_vm);
7465                 new_pages = cur_pages + nr_pages;
7466                 if (new_pages > page_limit)
7467                         return -ENOMEM;
7468         } while (atomic_long_cmpxchg(&user->locked_vm, cur_pages,
7469                                         new_pages) != cur_pages);
7470
7471         return 0;
7472 }
7473
7474 static void io_unaccount_mem(struct io_ring_ctx *ctx, unsigned long nr_pages,
7475                              enum io_mem_account acct)
7476 {
7477         if (ctx->limit_mem)
7478                 __io_unaccount_mem(ctx->user, nr_pages);
7479
7480         if (ctx->sqo_mm) {
7481                 if (acct == ACCT_LOCKED)
7482                         ctx->sqo_mm->locked_vm -= nr_pages;
7483                 else if (acct == ACCT_PINNED)
7484                         atomic64_sub(nr_pages, &ctx->sqo_mm->pinned_vm);
7485         }
7486 }
7487
7488 static int io_account_mem(struct io_ring_ctx *ctx, unsigned long nr_pages,
7489                           enum io_mem_account acct)
7490 {
7491         int ret;
7492
7493         if (ctx->limit_mem) {
7494                 ret = __io_account_mem(ctx->user, nr_pages);
7495                 if (ret)
7496                         return ret;
7497         }
7498
7499         if (ctx->sqo_mm) {
7500                 if (acct == ACCT_LOCKED)
7501                         ctx->sqo_mm->locked_vm += nr_pages;
7502                 else if (acct == ACCT_PINNED)
7503                         atomic64_add(nr_pages, &ctx->sqo_mm->pinned_vm);
7504         }
7505
7506         return 0;
7507 }
7508
7509 static void io_mem_free(void *ptr)
7510 {
7511         struct page *page;
7512
7513         if (!ptr)
7514                 return;
7515
7516         page = virt_to_head_page(ptr);
7517         if (put_page_testzero(page))
7518                 free_compound_page(page);
7519 }
7520
7521 static void *io_mem_alloc(size_t size)
7522 {
7523         gfp_t gfp_flags = GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN | __GFP_COMP |
7524                                 __GFP_NORETRY;
7525
7526         return (void *) __get_free_pages(gfp_flags, get_order(size));
7527 }
7528
7529 static unsigned long rings_size(unsigned sq_entries, unsigned cq_entries,
7530                                 size_t *sq_offset)
7531 {
7532         struct io_rings *rings;
7533         size_t off, sq_array_size;
7534
7535         off = struct_size(rings, cqes, cq_entries);
7536         if (off == SIZE_MAX)
7537                 return SIZE_MAX;
7538
7539 #ifdef CONFIG_SMP
7540         off = ALIGN(off, SMP_CACHE_BYTES);
7541         if (off == 0)
7542                 return SIZE_MAX;
7543 #endif
7544
7545         if (sq_offset)
7546                 *sq_offset = off;
7547
7548         sq_array_size = array_size(sizeof(u32), sq_entries);
7549         if (sq_array_size == SIZE_MAX)
7550                 return SIZE_MAX;
7551
7552         if (check_add_overflow(off, sq_array_size, &off))
7553                 return SIZE_MAX;
7554
7555         return off;
7556 }
7557
7558 static unsigned long ring_pages(unsigned sq_entries, unsigned cq_entries)
7559 {
7560         size_t pages;
7561
7562         pages = (size_t)1 << get_order(
7563                 rings_size(sq_entries, cq_entries, NULL));
7564         pages += (size_t)1 << get_order(
7565                 array_size(sizeof(struct io_uring_sqe), sq_entries));
7566
7567         return pages;
7568 }
7569
7570 static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx)
7571 {
7572         int i, j;
7573
7574         if (!ctx->user_bufs)
7575                 return -ENXIO;
7576
7577         for (i = 0; i < ctx->nr_user_bufs; i++) {
7578                 struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
7579
7580                 for (j = 0; j < imu->nr_bvecs; j++)
7581                         unpin_user_page(imu->bvec[j].bv_page);
7582
7583                 io_unaccount_mem(ctx, imu->nr_bvecs, ACCT_PINNED);
7584                 kvfree(imu->bvec);
7585                 imu->nr_bvecs = 0;
7586         }
7587
7588         kfree(ctx->user_bufs);
7589         ctx->user_bufs = NULL;
7590         ctx->nr_user_bufs = 0;
7591         return 0;
7592 }
7593
7594 static int io_copy_iov(struct io_ring_ctx *ctx, struct iovec *dst,
7595                        void __user *arg, unsigned index)
7596 {
7597         struct iovec __user *src;
7598
7599 #ifdef CONFIG_COMPAT
7600         if (ctx->compat) {
7601                 struct compat_iovec __user *ciovs;
7602                 struct compat_iovec ciov;
7603
7604                 ciovs = (struct compat_iovec __user *) arg;
7605                 if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
7606                         return -EFAULT;
7607
7608                 dst->iov_base = u64_to_user_ptr((u64)ciov.iov_base);
7609                 dst->iov_len = ciov.iov_len;
7610                 return 0;
7611         }
7612 #endif
7613         src = (struct iovec __user *) arg;
7614         if (copy_from_user(dst, &src[index], sizeof(*dst)))
7615                 return -EFAULT;
7616         return 0;
7617 }
7618
7619 static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
7620                                   unsigned nr_args)
7621 {
7622         struct vm_area_struct **vmas = NULL;
7623         struct page **pages = NULL;
7624         int i, j, got_pages = 0;
7625         int ret = -EINVAL;
7626
7627         if (ctx->user_bufs)
7628                 return -EBUSY;
7629         if (!nr_args || nr_args > UIO_MAXIOV)
7630                 return -EINVAL;
7631
7632         ctx->user_bufs = kcalloc(nr_args, sizeof(struct io_mapped_ubuf),
7633                                         GFP_KERNEL);
7634         if (!ctx->user_bufs)
7635                 return -ENOMEM;
7636
7637         for (i = 0; i < nr_args; i++) {
7638                 struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
7639                 unsigned long off, start, end, ubuf;
7640                 int pret, nr_pages;
7641                 struct iovec iov;
7642                 size_t size;
7643
7644                 ret = io_copy_iov(ctx, &iov, arg, i);
7645                 if (ret)
7646                         goto err;
7647
7648                 /*
7649                  * Don't impose further limits on the size and buffer
7650                  * constraints here, we'll -EINVAL later when IO is
7651                  * submitted if they are wrong.
7652                  */
7653                 ret = -EFAULT;
7654                 if (!iov.iov_base || !iov.iov_len)
7655                         goto err;
7656
7657                 /* arbitrary limit, but we need something */
7658                 if (iov.iov_len > SZ_1G)
7659                         goto err;
7660
7661                 ubuf = (unsigned long) iov.iov_base;
7662                 end = (ubuf + iov.iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
7663                 start = ubuf >> PAGE_SHIFT;
7664                 nr_pages = end - start;
7665
7666                 ret = io_account_mem(ctx, nr_pages, ACCT_PINNED);
7667                 if (ret)
7668                         goto err;
7669
7670                 ret = 0;
7671                 if (!pages || nr_pages > got_pages) {
7672                         kvfree(vmas);
7673                         kvfree(pages);
7674                         pages = kvmalloc_array(nr_pages, sizeof(struct page *),
7675                                                 GFP_KERNEL);
7676                         vmas = kvmalloc_array(nr_pages,
7677                                         sizeof(struct vm_area_struct *),
7678                                         GFP_KERNEL);
7679                         if (!pages || !vmas) {
7680                                 ret = -ENOMEM;
7681                                 io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7682                                 goto err;
7683                         }
7684                         got_pages = nr_pages;
7685                 }
7686
7687                 imu->bvec = kvmalloc_array(nr_pages, sizeof(struct bio_vec),
7688                                                 GFP_KERNEL);
7689                 ret = -ENOMEM;
7690                 if (!imu->bvec) {
7691                         io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7692                         goto err;
7693                 }
7694
7695                 ret = 0;
7696                 mmap_read_lock(current->mm);
7697                 pret = pin_user_pages(ubuf, nr_pages,
7698                                       FOLL_WRITE | FOLL_LONGTERM,
7699                                       pages, vmas);
7700                 if (pret == nr_pages) {
7701                         /* don't support file backed memory */
7702                         for (j = 0; j < nr_pages; j++) {
7703                                 struct vm_area_struct *vma = vmas[j];
7704
7705                                 if (vma->vm_file &&
7706                                     !is_file_hugepages(vma->vm_file)) {
7707                                         ret = -EOPNOTSUPP;
7708                                         break;
7709                                 }
7710                         }
7711                 } else {
7712                         ret = pret < 0 ? pret : -EFAULT;
7713                 }
7714                 mmap_read_unlock(current->mm);
7715                 if (ret) {
7716                         /*
7717                          * if we did partial map, or found file backed vmas,
7718                          * release any pages we did get
7719                          */
7720                         if (pret > 0)
7721                                 unpin_user_pages(pages, pret);
7722                         io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7723                         kvfree(imu->bvec);
7724                         goto err;
7725                 }
7726
7727                 off = ubuf & ~PAGE_MASK;
7728                 size = iov.iov_len;
7729                 for (j = 0; j < nr_pages; j++) {
7730                         size_t vec_len;
7731
7732                         vec_len = min_t(size_t, size, PAGE_SIZE - off);
7733                         imu->bvec[j].bv_page = pages[j];
7734                         imu->bvec[j].bv_len = vec_len;
7735                         imu->bvec[j].bv_offset = off;
7736                         off = 0;
7737                         size -= vec_len;
7738                 }
7739                 /* store original address for later verification */
7740                 imu->ubuf = ubuf;
7741                 imu->len = iov.iov_len;
7742                 imu->nr_bvecs = nr_pages;
7743
7744                 ctx->nr_user_bufs++;
7745         }
7746         kvfree(pages);
7747         kvfree(vmas);
7748         return 0;
7749 err:
7750         kvfree(pages);
7751         kvfree(vmas);
7752         io_sqe_buffer_unregister(ctx);
7753         return ret;
7754 }
7755
7756 static int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg)
7757 {
7758         __s32 __user *fds = arg;
7759         int fd;
7760
7761         if (ctx->cq_ev_fd)
7762                 return -EBUSY;
7763
7764         if (copy_from_user(&fd, fds, sizeof(*fds)))
7765                 return -EFAULT;
7766
7767         ctx->cq_ev_fd = eventfd_ctx_fdget(fd);
7768         if (IS_ERR(ctx->cq_ev_fd)) {
7769                 int ret = PTR_ERR(ctx->cq_ev_fd);
7770                 ctx->cq_ev_fd = NULL;
7771                 return ret;
7772         }
7773
7774         return 0;
7775 }
7776
7777 static int io_eventfd_unregister(struct io_ring_ctx *ctx)
7778 {
7779         if (ctx->cq_ev_fd) {
7780                 eventfd_ctx_put(ctx->cq_ev_fd);
7781                 ctx->cq_ev_fd = NULL;
7782                 return 0;
7783         }
7784
7785         return -ENXIO;
7786 }
7787
7788 static int __io_destroy_buffers(int id, void *p, void *data)
7789 {
7790         struct io_ring_ctx *ctx = data;
7791         struct io_buffer *buf = p;
7792
7793         __io_remove_buffers(ctx, buf, id, -1U);
7794         return 0;
7795 }
7796
7797 static void io_destroy_buffers(struct io_ring_ctx *ctx)
7798 {
7799         idr_for_each(&ctx->io_buffer_idr, __io_destroy_buffers, ctx);
7800         idr_destroy(&ctx->io_buffer_idr);
7801 }
7802
7803 static void io_ring_ctx_free(struct io_ring_ctx *ctx)
7804 {
7805         io_finish_async(ctx);
7806         io_sqe_buffer_unregister(ctx);
7807         if (ctx->sqo_mm) {
7808                 mmdrop(ctx->sqo_mm);
7809                 ctx->sqo_mm = NULL;
7810         }
7811
7812         io_sqe_files_unregister(ctx);
7813         io_eventfd_unregister(ctx);
7814         io_destroy_buffers(ctx);
7815         idr_destroy(&ctx->personality_idr);
7816
7817 #if defined(CONFIG_UNIX)
7818         if (ctx->ring_sock) {
7819                 ctx->ring_sock->file = NULL; /* so that iput() is called */
7820                 sock_release(ctx->ring_sock);
7821         }
7822 #endif
7823
7824         io_mem_free(ctx->rings);
7825         io_mem_free(ctx->sq_sqes);
7826
7827         percpu_ref_exit(&ctx->refs);
7828         free_uid(ctx->user);
7829         put_cred(ctx->creds);
7830         kfree(ctx->cancel_hash);
7831         kmem_cache_free(req_cachep, ctx->fallback_req);
7832         kfree(ctx);
7833 }
7834
7835 static __poll_t io_uring_poll(struct file *file, poll_table *wait)
7836 {
7837         struct io_ring_ctx *ctx = file->private_data;
7838         __poll_t mask = 0;
7839
7840         poll_wait(file, &ctx->cq_wait, wait);
7841         /*
7842          * synchronizes with barrier from wq_has_sleeper call in
7843          * io_commit_cqring
7844          */
7845         smp_rmb();
7846         if (READ_ONCE(ctx->rings->sq.tail) - ctx->cached_sq_head !=
7847             ctx->rings->sq_ring_entries)
7848                 mask |= EPOLLOUT | EPOLLWRNORM;
7849         if (io_cqring_events(ctx, false))
7850                 mask |= EPOLLIN | EPOLLRDNORM;
7851
7852         return mask;
7853 }
7854
7855 static int io_uring_fasync(int fd, struct file *file, int on)
7856 {
7857         struct io_ring_ctx *ctx = file->private_data;
7858
7859         return fasync_helper(fd, file, on, &ctx->cq_fasync);
7860 }
7861
7862 static int io_remove_personalities(int id, void *p, void *data)
7863 {
7864         struct io_ring_ctx *ctx = data;
7865         const struct cred *cred;
7866
7867         cred = idr_remove(&ctx->personality_idr, id);
7868         if (cred)
7869                 put_cred(cred);
7870         return 0;
7871 }
7872
7873 static void io_ring_exit_work(struct work_struct *work)
7874 {
7875         struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx,
7876                                                exit_work);
7877
7878         /*
7879          * If we're doing polled IO and end up having requests being
7880          * submitted async (out-of-line), then completions can come in while
7881          * we're waiting for refs to drop. We need to reap these manually,
7882          * as nobody else will be looking for them.
7883          */
7884         do {
7885                 if (ctx->rings)
7886                         io_cqring_overflow_flush(ctx, true);
7887                 io_iopoll_try_reap_events(ctx);
7888         } while (!wait_for_completion_timeout(&ctx->ref_comp, HZ/20));
7889         io_ring_ctx_free(ctx);
7890 }
7891
7892 static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
7893 {
7894         mutex_lock(&ctx->uring_lock);
7895         percpu_ref_kill(&ctx->refs);
7896         mutex_unlock(&ctx->uring_lock);
7897
7898         io_kill_timeouts(ctx);
7899         io_poll_remove_all(ctx);
7900
7901         if (ctx->io_wq)
7902                 io_wq_cancel_all(ctx->io_wq);
7903
7904         /* if we failed setting up the ctx, we might not have any rings */
7905         if (ctx->rings)
7906                 io_cqring_overflow_flush(ctx, true);
7907         io_iopoll_try_reap_events(ctx);
7908         idr_for_each(&ctx->personality_idr, io_remove_personalities, ctx);
7909
7910         /*
7911          * Do this upfront, so we won't have a grace period where the ring
7912          * is closed but resources aren't reaped yet. This can cause
7913          * spurious failure in setting up a new ring.
7914          */
7915         io_unaccount_mem(ctx, ring_pages(ctx->sq_entries, ctx->cq_entries),
7916                          ACCT_LOCKED);
7917
7918         INIT_WORK(&ctx->exit_work, io_ring_exit_work);
7919         queue_work(system_wq, &ctx->exit_work);
7920 }
7921
7922 static int io_uring_release(struct inode *inode, struct file *file)
7923 {
7924         struct io_ring_ctx *ctx = file->private_data;
7925
7926         file->private_data = NULL;
7927         io_ring_ctx_wait_and_kill(ctx);
7928         return 0;
7929 }
7930
7931 static bool io_wq_files_match(struct io_wq_work *work, void *data)
7932 {
7933         struct files_struct *files = data;
7934
7935         return work->files == files;
7936 }
7937
7938 static void io_uring_cancel_files(struct io_ring_ctx *ctx,
7939                                   struct files_struct *files)
7940 {
7941         if (list_empty_careful(&ctx->inflight_list))
7942                 return;
7943
7944         /* cancel all at once, should be faster than doing it one by one*/
7945         io_wq_cancel_cb(ctx->io_wq, io_wq_files_match, files, true);
7946
7947         while (!list_empty_careful(&ctx->inflight_list)) {
7948                 struct io_kiocb *cancel_req = NULL, *req;
7949                 DEFINE_WAIT(wait);
7950
7951                 spin_lock_irq(&ctx->inflight_lock);
7952                 list_for_each_entry(req, &ctx->inflight_list, inflight_entry) {
7953                         if (req->work.files != files)
7954                                 continue;
7955                         /* req is being completed, ignore */
7956                         if (!refcount_inc_not_zero(&req->refs))
7957                                 continue;
7958                         cancel_req = req;
7959                         break;
7960                 }
7961                 if (cancel_req)
7962                         prepare_to_wait(&ctx->inflight_wait, &wait,
7963                                                 TASK_UNINTERRUPTIBLE);
7964                 spin_unlock_irq(&ctx->inflight_lock);
7965
7966                 /* We need to keep going until we don't find a matching req */
7967                 if (!cancel_req)
7968                         break;
7969
7970                 if (cancel_req->flags & REQ_F_OVERFLOW) {
7971                         spin_lock_irq(&ctx->completion_lock);
7972                         list_del(&cancel_req->compl.list);
7973                         cancel_req->flags &= ~REQ_F_OVERFLOW;
7974
7975                         io_cqring_mark_overflow(ctx);
7976                         WRITE_ONCE(ctx->rings->cq_overflow,
7977                                 atomic_inc_return(&ctx->cached_cq_overflow));
7978                         io_commit_cqring(ctx);
7979                         spin_unlock_irq(&ctx->completion_lock);
7980
7981                         /*
7982                          * Put inflight ref and overflow ref. If that's
7983                          * all we had, then we're done with this request.
7984                          */
7985                         if (refcount_sub_and_test(2, &cancel_req->refs)) {
7986                                 io_free_req(cancel_req);
7987                                 finish_wait(&ctx->inflight_wait, &wait);
7988                                 continue;
7989                         }
7990                 } else {
7991                         io_wq_cancel_work(ctx->io_wq, &cancel_req->work);
7992                         io_put_req(cancel_req);
7993                 }
7994
7995                 schedule();
7996                 finish_wait(&ctx->inflight_wait, &wait);
7997         }
7998 }
7999
8000 static bool io_cancel_task_cb(struct io_wq_work *work, void *data)
8001 {
8002         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
8003         struct task_struct *task = data;
8004
8005         return req->task == task;
8006 }
8007
8008 static int io_uring_flush(struct file *file, void *data)
8009 {
8010         struct io_ring_ctx *ctx = file->private_data;
8011
8012         io_uring_cancel_files(ctx, data);
8013
8014         /*
8015          * If the task is going away, cancel work it may have pending
8016          */
8017         if (fatal_signal_pending(current) || (current->flags & PF_EXITING))
8018                 io_wq_cancel_cb(ctx->io_wq, io_cancel_task_cb, current, true);
8019
8020         return 0;
8021 }
8022
8023 static void *io_uring_validate_mmap_request(struct file *file,
8024                                             loff_t pgoff, size_t sz)
8025 {
8026         struct io_ring_ctx *ctx = file->private_data;
8027         loff_t offset = pgoff << PAGE_SHIFT;
8028         struct page *page;
8029         void *ptr;
8030
8031         switch (offset) {
8032         case IORING_OFF_SQ_RING:
8033         case IORING_OFF_CQ_RING:
8034                 ptr = ctx->rings;
8035                 break;
8036         case IORING_OFF_SQES:
8037                 ptr = ctx->sq_sqes;
8038                 break;
8039         default:
8040                 return ERR_PTR(-EINVAL);
8041         }
8042
8043         page = virt_to_head_page(ptr);
8044         if (sz > page_size(page))
8045                 return ERR_PTR(-EINVAL);
8046
8047         return ptr;
8048 }
8049
8050 #ifdef CONFIG_MMU
8051
8052 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
8053 {
8054         size_t sz = vma->vm_end - vma->vm_start;
8055         unsigned long pfn;
8056         void *ptr;
8057
8058         ptr = io_uring_validate_mmap_request(file, vma->vm_pgoff, sz);
8059         if (IS_ERR(ptr))
8060                 return PTR_ERR(ptr);
8061
8062         pfn = virt_to_phys(ptr) >> PAGE_SHIFT;
8063         return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
8064 }
8065
8066 #else /* !CONFIG_MMU */
8067
8068 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
8069 {
8070         return vma->vm_flags & (VM_SHARED | VM_MAYSHARE) ? 0 : -EINVAL;
8071 }
8072
8073 static unsigned int io_uring_nommu_mmap_capabilities(struct file *file)
8074 {
8075         return NOMMU_MAP_DIRECT | NOMMU_MAP_READ | NOMMU_MAP_WRITE;
8076 }
8077
8078 static unsigned long io_uring_nommu_get_unmapped_area(struct file *file,
8079         unsigned long addr, unsigned long len,
8080         unsigned long pgoff, unsigned long flags)
8081 {
8082         void *ptr;
8083
8084         ptr = io_uring_validate_mmap_request(file, pgoff, len);
8085         if (IS_ERR(ptr))
8086                 return PTR_ERR(ptr);
8087
8088         return (unsigned long) ptr;
8089 }
8090
8091 #endif /* !CONFIG_MMU */
8092
8093 SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
8094                 u32, min_complete, u32, flags, const sigset_t __user *, sig,
8095                 size_t, sigsz)
8096 {
8097         struct io_ring_ctx *ctx;
8098         long ret = -EBADF;
8099         int submitted = 0;
8100         struct fd f;
8101
8102         io_run_task_work();
8103
8104         if (flags & ~(IORING_ENTER_GETEVENTS | IORING_ENTER_SQ_WAKEUP))
8105                 return -EINVAL;
8106
8107         f = fdget(fd);
8108         if (!f.file)
8109                 return -EBADF;
8110
8111         ret = -EOPNOTSUPP;
8112         if (f.file->f_op != &io_uring_fops)
8113                 goto out_fput;
8114
8115         ret = -ENXIO;
8116         ctx = f.file->private_data;
8117         if (!percpu_ref_tryget(&ctx->refs))
8118                 goto out_fput;
8119
8120         /*
8121          * For SQ polling, the thread will do all submissions and completions.
8122          * Just return the requested submit count, and wake the thread if
8123          * we were asked to.
8124          */
8125         ret = 0;
8126         if (ctx->flags & IORING_SETUP_SQPOLL) {
8127                 if (!list_empty_careful(&ctx->cq_overflow_list))
8128                         io_cqring_overflow_flush(ctx, false);
8129                 if (flags & IORING_ENTER_SQ_WAKEUP)
8130                         wake_up(&ctx->sqo_wait);
8131                 submitted = to_submit;
8132         } else if (to_submit) {
8133                 mutex_lock(&ctx->uring_lock);
8134                 submitted = io_submit_sqes(ctx, to_submit, f.file, fd);
8135                 mutex_unlock(&ctx->uring_lock);
8136
8137                 if (submitted != to_submit)
8138                         goto out;
8139         }
8140         if (flags & IORING_ENTER_GETEVENTS) {
8141                 min_complete = min(min_complete, ctx->cq_entries);
8142
8143                 /*
8144                  * When SETUP_IOPOLL and SETUP_SQPOLL are both enabled, user
8145                  * space applications don't need to do io completion events
8146                  * polling again, they can rely on io_sq_thread to do polling
8147                  * work, which can reduce cpu usage and uring_lock contention.
8148                  */
8149                 if (ctx->flags & IORING_SETUP_IOPOLL &&
8150                     !(ctx->flags & IORING_SETUP_SQPOLL)) {
8151                         ret = io_iopoll_check(ctx, min_complete);
8152                 } else {
8153                         ret = io_cqring_wait(ctx, min_complete, sig, sigsz);
8154                 }
8155         }
8156
8157 out:
8158         percpu_ref_put(&ctx->refs);
8159 out_fput:
8160         fdput(f);
8161         return submitted ? submitted : ret;
8162 }
8163
8164 #ifdef CONFIG_PROC_FS
8165 static int io_uring_show_cred(int id, void *p, void *data)
8166 {
8167         const struct cred *cred = p;
8168         struct seq_file *m = data;
8169         struct user_namespace *uns = seq_user_ns(m);
8170         struct group_info *gi;
8171         kernel_cap_t cap;
8172         unsigned __capi;
8173         int g;
8174
8175         seq_printf(m, "%5d\n", id);
8176         seq_put_decimal_ull(m, "\tUid:\t", from_kuid_munged(uns, cred->uid));
8177         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->euid));
8178         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->suid));
8179         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->fsuid));
8180         seq_put_decimal_ull(m, "\n\tGid:\t", from_kgid_munged(uns, cred->gid));
8181         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->egid));
8182         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->sgid));
8183         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->fsgid));
8184         seq_puts(m, "\n\tGroups:\t");
8185         gi = cred->group_info;
8186         for (g = 0; g < gi->ngroups; g++) {
8187                 seq_put_decimal_ull(m, g ? " " : "",
8188                                         from_kgid_munged(uns, gi->gid[g]));
8189         }
8190         seq_puts(m, "\n\tCapEff:\t");
8191         cap = cred->cap_effective;
8192         CAP_FOR_EACH_U32(__capi)
8193                 seq_put_hex_ll(m, NULL, cap.cap[CAP_LAST_U32 - __capi], 8);
8194         seq_putc(m, '\n');
8195         return 0;
8196 }
8197
8198 static void __io_uring_show_fdinfo(struct io_ring_ctx *ctx, struct seq_file *m)
8199 {
8200         int i;
8201
8202         mutex_lock(&ctx->uring_lock);
8203         seq_printf(m, "UserFiles:\t%u\n", ctx->nr_user_files);
8204         for (i = 0; i < ctx->nr_user_files; i++) {
8205                 struct fixed_file_table *table;
8206                 struct file *f;
8207
8208                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
8209                 f = table->files[i & IORING_FILE_TABLE_MASK];
8210                 if (f)
8211                         seq_printf(m, "%5u: %s\n", i, file_dentry(f)->d_iname);
8212                 else
8213                         seq_printf(m, "%5u: <none>\n", i);
8214         }
8215         seq_printf(m, "UserBufs:\t%u\n", ctx->nr_user_bufs);
8216         for (i = 0; i < ctx->nr_user_bufs; i++) {
8217                 struct io_mapped_ubuf *buf = &ctx->user_bufs[i];
8218
8219                 seq_printf(m, "%5u: 0x%llx/%u\n", i, buf->ubuf,
8220                                                 (unsigned int) buf->len);
8221         }
8222         if (!idr_is_empty(&ctx->personality_idr)) {
8223                 seq_printf(m, "Personalities:\n");
8224                 idr_for_each(&ctx->personality_idr, io_uring_show_cred, m);
8225         }
8226         seq_printf(m, "PollList:\n");
8227         spin_lock_irq(&ctx->completion_lock);
8228         for (i = 0; i < (1U << ctx->cancel_hash_bits); i++) {
8229                 struct hlist_head *list = &ctx->cancel_hash[i];
8230                 struct io_kiocb *req;
8231
8232                 hlist_for_each_entry(req, list, hash_node)
8233                         seq_printf(m, "  op=%d, task_works=%d\n", req->opcode,
8234                                         req->task->task_works != NULL);
8235         }
8236         spin_unlock_irq(&ctx->completion_lock);
8237         mutex_unlock(&ctx->uring_lock);
8238 }
8239
8240 static void io_uring_show_fdinfo(struct seq_file *m, struct file *f)
8241 {
8242         struct io_ring_ctx *ctx = f->private_data;
8243
8244         if (percpu_ref_tryget(&ctx->refs)) {
8245                 __io_uring_show_fdinfo(ctx, m);
8246                 percpu_ref_put(&ctx->refs);
8247         }
8248 }
8249 #endif
8250
8251 static const struct file_operations io_uring_fops = {
8252         .release        = io_uring_release,
8253         .flush          = io_uring_flush,
8254         .mmap           = io_uring_mmap,
8255 #ifndef CONFIG_MMU
8256         .get_unmapped_area = io_uring_nommu_get_unmapped_area,
8257         .mmap_capabilities = io_uring_nommu_mmap_capabilities,
8258 #endif
8259         .poll           = io_uring_poll,
8260         .fasync         = io_uring_fasync,
8261 #ifdef CONFIG_PROC_FS
8262         .show_fdinfo    = io_uring_show_fdinfo,
8263 #endif
8264 };
8265
8266 static int io_allocate_scq_urings(struct io_ring_ctx *ctx,
8267                                   struct io_uring_params *p)
8268 {
8269         struct io_rings *rings;
8270         size_t size, sq_array_offset;
8271
8272         /* make sure these are sane, as we already accounted them */
8273         ctx->sq_entries = p->sq_entries;
8274         ctx->cq_entries = p->cq_entries;
8275
8276         size = rings_size(p->sq_entries, p->cq_entries, &sq_array_offset);
8277         if (size == SIZE_MAX)
8278                 return -EOVERFLOW;
8279
8280         rings = io_mem_alloc(size);
8281         if (!rings)
8282                 return -ENOMEM;
8283
8284         ctx->rings = rings;
8285         ctx->sq_array = (u32 *)((char *)rings + sq_array_offset);
8286         rings->sq_ring_mask = p->sq_entries - 1;
8287         rings->cq_ring_mask = p->cq_entries - 1;
8288         rings->sq_ring_entries = p->sq_entries;
8289         rings->cq_ring_entries = p->cq_entries;
8290         ctx->sq_mask = rings->sq_ring_mask;
8291         ctx->cq_mask = rings->cq_ring_mask;
8292
8293         size = array_size(sizeof(struct io_uring_sqe), p->sq_entries);
8294         if (size == SIZE_MAX) {
8295                 io_mem_free(ctx->rings);
8296                 ctx->rings = NULL;
8297                 return -EOVERFLOW;
8298         }
8299
8300         ctx->sq_sqes = io_mem_alloc(size);
8301         if (!ctx->sq_sqes) {
8302                 io_mem_free(ctx->rings);
8303                 ctx->rings = NULL;
8304                 return -ENOMEM;
8305         }
8306
8307         return 0;
8308 }
8309
8310 /*
8311  * Allocate an anonymous fd, this is what constitutes the application
8312  * visible backing of an io_uring instance. The application mmaps this
8313  * fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
8314  * we have to tie this fd to a socket for file garbage collection purposes.
8315  */
8316 static int io_uring_get_fd(struct io_ring_ctx *ctx)
8317 {
8318         struct file *file;
8319         int ret;
8320
8321 #if defined(CONFIG_UNIX)
8322         ret = sock_create_kern(&init_net, PF_UNIX, SOCK_RAW, IPPROTO_IP,
8323                                 &ctx->ring_sock);
8324         if (ret)
8325                 return ret;
8326 #endif
8327
8328         ret = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
8329         if (ret < 0)
8330                 goto err;
8331
8332         file = anon_inode_getfile("[io_uring]", &io_uring_fops, ctx,
8333                                         O_RDWR | O_CLOEXEC);
8334         if (IS_ERR(file)) {
8335                 put_unused_fd(ret);
8336                 ret = PTR_ERR(file);
8337                 goto err;
8338         }
8339
8340 #if defined(CONFIG_UNIX)
8341         ctx->ring_sock->file = file;
8342 #endif
8343         fd_install(ret, file);
8344         return ret;
8345 err:
8346 #if defined(CONFIG_UNIX)
8347         sock_release(ctx->ring_sock);
8348         ctx->ring_sock = NULL;
8349 #endif
8350         return ret;
8351 }
8352
8353 static int io_uring_create(unsigned entries, struct io_uring_params *p,
8354                            struct io_uring_params __user *params)
8355 {
8356         struct user_struct *user = NULL;
8357         struct io_ring_ctx *ctx;
8358         bool limit_mem;
8359         int ret;
8360
8361         if (!entries)
8362                 return -EINVAL;
8363         if (entries > IORING_MAX_ENTRIES) {
8364                 if (!(p->flags & IORING_SETUP_CLAMP))
8365                         return -EINVAL;
8366                 entries = IORING_MAX_ENTRIES;
8367         }
8368
8369         /*
8370          * Use twice as many entries for the CQ ring. It's possible for the
8371          * application to drive a higher depth than the size of the SQ ring,
8372          * since the sqes are only used at submission time. This allows for
8373          * some flexibility in overcommitting a bit. If the application has
8374          * set IORING_SETUP_CQSIZE, it will have passed in the desired number
8375          * of CQ ring entries manually.
8376          */
8377         p->sq_entries = roundup_pow_of_two(entries);
8378         if (p->flags & IORING_SETUP_CQSIZE) {
8379                 /*
8380                  * If IORING_SETUP_CQSIZE is set, we do the same roundup
8381                  * to a power-of-two, if it isn't already. We do NOT impose
8382                  * any cq vs sq ring sizing.
8383                  */
8384                 if (p->cq_entries < p->sq_entries)
8385                         return -EINVAL;
8386                 if (p->cq_entries > IORING_MAX_CQ_ENTRIES) {
8387                         if (!(p->flags & IORING_SETUP_CLAMP))
8388                                 return -EINVAL;
8389                         p->cq_entries = IORING_MAX_CQ_ENTRIES;
8390                 }
8391                 p->cq_entries = roundup_pow_of_two(p->cq_entries);
8392         } else {
8393                 p->cq_entries = 2 * p->sq_entries;
8394         }
8395
8396         user = get_uid(current_user());
8397         limit_mem = !capable(CAP_IPC_LOCK);
8398
8399         if (limit_mem) {
8400                 ret = __io_account_mem(user,
8401                                 ring_pages(p->sq_entries, p->cq_entries));
8402                 if (ret) {
8403                         free_uid(user);
8404                         return ret;
8405                 }
8406         }
8407
8408         ctx = io_ring_ctx_alloc(p);
8409         if (!ctx) {
8410                 if (limit_mem)
8411                         __io_unaccount_mem(user, ring_pages(p->sq_entries,
8412                                                                 p->cq_entries));
8413                 free_uid(user);
8414                 return -ENOMEM;
8415         }
8416         ctx->compat = in_compat_syscall();
8417         ctx->user = user;
8418         ctx->creds = get_current_cred();
8419
8420         /*
8421          * Account memory _before_ installing the file descriptor. Once
8422          * the descriptor is installed, it can get closed at any time. Also
8423          * do this before hitting the general error path, as ring freeing
8424          * will un-account as well.
8425          */
8426         io_account_mem(ctx, ring_pages(p->sq_entries, p->cq_entries),
8427                        ACCT_LOCKED);
8428         ctx->limit_mem = limit_mem;
8429
8430         ret = io_allocate_scq_urings(ctx, p);
8431         if (ret)
8432                 goto err;
8433
8434         ret = io_sq_offload_start(ctx, p);
8435         if (ret)
8436                 goto err;
8437
8438         memset(&p->sq_off, 0, sizeof(p->sq_off));
8439         p->sq_off.head = offsetof(struct io_rings, sq.head);
8440         p->sq_off.tail = offsetof(struct io_rings, sq.tail);
8441         p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask);
8442         p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries);
8443         p->sq_off.flags = offsetof(struct io_rings, sq_flags);
8444         p->sq_off.dropped = offsetof(struct io_rings, sq_dropped);
8445         p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings;
8446
8447         memset(&p->cq_off, 0, sizeof(p->cq_off));
8448         p->cq_off.head = offsetof(struct io_rings, cq.head);
8449         p->cq_off.tail = offsetof(struct io_rings, cq.tail);
8450         p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask);
8451         p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries);
8452         p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
8453         p->cq_off.cqes = offsetof(struct io_rings, cqes);
8454         p->cq_off.flags = offsetof(struct io_rings, cq_flags);
8455
8456         p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
8457                         IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
8458                         IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL |
8459                         IORING_FEAT_POLL_32BITS;
8460
8461         if (copy_to_user(params, p, sizeof(*p))) {
8462                 ret = -EFAULT;
8463                 goto err;
8464         }
8465
8466         /*
8467          * Install ring fd as the very last thing, so we don't risk someone
8468          * having closed it before we finish setup
8469          */
8470         ret = io_uring_get_fd(ctx);
8471         if (ret < 0)
8472                 goto err;
8473
8474         trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
8475         return ret;
8476 err:
8477         io_ring_ctx_wait_and_kill(ctx);
8478         return ret;
8479 }
8480
8481 /*
8482  * Sets up an aio uring context, and returns the fd. Applications asks for a
8483  * ring size, we return the actual sq/cq ring sizes (among other things) in the
8484  * params structure passed in.
8485  */
8486 static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
8487 {
8488         struct io_uring_params p;
8489         int i;
8490
8491         if (copy_from_user(&p, params, sizeof(p)))
8492                 return -EFAULT;
8493         for (i = 0; i < ARRAY_SIZE(p.resv); i++) {
8494                 if (p.resv[i])
8495                         return -EINVAL;
8496         }
8497
8498         if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
8499                         IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE |
8500                         IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ))
8501                 return -EINVAL;
8502
8503         return  io_uring_create(entries, &p, params);
8504 }
8505
8506 SYSCALL_DEFINE2(io_uring_setup, u32, entries,
8507                 struct io_uring_params __user *, params)
8508 {
8509         return io_uring_setup(entries, params);
8510 }
8511
8512 static int io_probe(struct io_ring_ctx *ctx, void __user *arg, unsigned nr_args)
8513 {
8514         struct io_uring_probe *p;
8515         size_t size;
8516         int i, ret;
8517
8518         size = struct_size(p, ops, nr_args);
8519         if (size == SIZE_MAX)
8520                 return -EOVERFLOW;
8521         p = kzalloc(size, GFP_KERNEL);
8522         if (!p)
8523                 return -ENOMEM;
8524
8525         ret = -EFAULT;
8526         if (copy_from_user(p, arg, size))
8527                 goto out;
8528         ret = -EINVAL;
8529         if (memchr_inv(p, 0, size))
8530                 goto out;
8531
8532         p->last_op = IORING_OP_LAST - 1;
8533         if (nr_args > IORING_OP_LAST)
8534                 nr_args = IORING_OP_LAST;
8535
8536         for (i = 0; i < nr_args; i++) {
8537                 p->ops[i].op = i;
8538                 if (!io_op_defs[i].not_supported)
8539                         p->ops[i].flags = IO_URING_OP_SUPPORTED;
8540         }
8541         p->ops_len = i;
8542
8543         ret = 0;
8544         if (copy_to_user(arg, p, size))
8545                 ret = -EFAULT;
8546 out:
8547         kfree(p);
8548         return ret;
8549 }
8550
8551 static int io_register_personality(struct io_ring_ctx *ctx)
8552 {
8553         const struct cred *creds = get_current_cred();
8554         int id;
8555
8556         id = idr_alloc_cyclic(&ctx->personality_idr, (void *) creds, 1,
8557                                 USHRT_MAX, GFP_KERNEL);
8558         if (id < 0)
8559                 put_cred(creds);
8560         return id;
8561 }
8562
8563 static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id)
8564 {
8565         const struct cred *old_creds;
8566
8567         old_creds = idr_remove(&ctx->personality_idr, id);
8568         if (old_creds) {
8569                 put_cred(old_creds);
8570                 return 0;
8571         }
8572
8573         return -EINVAL;
8574 }
8575
8576 static bool io_register_op_must_quiesce(int op)
8577 {
8578         switch (op) {
8579         case IORING_UNREGISTER_FILES:
8580         case IORING_REGISTER_FILES_UPDATE:
8581         case IORING_REGISTER_PROBE:
8582         case IORING_REGISTER_PERSONALITY:
8583         case IORING_UNREGISTER_PERSONALITY:
8584                 return false;
8585         default:
8586                 return true;
8587         }
8588 }
8589
8590 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
8591                                void __user *arg, unsigned nr_args)
8592         __releases(ctx->uring_lock)
8593         __acquires(ctx->uring_lock)
8594 {
8595         int ret;
8596
8597         /*
8598          * We're inside the ring mutex, if the ref is already dying, then
8599          * someone else killed the ctx or is already going through
8600          * io_uring_register().
8601          */
8602         if (percpu_ref_is_dying(&ctx->refs))
8603                 return -ENXIO;
8604
8605         if (io_register_op_must_quiesce(opcode)) {
8606                 percpu_ref_kill(&ctx->refs);
8607
8608                 /*
8609                  * Drop uring mutex before waiting for references to exit. If
8610                  * another thread is currently inside io_uring_enter() it might
8611                  * need to grab the uring_lock to make progress. If we hold it
8612                  * here across the drain wait, then we can deadlock. It's safe
8613                  * to drop the mutex here, since no new references will come in
8614                  * after we've killed the percpu ref.
8615                  */
8616                 mutex_unlock(&ctx->uring_lock);
8617                 ret = wait_for_completion_interruptible(&ctx->ref_comp);
8618                 mutex_lock(&ctx->uring_lock);
8619                 if (ret) {
8620                         percpu_ref_resurrect(&ctx->refs);
8621                         ret = -EINTR;
8622                         goto out;
8623                 }
8624         }
8625
8626         switch (opcode) {
8627         case IORING_REGISTER_BUFFERS:
8628                 ret = io_sqe_buffer_register(ctx, arg, nr_args);
8629                 break;
8630         case IORING_UNREGISTER_BUFFERS:
8631                 ret = -EINVAL;
8632                 if (arg || nr_args)
8633                         break;
8634                 ret = io_sqe_buffer_unregister(ctx);
8635                 break;
8636         case IORING_REGISTER_FILES:
8637                 ret = io_sqe_files_register(ctx, arg, nr_args);
8638                 break;
8639         case IORING_UNREGISTER_FILES:
8640                 ret = -EINVAL;
8641                 if (arg || nr_args)
8642                         break;
8643                 ret = io_sqe_files_unregister(ctx);
8644                 break;
8645         case IORING_REGISTER_FILES_UPDATE:
8646                 ret = io_sqe_files_update(ctx, arg, nr_args);
8647                 break;
8648         case IORING_REGISTER_EVENTFD:
8649         case IORING_REGISTER_EVENTFD_ASYNC:
8650                 ret = -EINVAL;
8651                 if (nr_args != 1)
8652                         break;
8653                 ret = io_eventfd_register(ctx, arg);
8654                 if (ret)
8655                         break;
8656                 if (opcode == IORING_REGISTER_EVENTFD_ASYNC)
8657                         ctx->eventfd_async = 1;
8658                 else
8659                         ctx->eventfd_async = 0;
8660                 break;
8661         case IORING_UNREGISTER_EVENTFD:
8662                 ret = -EINVAL;
8663                 if (arg || nr_args)
8664                         break;
8665                 ret = io_eventfd_unregister(ctx);
8666                 break;
8667         case IORING_REGISTER_PROBE:
8668                 ret = -EINVAL;
8669                 if (!arg || nr_args > 256)
8670                         break;
8671                 ret = io_probe(ctx, arg, nr_args);
8672                 break;
8673         case IORING_REGISTER_PERSONALITY:
8674                 ret = -EINVAL;
8675                 if (arg || nr_args)
8676                         break;
8677                 ret = io_register_personality(ctx);
8678                 break;
8679         case IORING_UNREGISTER_PERSONALITY:
8680                 ret = -EINVAL;
8681                 if (arg)
8682                         break;
8683                 ret = io_unregister_personality(ctx, nr_args);
8684                 break;
8685         default:
8686                 ret = -EINVAL;
8687                 break;
8688         }
8689
8690         if (io_register_op_must_quiesce(opcode)) {
8691                 /* bring the ctx back to life */
8692                 percpu_ref_reinit(&ctx->refs);
8693 out:
8694                 reinit_completion(&ctx->ref_comp);
8695         }
8696         return ret;
8697 }
8698
8699 SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
8700                 void __user *, arg, unsigned int, nr_args)
8701 {
8702         struct io_ring_ctx *ctx;
8703         long ret = -EBADF;
8704         struct fd f;
8705
8706         f = fdget(fd);
8707         if (!f.file)
8708                 return -EBADF;
8709
8710         ret = -EOPNOTSUPP;
8711         if (f.file->f_op != &io_uring_fops)
8712                 goto out_fput;
8713
8714         ctx = f.file->private_data;
8715
8716         mutex_lock(&ctx->uring_lock);
8717         ret = __io_uring_register(ctx, opcode, arg, nr_args);
8718         mutex_unlock(&ctx->uring_lock);
8719         trace_io_uring_register(ctx, opcode, ctx->nr_user_files, ctx->nr_user_bufs,
8720                                                         ctx->cq_ev_fd != NULL, ret);
8721 out_fput:
8722         fdput(f);
8723         return ret;
8724 }
8725
8726 static int __init io_uring_init(void)
8727 {
8728 #define __BUILD_BUG_VERIFY_ELEMENT(stype, eoffset, etype, ename) do { \
8729         BUILD_BUG_ON(offsetof(stype, ename) != eoffset); \
8730         BUILD_BUG_ON(sizeof(etype) != sizeof_field(stype, ename)); \
8731 } while (0)
8732
8733 #define BUILD_BUG_SQE_ELEM(eoffset, etype, ename) \
8734         __BUILD_BUG_VERIFY_ELEMENT(struct io_uring_sqe, eoffset, etype, ename)
8735         BUILD_BUG_ON(sizeof(struct io_uring_sqe) != 64);
8736         BUILD_BUG_SQE_ELEM(0,  __u8,   opcode);
8737         BUILD_BUG_SQE_ELEM(1,  __u8,   flags);
8738         BUILD_BUG_SQE_ELEM(2,  __u16,  ioprio);
8739         BUILD_BUG_SQE_ELEM(4,  __s32,  fd);
8740         BUILD_BUG_SQE_ELEM(8,  __u64,  off);
8741         BUILD_BUG_SQE_ELEM(8,  __u64,  addr2);
8742         BUILD_BUG_SQE_ELEM(16, __u64,  addr);
8743         BUILD_BUG_SQE_ELEM(16, __u64,  splice_off_in);
8744         BUILD_BUG_SQE_ELEM(24, __u32,  len);
8745         BUILD_BUG_SQE_ELEM(28,     __kernel_rwf_t, rw_flags);
8746         BUILD_BUG_SQE_ELEM(28, /* compat */   int, rw_flags);
8747         BUILD_BUG_SQE_ELEM(28, /* compat */ __u32, rw_flags);
8748         BUILD_BUG_SQE_ELEM(28, __u32,  fsync_flags);
8749         BUILD_BUG_SQE_ELEM(28, /* compat */ __u16,  poll_events);
8750         BUILD_BUG_SQE_ELEM(28, __u32,  poll32_events);
8751         BUILD_BUG_SQE_ELEM(28, __u32,  sync_range_flags);
8752         BUILD_BUG_SQE_ELEM(28, __u32,  msg_flags);
8753         BUILD_BUG_SQE_ELEM(28, __u32,  timeout_flags);
8754         BUILD_BUG_SQE_ELEM(28, __u32,  accept_flags);
8755         BUILD_BUG_SQE_ELEM(28, __u32,  cancel_flags);
8756         BUILD_BUG_SQE_ELEM(28, __u32,  open_flags);
8757         BUILD_BUG_SQE_ELEM(28, __u32,  statx_flags);
8758         BUILD_BUG_SQE_ELEM(28, __u32,  fadvise_advice);
8759         BUILD_BUG_SQE_ELEM(28, __u32,  splice_flags);
8760         BUILD_BUG_SQE_ELEM(32, __u64,  user_data);
8761         BUILD_BUG_SQE_ELEM(40, __u16,  buf_index);
8762         BUILD_BUG_SQE_ELEM(42, __u16,  personality);
8763         BUILD_BUG_SQE_ELEM(44, __s32,  splice_fd_in);
8764
8765         BUILD_BUG_ON(ARRAY_SIZE(io_op_defs) != IORING_OP_LAST);
8766         BUILD_BUG_ON(__REQ_F_LAST_BIT >= 8 * sizeof(int));
8767         req_cachep = KMEM_CACHE(io_kiocb, SLAB_HWCACHE_ALIGN | SLAB_PANIC);
8768         return 0;
8769 };
8770 __initcall(io_uring_init);