fs/io_uring.c

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