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