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_alloc_async_ctx(req))
5283                 return -EAGAIN;
5284
5285         if (io_op_defs[req->opcode].file_table) {
5286                 io_req_init_async(req);
5287                 ret = io_grab_files(req);
5288                 if (unlikely(ret))
5289                         return ret;
5290         }
5291
5292         switch (req->opcode) {
5293         case IORING_OP_NOP:
5294                 break;
5295         case IORING_OP_READV:
5296         case IORING_OP_READ_FIXED:
5297         case IORING_OP_READ:
5298                 ret = io_read_prep(req, sqe, true);
5299                 break;
5300         case IORING_OP_WRITEV:
5301         case IORING_OP_WRITE_FIXED:
5302         case IORING_OP_WRITE:
5303                 ret = io_write_prep(req, sqe, true);
5304                 break;
5305         case IORING_OP_POLL_ADD:
5306                 ret = io_poll_add_prep(req, sqe);
5307                 break;
5308         case IORING_OP_POLL_REMOVE:
5309                 ret = io_poll_remove_prep(req, sqe);
5310                 break;
5311         case IORING_OP_FSYNC:
5312                 ret = io_prep_fsync(req, sqe);
5313                 break;
5314         case IORING_OP_SYNC_FILE_RANGE:
5315                 ret = io_prep_sfr(req, sqe);
5316                 break;
5317         case IORING_OP_SENDMSG:
5318         case IORING_OP_SEND:
5319                 ret = io_sendmsg_prep(req, sqe);
5320                 break;
5321         case IORING_OP_RECVMSG:
5322         case IORING_OP_RECV:
5323                 ret = io_recvmsg_prep(req, sqe);
5324                 break;
5325         case IORING_OP_CONNECT:
5326                 ret = io_connect_prep(req, sqe);
5327                 break;
5328         case IORING_OP_TIMEOUT:
5329                 ret = io_timeout_prep(req, sqe, false);
5330                 break;
5331         case IORING_OP_TIMEOUT_REMOVE:
5332                 ret = io_timeout_remove_prep(req, sqe);
5333                 break;
5334         case IORING_OP_ASYNC_CANCEL:
5335                 ret = io_async_cancel_prep(req, sqe);
5336                 break;
5337         case IORING_OP_LINK_TIMEOUT:
5338                 ret = io_timeout_prep(req, sqe, true);
5339                 break;
5340         case IORING_OP_ACCEPT:
5341                 ret = io_accept_prep(req, sqe);
5342                 break;
5343         case IORING_OP_FALLOCATE:
5344                 ret = io_fallocate_prep(req, sqe);
5345                 break;
5346         case IORING_OP_OPENAT:
5347                 ret = io_openat_prep(req, sqe);
5348                 break;
5349         case IORING_OP_CLOSE:
5350                 ret = io_close_prep(req, sqe);
5351                 break;
5352         case IORING_OP_FILES_UPDATE:
5353                 ret = io_files_update_prep(req, sqe);
5354                 break;
5355         case IORING_OP_STATX:
5356                 ret = io_statx_prep(req, sqe);
5357                 break;
5358         case IORING_OP_FADVISE:
5359                 ret = io_fadvise_prep(req, sqe);
5360                 break;
5361         case IORING_OP_MADVISE:
5362                 ret = io_madvise_prep(req, sqe);
5363                 break;
5364         case IORING_OP_OPENAT2:
5365                 ret = io_openat2_prep(req, sqe);
5366                 break;
5367         case IORING_OP_EPOLL_CTL:
5368                 ret = io_epoll_ctl_prep(req, sqe);
5369                 break;
5370         case IORING_OP_SPLICE:
5371                 ret = io_splice_prep(req, sqe);
5372                 break;
5373         case IORING_OP_PROVIDE_BUFFERS:
5374                 ret = io_provide_buffers_prep(req, sqe);
5375                 break;
5376         case IORING_OP_REMOVE_BUFFERS:
5377                 ret = io_remove_buffers_prep(req, sqe);
5378                 break;
5379         case IORING_OP_TEE:
5380                 ret = io_tee_prep(req, sqe);
5381                 break;
5382         default:
5383                 printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
5384                                 req->opcode);
5385                 ret = -EINVAL;
5386                 break;
5387         }
5388
5389         return ret;
5390 }
5391
5392 static u32 io_get_sequence(struct io_kiocb *req)
5393 {
5394         struct io_kiocb *pos;
5395         struct io_ring_ctx *ctx = req->ctx;
5396         u32 total_submitted, nr_reqs = 1;
5397
5398         if (req->flags & REQ_F_LINK_HEAD)
5399                 list_for_each_entry(pos, &req->link_list, link_list)
5400                         nr_reqs++;
5401
5402         total_submitted = ctx->cached_sq_head - ctx->cached_sq_dropped;
5403         return total_submitted - nr_reqs;
5404 }
5405
5406 static int io_req_defer(struct io_kiocb *req, const struct io_uring_sqe *sqe)
5407 {
5408         struct io_ring_ctx *ctx = req->ctx;
5409         struct io_defer_entry *de;
5410         int ret;
5411         u32 seq;
5412
5413         /* Still need defer if there is pending req in defer list. */
5414         if (likely(list_empty_careful(&ctx->defer_list) &&
5415                 !(req->flags & REQ_F_IO_DRAIN)))
5416                 return 0;
5417
5418         seq = io_get_sequence(req);
5419         /* Still a chance to pass the sequence check */
5420         if (!req_need_defer(req, seq) && list_empty_careful(&ctx->defer_list))
5421                 return 0;
5422
5423         if (!req->io) {
5424                 ret = io_req_defer_prep(req, sqe);
5425                 if (ret)
5426                         return ret;
5427         }
5428         io_prep_async_link(req);
5429         de = kmalloc(sizeof(*de), GFP_KERNEL);
5430         if (!de)
5431                 return -ENOMEM;
5432
5433         spin_lock_irq(&ctx->completion_lock);
5434         if (!req_need_defer(req, seq) && list_empty(&ctx->defer_list)) {
5435                 spin_unlock_irq(&ctx->completion_lock);
5436                 kfree(de);
5437                 return 0;
5438         }
5439
5440         trace_io_uring_defer(ctx, req, req->user_data);
5441         de->req = req;
5442         de->seq = seq;
5443         list_add_tail(&de->list, &ctx->defer_list);
5444         spin_unlock_irq(&ctx->completion_lock);
5445         return -EIOCBQUEUED;
5446 }
5447
5448 static void __io_clean_op(struct io_kiocb *req)
5449 {
5450         struct io_async_ctx *io = req->io;
5451
5452         switch (req->opcode) {
5453         case IORING_OP_READV:
5454         case IORING_OP_READ_FIXED:
5455         case IORING_OP_READ:
5456                 if (req->flags & REQ_F_BUFFER_SELECTED)
5457                         kfree((void *)(unsigned long)req->rw.addr);
5458                 /* fallthrough */
5459         case IORING_OP_WRITEV:
5460         case IORING_OP_WRITE_FIXED:
5461         case IORING_OP_WRITE:
5462                 if (io->rw.iov != io->rw.fast_iov)
5463                         kfree(io->rw.iov);
5464                 break;
5465         case IORING_OP_RECVMSG:
5466                 if (req->flags & REQ_F_BUFFER_SELECTED)
5467                         kfree(req->sr_msg.kbuf);
5468                 /* fallthrough */
5469         case IORING_OP_SENDMSG:
5470                 if (io->msg.iov != io->msg.fast_iov)
5471                         kfree(io->msg.iov);
5472                 break;
5473         case IORING_OP_RECV:
5474                 if (req->flags & REQ_F_BUFFER_SELECTED)
5475                         kfree(req->sr_msg.kbuf);
5476                 break;
5477         case IORING_OP_SPLICE:
5478         case IORING_OP_TEE:
5479                 io_put_file(req, req->splice.file_in,
5480                             (req->splice.flags & SPLICE_F_FD_IN_FIXED));
5481                 break;
5482         }
5483
5484         req->flags &= ~REQ_F_NEED_CLEANUP;
5485 }
5486
5487 static int io_issue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
5488                         bool force_nonblock, struct io_comp_state *cs)
5489 {
5490         struct io_ring_ctx *ctx = req->ctx;
5491         int ret;
5492
5493         switch (req->opcode) {
5494         case IORING_OP_NOP:
5495                 ret = io_nop(req, cs);
5496                 break;
5497         case IORING_OP_READV:
5498         case IORING_OP_READ_FIXED:
5499         case IORING_OP_READ:
5500                 if (sqe) {
5501                         ret = io_read_prep(req, sqe, force_nonblock);
5502                         if (ret < 0)
5503                                 break;
5504                 }
5505                 ret = io_read(req, force_nonblock, cs);
5506                 break;
5507         case IORING_OP_WRITEV:
5508         case IORING_OP_WRITE_FIXED:
5509         case IORING_OP_WRITE:
5510                 if (sqe) {
5511                         ret = io_write_prep(req, sqe, force_nonblock);
5512                         if (ret < 0)
5513                                 break;
5514                 }
5515                 ret = io_write(req, force_nonblock, cs);
5516                 break;
5517         case IORING_OP_FSYNC:
5518                 if (sqe) {
5519                         ret = io_prep_fsync(req, sqe);
5520                         if (ret < 0)
5521                                 break;
5522                 }
5523                 ret = io_fsync(req, force_nonblock);
5524                 break;
5525         case IORING_OP_POLL_ADD:
5526                 if (sqe) {
5527                         ret = io_poll_add_prep(req, sqe);
5528                         if (ret)
5529                                 break;
5530                 }
5531                 ret = io_poll_add(req);
5532                 break;
5533         case IORING_OP_POLL_REMOVE:
5534                 if (sqe) {
5535                         ret = io_poll_remove_prep(req, sqe);
5536                         if (ret < 0)
5537                                 break;
5538                 }
5539                 ret = io_poll_remove(req);
5540                 break;
5541         case IORING_OP_SYNC_FILE_RANGE:
5542                 if (sqe) {
5543                         ret = io_prep_sfr(req, sqe);
5544                         if (ret < 0)
5545                                 break;
5546                 }
5547                 ret = io_sync_file_range(req, force_nonblock);
5548                 break;
5549         case IORING_OP_SENDMSG:
5550         case IORING_OP_SEND:
5551                 if (sqe) {
5552                         ret = io_sendmsg_prep(req, sqe);
5553                         if (ret < 0)
5554                                 break;
5555                 }
5556                 if (req->opcode == IORING_OP_SENDMSG)
5557                         ret = io_sendmsg(req, force_nonblock, cs);
5558                 else
5559                         ret = io_send(req, force_nonblock, cs);
5560                 break;
5561         case IORING_OP_RECVMSG:
5562         case IORING_OP_RECV:
5563                 if (sqe) {
5564                         ret = io_recvmsg_prep(req, sqe);
5565                         if (ret)
5566                                 break;
5567                 }
5568                 if (req->opcode == IORING_OP_RECVMSG)
5569                         ret = io_recvmsg(req, force_nonblock, cs);
5570                 else
5571                         ret = io_recv(req, force_nonblock, cs);
5572                 break;
5573         case IORING_OP_TIMEOUT:
5574                 if (sqe) {
5575                         ret = io_timeout_prep(req, sqe, false);
5576                         if (ret)
5577                                 break;
5578                 }
5579                 ret = io_timeout(req);
5580                 break;
5581         case IORING_OP_TIMEOUT_REMOVE:
5582                 if (sqe) {
5583                         ret = io_timeout_remove_prep(req, sqe);
5584                         if (ret)
5585                                 break;
5586                 }
5587                 ret = io_timeout_remove(req);
5588                 break;
5589         case IORING_OP_ACCEPT:
5590                 if (sqe) {
5591                         ret = io_accept_prep(req, sqe);
5592                         if (ret)
5593                                 break;
5594                 }
5595                 ret = io_accept(req, force_nonblock, cs);
5596                 break;
5597         case IORING_OP_CONNECT:
5598                 if (sqe) {
5599                         ret = io_connect_prep(req, sqe);
5600                         if (ret)
5601                                 break;
5602                 }
5603                 ret = io_connect(req, force_nonblock, cs);
5604                 break;
5605         case IORING_OP_ASYNC_CANCEL:
5606                 if (sqe) {
5607                         ret = io_async_cancel_prep(req, sqe);
5608                         if (ret)
5609                                 break;
5610                 }
5611                 ret = io_async_cancel(req);
5612                 break;
5613         case IORING_OP_FALLOCATE:
5614                 if (sqe) {
5615                         ret = io_fallocate_prep(req, sqe);
5616                         if (ret)
5617                                 break;
5618                 }
5619                 ret = io_fallocate(req, force_nonblock);
5620                 break;
5621         case IORING_OP_OPENAT:
5622                 if (sqe) {
5623                         ret = io_openat_prep(req, sqe);
5624                         if (ret)
5625                                 break;
5626                 }
5627                 ret = io_openat(req, force_nonblock);
5628                 break;
5629         case IORING_OP_CLOSE:
5630                 if (sqe) {
5631                         ret = io_close_prep(req, sqe);
5632                         if (ret)
5633                                 break;
5634                 }
5635                 ret = io_close(req, force_nonblock, cs);
5636                 break;
5637         case IORING_OP_FILES_UPDATE:
5638                 if (sqe) {
5639                         ret = io_files_update_prep(req, sqe);
5640                         if (ret)
5641                                 break;
5642                 }
5643                 ret = io_files_update(req, force_nonblock, cs);
5644                 break;
5645         case IORING_OP_STATX:
5646                 if (sqe) {
5647                         ret = io_statx_prep(req, sqe);
5648                         if (ret)
5649                                 break;
5650                 }
5651                 ret = io_statx(req, force_nonblock);
5652                 break;
5653         case IORING_OP_FADVISE:
5654                 if (sqe) {
5655                         ret = io_fadvise_prep(req, sqe);
5656                         if (ret)
5657                                 break;
5658                 }
5659                 ret = io_fadvise(req, force_nonblock);
5660                 break;
5661         case IORING_OP_MADVISE:
5662                 if (sqe) {
5663                         ret = io_madvise_prep(req, sqe);
5664                         if (ret)
5665                                 break;
5666                 }
5667                 ret = io_madvise(req, force_nonblock);
5668                 break;
5669         case IORING_OP_OPENAT2:
5670                 if (sqe) {
5671                         ret = io_openat2_prep(req, sqe);
5672                         if (ret)
5673                                 break;
5674                 }
5675                 ret = io_openat2(req, force_nonblock);
5676                 break;
5677         case IORING_OP_EPOLL_CTL:
5678                 if (sqe) {
5679                         ret = io_epoll_ctl_prep(req, sqe);
5680                         if (ret)
5681                                 break;
5682                 }
5683                 ret = io_epoll_ctl(req, force_nonblock, cs);
5684                 break;
5685         case IORING_OP_SPLICE:
5686                 if (sqe) {
5687                         ret = io_splice_prep(req, sqe);
5688                         if (ret < 0)
5689                                 break;
5690                 }
5691                 ret = io_splice(req, force_nonblock);
5692                 break;
5693         case IORING_OP_PROVIDE_BUFFERS:
5694                 if (sqe) {
5695                         ret = io_provide_buffers_prep(req, sqe);
5696                         if (ret)
5697                                 break;
5698                 }
5699                 ret = io_provide_buffers(req, force_nonblock, cs);
5700                 break;
5701         case IORING_OP_REMOVE_BUFFERS:
5702                 if (sqe) {
5703                         ret = io_remove_buffers_prep(req, sqe);
5704                         if (ret)
5705                                 break;
5706                 }
5707                 ret = io_remove_buffers(req, force_nonblock, cs);
5708                 break;
5709         case IORING_OP_TEE:
5710                 if (sqe) {
5711                         ret = io_tee_prep(req, sqe);
5712                         if (ret < 0)
5713                                 break;
5714                 }
5715                 ret = io_tee(req, force_nonblock);
5716                 break;
5717         default:
5718                 ret = -EINVAL;
5719                 break;
5720         }
5721
5722         if (ret)
5723                 return ret;
5724
5725         /* If the op doesn't have a file, we're not polling for it */
5726         if ((ctx->flags & IORING_SETUP_IOPOLL) && req->file) {
5727                 const bool in_async = io_wq_current_is_worker();
5728
5729                 /* workqueue context doesn't hold uring_lock, grab it now */
5730                 if (in_async)
5731                         mutex_lock(&ctx->uring_lock);
5732
5733                 io_iopoll_req_issued(req);
5734
5735                 if (in_async)
5736                         mutex_unlock(&ctx->uring_lock);
5737         }
5738
5739         return 0;
5740 }
5741
5742 static struct io_wq_work *io_wq_submit_work(struct io_wq_work *work)
5743 {
5744         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
5745         struct io_kiocb *timeout;
5746         int ret = 0;
5747
5748         timeout = io_prep_linked_timeout(req);
5749         if (timeout)
5750                 io_queue_linked_timeout(timeout);
5751
5752         /* if NO_CANCEL is set, we must still run the work */
5753         if ((work->flags & (IO_WQ_WORK_CANCEL|IO_WQ_WORK_NO_CANCEL)) ==
5754                                 IO_WQ_WORK_CANCEL) {
5755                 ret = -ECANCELED;
5756         }
5757
5758         if (!ret) {
5759                 do {
5760                         ret = io_issue_sqe(req, NULL, false, NULL);
5761                         /*
5762                          * We can get EAGAIN for polled IO even though we're
5763                          * forcing a sync submission from here, since we can't
5764                          * wait for request slots on the block side.
5765                          */
5766                         if (ret != -EAGAIN)
5767                                 break;
5768                         cond_resched();
5769                 } while (1);
5770         }
5771
5772         if (ret) {
5773                 req_set_fail_links(req);
5774                 io_req_complete(req, ret);
5775         }
5776
5777         return io_steal_work(req);
5778 }
5779
5780 static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
5781                                               int index)
5782 {
5783         struct fixed_file_table *table;
5784
5785         table = &ctx->file_data->table[index >> IORING_FILE_TABLE_SHIFT];
5786         return table->files[index & IORING_FILE_TABLE_MASK];
5787 }
5788
5789 static int io_file_get(struct io_submit_state *state, struct io_kiocb *req,
5790                         int fd, struct file **out_file, bool fixed)
5791 {
5792         struct io_ring_ctx *ctx = req->ctx;
5793         struct file *file;
5794
5795         if (fixed) {
5796                 if (unlikely(!ctx->file_data ||
5797                     (unsigned) fd >= ctx->nr_user_files))
5798                         return -EBADF;
5799                 fd = array_index_nospec(fd, ctx->nr_user_files);
5800                 file = io_file_from_index(ctx, fd);
5801                 if (file) {
5802                         req->fixed_file_refs = ctx->file_data->cur_refs;
5803                         percpu_ref_get(req->fixed_file_refs);
5804                 }
5805         } else {
5806                 trace_io_uring_file_get(ctx, fd);
5807                 file = __io_file_get(state, fd);
5808         }
5809
5810         if (file || io_op_defs[req->opcode].needs_file_no_error) {
5811                 *out_file = file;
5812                 return 0;
5813         }
5814         return -EBADF;
5815 }
5816
5817 static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
5818                            int fd)
5819 {
5820         bool fixed;
5821
5822         fixed = (req->flags & REQ_F_FIXED_FILE) != 0;
5823         if (unlikely(!fixed && io_async_submit(req->ctx)))
5824                 return -EBADF;
5825
5826         return io_file_get(state, req, fd, &req->file, fixed);
5827 }
5828
5829 static int io_grab_files(struct io_kiocb *req)
5830 {
5831         int ret = -EBADF;
5832         struct io_ring_ctx *ctx = req->ctx;
5833
5834         if (req->work.files || (req->flags & REQ_F_NO_FILE_TABLE))
5835                 return 0;
5836         if (!ctx->ring_file)
5837                 return -EBADF;
5838
5839         rcu_read_lock();
5840         spin_lock_irq(&ctx->inflight_lock);
5841         /*
5842          * We use the f_ops->flush() handler to ensure that we can flush
5843          * out work accessing these files if the fd is closed. Check if
5844          * the fd has changed since we started down this path, and disallow
5845          * this operation if it has.
5846          */
5847         if (fcheck(ctx->ring_fd) == ctx->ring_file) {
5848                 list_add(&req->inflight_entry, &ctx->inflight_list);
5849                 req->flags |= REQ_F_INFLIGHT;
5850                 req->work.files = current->files;
5851                 ret = 0;
5852         }
5853         spin_unlock_irq(&ctx->inflight_lock);
5854         rcu_read_unlock();
5855
5856         return ret;
5857 }
5858
5859 static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer)
5860 {
5861         struct io_timeout_data *data = container_of(timer,
5862                                                 struct io_timeout_data, timer);
5863         struct io_kiocb *req = data->req;
5864         struct io_ring_ctx *ctx = req->ctx;
5865         struct io_kiocb *prev = NULL;
5866         unsigned long flags;
5867
5868         spin_lock_irqsave(&ctx->completion_lock, flags);
5869
5870         /*
5871          * We don't expect the list to be empty, that will only happen if we
5872          * race with the completion of the linked work.
5873          */
5874         if (!list_empty(&req->link_list)) {
5875                 prev = list_entry(req->link_list.prev, struct io_kiocb,
5876                                   link_list);
5877                 if (refcount_inc_not_zero(&prev->refs)) {
5878                         list_del_init(&req->link_list);
5879                         prev->flags &= ~REQ_F_LINK_TIMEOUT;
5880                 } else
5881                         prev = NULL;
5882         }
5883
5884         spin_unlock_irqrestore(&ctx->completion_lock, flags);
5885
5886         if (prev) {
5887                 req_set_fail_links(prev);
5888                 io_async_find_and_cancel(ctx, req, prev->user_data, -ETIME);
5889                 io_put_req(prev);
5890         } else {
5891                 io_req_complete(req, -ETIME);
5892         }
5893         return HRTIMER_NORESTART;
5894 }
5895
5896 static void io_queue_linked_timeout(struct io_kiocb *req)
5897 {
5898         struct io_ring_ctx *ctx = req->ctx;
5899
5900         /*
5901          * If the list is now empty, then our linked request finished before
5902          * we got a chance to setup the timer
5903          */
5904         spin_lock_irq(&ctx->completion_lock);
5905         if (!list_empty(&req->link_list)) {
5906                 struct io_timeout_data *data = &req->io->timeout;
5907
5908                 data->timer.function = io_link_timeout_fn;
5909                 hrtimer_start(&data->timer, timespec64_to_ktime(data->ts),
5910                                 data->mode);
5911         }
5912         spin_unlock_irq(&ctx->completion_lock);
5913
5914         /* drop submission reference */
5915         io_put_req(req);
5916 }
5917
5918 static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req)
5919 {
5920         struct io_kiocb *nxt;
5921
5922         if (!(req->flags & REQ_F_LINK_HEAD))
5923                 return NULL;
5924         if (req->flags & REQ_F_LINK_TIMEOUT)
5925                 return NULL;
5926
5927         nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb,
5928                                         link_list);
5929         if (!nxt || nxt->opcode != IORING_OP_LINK_TIMEOUT)
5930                 return NULL;
5931
5932         req->flags |= REQ_F_LINK_TIMEOUT;
5933         return nxt;
5934 }
5935
5936 static void __io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
5937                            struct io_comp_state *cs)
5938 {
5939         struct io_kiocb *linked_timeout;
5940         struct io_kiocb *nxt;
5941         const struct cred *old_creds = NULL;
5942         int ret;
5943
5944 again:
5945         linked_timeout = io_prep_linked_timeout(req);
5946
5947         if ((req->flags & REQ_F_WORK_INITIALIZED) && req->work.creds &&
5948             req->work.creds != current_cred()) {
5949                 if (old_creds)
5950                         revert_creds(old_creds);
5951                 if (old_creds == req->work.creds)
5952                         old_creds = NULL; /* restored original creds */
5953                 else
5954                         old_creds = override_creds(req->work.creds);
5955         }
5956
5957         ret = io_issue_sqe(req, sqe, true, cs);
5958
5959         /*
5960          * We async punt it if the file wasn't marked NOWAIT, or if the file
5961          * doesn't support non-blocking read/write attempts
5962          */
5963         if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
5964                 if (io_arm_poll_handler(req)) {
5965                         if (linked_timeout)
5966                                 io_queue_linked_timeout(linked_timeout);
5967                         goto exit;
5968                 }
5969 punt:
5970                 io_req_init_async(req);
5971
5972                 if (io_op_defs[req->opcode].file_table) {
5973                         ret = io_grab_files(req);
5974                         if (ret)
5975                                 goto err;
5976                 }
5977
5978                 /*
5979                  * Queued up for async execution, worker will release
5980                  * submit reference when the iocb is actually submitted.
5981                  */
5982                 io_queue_async_work(req);
5983                 goto exit;
5984         }
5985
5986         if (unlikely(ret)) {
5987 err:
5988                 /* un-prep timeout, so it'll be killed as any other linked */
5989                 req->flags &= ~REQ_F_LINK_TIMEOUT;
5990                 req_set_fail_links(req);
5991                 io_put_req(req);
5992                 io_req_complete(req, ret);
5993                 goto exit;
5994         }
5995
5996         /* drop submission reference */
5997         nxt = io_put_req_find_next(req);
5998         if (linked_timeout)
5999                 io_queue_linked_timeout(linked_timeout);
6000
6001         if (nxt) {
6002                 req = nxt;
6003
6004                 if (req->flags & REQ_F_FORCE_ASYNC)
6005                         goto punt;
6006                 goto again;
6007         }
6008 exit:
6009         if (old_creds)
6010                 revert_creds(old_creds);
6011 }
6012
6013 static void io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
6014                          struct io_comp_state *cs)
6015 {
6016         int ret;
6017
6018         ret = io_req_defer(req, sqe);
6019         if (ret) {
6020                 if (ret != -EIOCBQUEUED) {
6021 fail_req:
6022                         req_set_fail_links(req);
6023                         io_put_req(req);
6024                         io_req_complete(req, ret);
6025                 }
6026         } else if (req->flags & REQ_F_FORCE_ASYNC) {
6027                 if (!req->io) {
6028                         ret = io_req_defer_prep(req, sqe);
6029                         if (unlikely(ret))
6030                                 goto fail_req;
6031                 }
6032
6033                 /*
6034                  * Never try inline submit of IOSQE_ASYNC is set, go straight
6035                  * to async execution.
6036                  */
6037                 io_req_init_async(req);
6038                 req->work.flags |= IO_WQ_WORK_CONCURRENT;
6039                 io_queue_async_work(req);
6040         } else {
6041                 __io_queue_sqe(req, sqe, cs);
6042         }
6043 }
6044
6045 static inline void io_queue_link_head(struct io_kiocb *req,
6046                                       struct io_comp_state *cs)
6047 {
6048         if (unlikely(req->flags & REQ_F_FAIL_LINK)) {
6049                 io_put_req(req);
6050                 io_req_complete(req, -ECANCELED);
6051         } else
6052                 io_queue_sqe(req, NULL, cs);
6053 }
6054
6055 static int io_submit_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
6056                          struct io_kiocb **link, struct io_comp_state *cs)
6057 {
6058         struct io_ring_ctx *ctx = req->ctx;
6059         int ret;
6060
6061         /*
6062          * If we already have a head request, queue this one for async
6063          * submittal once the head completes. If we don't have a head but
6064          * IOSQE_IO_LINK is set in the sqe, start a new head. This one will be
6065          * submitted sync once the chain is complete. If none of those
6066          * conditions are true (normal request), then just queue it.
6067          */
6068         if (*link) {
6069                 struct io_kiocb *head = *link;
6070
6071                 /*
6072                  * Taking sequential execution of a link, draining both sides
6073                  * of the link also fullfils IOSQE_IO_DRAIN semantics for all
6074                  * requests in the link. So, it drains the head and the
6075                  * next after the link request. The last one is done via
6076                  * drain_next flag to persist the effect across calls.
6077                  */
6078                 if (req->flags & REQ_F_IO_DRAIN) {
6079                         head->flags |= REQ_F_IO_DRAIN;
6080                         ctx->drain_next = 1;
6081                 }
6082                 ret = io_req_defer_prep(req, sqe);
6083                 if (unlikely(ret)) {
6084                         /* fail even hard links since we don't submit */
6085                         head->flags |= REQ_F_FAIL_LINK;
6086                         return ret;
6087                 }
6088                 trace_io_uring_link(ctx, req, head);
6089                 io_get_req_task(req);
6090                 list_add_tail(&req->link_list, &head->link_list);
6091
6092                 /* last request of a link, enqueue the link */
6093                 if (!(req->flags & (REQ_F_LINK | REQ_F_HARDLINK))) {
6094                         io_queue_link_head(head, cs);
6095                         *link = NULL;
6096                 }
6097         } else {
6098                 if (unlikely(ctx->drain_next)) {
6099                         req->flags |= REQ_F_IO_DRAIN;
6100                         ctx->drain_next = 0;
6101                 }
6102                 if (req->flags & (REQ_F_LINK | REQ_F_HARDLINK)) {
6103                         req->flags |= REQ_F_LINK_HEAD;
6104                         INIT_LIST_HEAD(&req->link_list);
6105
6106                         ret = io_req_defer_prep(req, sqe);
6107                         if (unlikely(ret))
6108                                 req->flags |= REQ_F_FAIL_LINK;
6109                         *link = req;
6110                 } else {
6111                         io_queue_sqe(req, sqe, cs);
6112                 }
6113         }
6114
6115         return 0;
6116 }
6117
6118 /*
6119  * Batched submission is done, ensure local IO is flushed out.
6120  */
6121 static void io_submit_state_end(struct io_submit_state *state)
6122 {
6123         if (!list_empty(&state->comp.list))
6124                 io_submit_flush_completions(&state->comp);
6125         blk_finish_plug(&state->plug);
6126         io_state_file_put(state);
6127         if (state->free_reqs)
6128                 kmem_cache_free_bulk(req_cachep, state->free_reqs, state->reqs);
6129 }
6130
6131 /*
6132  * Start submission side cache.
6133  */
6134 static void io_submit_state_start(struct io_submit_state *state,
6135                                   struct io_ring_ctx *ctx, unsigned int max_ios)
6136 {
6137         blk_start_plug(&state->plug);
6138 #ifdef CONFIG_BLOCK
6139         state->plug.nowait = true;
6140 #endif
6141         state->comp.nr = 0;
6142         INIT_LIST_HEAD(&state->comp.list);
6143         state->comp.ctx = ctx;
6144         state->free_reqs = 0;
6145         state->file = NULL;
6146         state->ios_left = max_ios;
6147 }
6148
6149 static void io_commit_sqring(struct io_ring_ctx *ctx)
6150 {
6151         struct io_rings *rings = ctx->rings;
6152
6153         /*
6154          * Ensure any loads from the SQEs are done at this point,
6155          * since once we write the new head, the application could
6156          * write new data to them.
6157          */
6158         smp_store_release(&rings->sq.head, ctx->cached_sq_head);
6159 }
6160
6161 /*
6162  * Fetch an sqe, if one is available. Note that sqe_ptr will point to memory
6163  * that is mapped by userspace. This means that care needs to be taken to
6164  * ensure that reads are stable, as we cannot rely on userspace always
6165  * being a good citizen. If members of the sqe are validated and then later
6166  * used, it's important that those reads are done through READ_ONCE() to
6167  * prevent a re-load down the line.
6168  */
6169 static const struct io_uring_sqe *io_get_sqe(struct io_ring_ctx *ctx)
6170 {
6171         u32 *sq_array = ctx->sq_array;
6172         unsigned head;
6173
6174         /*
6175          * The cached sq head (or cq tail) serves two purposes:
6176          *
6177          * 1) allows us to batch the cost of updating the user visible
6178          *    head updates.
6179          * 2) allows the kernel side to track the head on its own, even
6180          *    though the application is the one updating it.
6181          */
6182         head = READ_ONCE(sq_array[ctx->cached_sq_head & ctx->sq_mask]);
6183         if (likely(head < ctx->sq_entries))
6184                 return &ctx->sq_sqes[head];
6185
6186         /* drop invalid entries */
6187         ctx->cached_sq_dropped++;
6188         WRITE_ONCE(ctx->rings->sq_dropped, ctx->cached_sq_dropped);
6189         return NULL;
6190 }
6191
6192 static inline void io_consume_sqe(struct io_ring_ctx *ctx)
6193 {
6194         ctx->cached_sq_head++;
6195 }
6196
6197 #define SQE_VALID_FLAGS (IOSQE_FIXED_FILE|IOSQE_IO_DRAIN|IOSQE_IO_LINK| \
6198                                 IOSQE_IO_HARDLINK | IOSQE_ASYNC | \
6199                                 IOSQE_BUFFER_SELECT)
6200
6201 static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req,
6202                        const struct io_uring_sqe *sqe,
6203                        struct io_submit_state *state)
6204 {
6205         unsigned int sqe_flags;
6206         int id;
6207
6208         req->opcode = READ_ONCE(sqe->opcode);
6209         req->user_data = READ_ONCE(sqe->user_data);
6210         req->io = NULL;
6211         req->file = NULL;
6212         req->ctx = ctx;
6213         req->flags = 0;
6214         /* one is dropped after submission, the other at completion */
6215         refcount_set(&req->refs, 2);
6216         req->task = current;
6217         req->result = 0;
6218
6219         if (unlikely(req->opcode >= IORING_OP_LAST))
6220                 return -EINVAL;
6221
6222         if (unlikely(io_sq_thread_acquire_mm(ctx, req)))
6223                 return -EFAULT;
6224
6225         sqe_flags = READ_ONCE(sqe->flags);
6226         /* enforce forwards compatibility on users */
6227         if (unlikely(sqe_flags & ~SQE_VALID_FLAGS))
6228                 return -EINVAL;
6229
6230         if ((sqe_flags & IOSQE_BUFFER_SELECT) &&
6231             !io_op_defs[req->opcode].buffer_select)
6232                 return -EOPNOTSUPP;
6233
6234         id = READ_ONCE(sqe->personality);
6235         if (id) {
6236                 io_req_init_async(req);
6237                 req->work.creds = idr_find(&ctx->personality_idr, id);
6238                 if (unlikely(!req->work.creds))
6239                         return -EINVAL;
6240                 get_cred(req->work.creds);
6241         }
6242
6243         /* same numerical values with corresponding REQ_F_*, safe to copy */
6244         req->flags |= sqe_flags;
6245
6246         if (!io_op_defs[req->opcode].needs_file)
6247                 return 0;
6248
6249         return io_req_set_file(state, req, READ_ONCE(sqe->fd));
6250 }
6251
6252 static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr,
6253                           struct file *ring_file, int ring_fd)
6254 {
6255         struct io_submit_state state;
6256         struct io_kiocb *link = NULL;
6257         int i, submitted = 0;
6258
6259         /* if we have a backlog and couldn't flush it all, return BUSY */
6260         if (test_bit(0, &ctx->sq_check_overflow)) {
6261                 if (!list_empty(&ctx->cq_overflow_list) &&
6262                     !io_cqring_overflow_flush(ctx, false))
6263                         return -EBUSY;
6264         }
6265
6266         /* make sure SQ entry isn't read before tail */
6267         nr = min3(nr, ctx->sq_entries, io_sqring_entries(ctx));
6268
6269         if (!percpu_ref_tryget_many(&ctx->refs, nr))
6270                 return -EAGAIN;
6271
6272         io_submit_state_start(&state, ctx, nr);
6273
6274         ctx->ring_fd = ring_fd;
6275         ctx->ring_file = ring_file;
6276
6277         for (i = 0; i < nr; i++) {
6278                 const struct io_uring_sqe *sqe;
6279                 struct io_kiocb *req;
6280                 int err;
6281
6282                 sqe = io_get_sqe(ctx);
6283                 if (unlikely(!sqe)) {
6284                         io_consume_sqe(ctx);
6285                         break;
6286                 }
6287                 req = io_alloc_req(ctx, &state);
6288                 if (unlikely(!req)) {
6289                         if (!submitted)
6290                                 submitted = -EAGAIN;
6291                         break;
6292                 }
6293
6294                 err = io_init_req(ctx, req, sqe, &state);
6295                 io_consume_sqe(ctx);
6296                 /* will complete beyond this point, count as submitted */
6297                 submitted++;
6298
6299                 if (unlikely(err)) {
6300 fail_req:
6301                         io_put_req(req);
6302                         io_req_complete(req, err);
6303                         break;
6304                 }
6305
6306                 trace_io_uring_submit_sqe(ctx, req->opcode, req->user_data,
6307                                                 true, io_async_submit(ctx));
6308                 err = io_submit_sqe(req, sqe, &link, &state.comp);
6309                 if (err)
6310                         goto fail_req;
6311         }
6312
6313         if (unlikely(submitted != nr)) {
6314                 int ref_used = (submitted == -EAGAIN) ? 0 : submitted;
6315
6316                 percpu_ref_put_many(&ctx->refs, nr - ref_used);
6317         }
6318         if (link)
6319                 io_queue_link_head(link, &state.comp);
6320         io_submit_state_end(&state);
6321
6322          /* Commit SQ ring head once we've consumed and submitted all SQEs */
6323         io_commit_sqring(ctx);
6324
6325         return submitted;
6326 }
6327
6328 static int io_sq_thread(void *data)
6329 {
6330         struct io_ring_ctx *ctx = data;
6331         const struct cred *old_cred;
6332         DEFINE_WAIT(wait);
6333         unsigned long timeout;
6334         int ret = 0;
6335
6336         complete(&ctx->sq_thread_comp);
6337
6338         old_cred = override_creds(ctx->creds);
6339
6340         timeout = jiffies + ctx->sq_thread_idle;
6341         while (!kthread_should_park()) {
6342                 unsigned int to_submit;
6343
6344                 if (!list_empty(&ctx->iopoll_list)) {
6345                         unsigned nr_events = 0;
6346
6347                         mutex_lock(&ctx->uring_lock);
6348                         if (!list_empty(&ctx->iopoll_list) && !need_resched())
6349                                 io_do_iopoll(ctx, &nr_events, 0);
6350                         else
6351                                 timeout = jiffies + ctx->sq_thread_idle;
6352                         mutex_unlock(&ctx->uring_lock);
6353                 }
6354
6355                 to_submit = io_sqring_entries(ctx);
6356
6357                 /*
6358                  * If submit got -EBUSY, flag us as needing the application
6359                  * to enter the kernel to reap and flush events.
6360                  */
6361                 if (!to_submit || ret == -EBUSY || need_resched()) {
6362                         /*
6363                          * Drop cur_mm before scheduling, we can't hold it for
6364                          * long periods (or over schedule()). Do this before
6365                          * adding ourselves to the waitqueue, as the unuse/drop
6366                          * may sleep.
6367                          */
6368                         io_sq_thread_drop_mm();
6369
6370                         /*
6371                          * We're polling. If we're within the defined idle
6372                          * period, then let us spin without work before going
6373                          * to sleep. The exception is if we got EBUSY doing
6374                          * more IO, we should wait for the application to
6375                          * reap events and wake us up.
6376                          */
6377                         if (!list_empty(&ctx->iopoll_list) || need_resched() ||
6378                             (!time_after(jiffies, timeout) && ret != -EBUSY &&
6379                             !percpu_ref_is_dying(&ctx->refs))) {
6380                                 io_run_task_work();
6381                                 cond_resched();
6382                                 continue;
6383                         }
6384
6385                         prepare_to_wait(&ctx->sqo_wait, &wait,
6386                                                 TASK_INTERRUPTIBLE);
6387
6388                         /*
6389                          * While doing polled IO, before going to sleep, we need
6390                          * to check if there are new reqs added to iopoll_list,
6391                          * it is because reqs may have been punted to io worker
6392                          * and will be added to iopoll_list later, hence check
6393                          * the iopoll_list again.
6394                          */
6395                         if ((ctx->flags & IORING_SETUP_IOPOLL) &&
6396                             !list_empty_careful(&ctx->iopoll_list)) {
6397                                 finish_wait(&ctx->sqo_wait, &wait);
6398                                 continue;
6399                         }
6400
6401                         /* Tell userspace we may need a wakeup call */
6402                         spin_lock_irq(&ctx->completion_lock);
6403                         ctx->rings->sq_flags |= IORING_SQ_NEED_WAKEUP;
6404                         spin_unlock_irq(&ctx->completion_lock);
6405
6406                         to_submit = io_sqring_entries(ctx);
6407                         if (!to_submit || ret == -EBUSY) {
6408                                 if (kthread_should_park()) {
6409                                         finish_wait(&ctx->sqo_wait, &wait);
6410                                         break;
6411                                 }
6412                                 if (io_run_task_work()) {
6413                                         finish_wait(&ctx->sqo_wait, &wait);
6414                                         continue;
6415                                 }
6416                                 if (signal_pending(current))
6417                                         flush_signals(current);
6418                                 schedule();
6419                                 finish_wait(&ctx->sqo_wait, &wait);
6420
6421                                 spin_lock_irq(&ctx->completion_lock);
6422                                 ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
6423                                 spin_unlock_irq(&ctx->completion_lock);
6424                                 ret = 0;
6425                                 continue;
6426                         }
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                 }
6433
6434                 mutex_lock(&ctx->uring_lock);
6435                 if (likely(!percpu_ref_is_dying(&ctx->refs)))
6436                         ret = io_submit_sqes(ctx, to_submit, NULL, -1);
6437                 mutex_unlock(&ctx->uring_lock);
6438                 timeout = jiffies + ctx->sq_thread_idle;
6439         }
6440
6441         io_run_task_work();
6442
6443         io_sq_thread_drop_mm();
6444         revert_creds(old_cred);
6445
6446         kthread_parkme();
6447
6448         return 0;
6449 }
6450
6451 struct io_wait_queue {
6452         struct wait_queue_entry wq;
6453         struct io_ring_ctx *ctx;
6454         unsigned to_wait;
6455         unsigned nr_timeouts;
6456 };
6457
6458 static inline bool io_should_wake(struct io_wait_queue *iowq, bool noflush)
6459 {
6460         struct io_ring_ctx *ctx = iowq->ctx;
6461
6462         /*
6463          * Wake up if we have enough events, or if a timeout occurred since we
6464          * started waiting. For timeouts, we always want to return to userspace,
6465          * regardless of event count.
6466          */
6467         return io_cqring_events(ctx, noflush) >= iowq->to_wait ||
6468                         atomic_read(&ctx->cq_timeouts) != iowq->nr_timeouts;
6469 }
6470
6471 static int io_wake_function(struct wait_queue_entry *curr, unsigned int mode,
6472                             int wake_flags, void *key)
6473 {
6474         struct io_wait_queue *iowq = container_of(curr, struct io_wait_queue,
6475                                                         wq);
6476
6477         /* use noflush == true, as we can't safely rely on locking context */
6478         if (!io_should_wake(iowq, true))
6479                 return -1;
6480
6481         return autoremove_wake_function(curr, mode, wake_flags, key);
6482 }
6483
6484 /*
6485  * Wait until events become available, if we don't already have some. The
6486  * application must reap them itself, as they reside on the shared cq ring.
6487  */
6488 static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
6489                           const sigset_t __user *sig, size_t sigsz)
6490 {
6491         struct io_wait_queue iowq = {
6492                 .wq = {
6493                         .private        = current,
6494                         .func           = io_wake_function,
6495                         .entry          = LIST_HEAD_INIT(iowq.wq.entry),
6496                 },
6497                 .ctx            = ctx,
6498                 .to_wait        = min_events,
6499         };
6500         struct io_rings *rings = ctx->rings;
6501         int ret = 0;
6502
6503         do {
6504                 if (io_cqring_events(ctx, false) >= min_events)
6505                         return 0;
6506                 if (!io_run_task_work())
6507                         break;
6508         } while (1);
6509
6510         if (sig) {
6511 #ifdef CONFIG_COMPAT
6512                 if (in_compat_syscall())
6513                         ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
6514                                                       sigsz);
6515                 else
6516 #endif
6517                         ret = set_user_sigmask(sig, sigsz);
6518
6519                 if (ret)
6520                         return ret;
6521         }
6522
6523         iowq.nr_timeouts = atomic_read(&ctx->cq_timeouts);
6524         trace_io_uring_cqring_wait(ctx, min_events);
6525         do {
6526                 prepare_to_wait_exclusive(&ctx->wait, &iowq.wq,
6527                                                 TASK_INTERRUPTIBLE);
6528                 /* make sure we run task_work before checking for signals */
6529                 if (io_run_task_work())
6530                         continue;
6531                 if (signal_pending(current)) {
6532                         if (current->jobctl & JOBCTL_TASK_WORK) {
6533                                 spin_lock_irq(&current->sighand->siglock);
6534                                 current->jobctl &= ~JOBCTL_TASK_WORK;
6535                                 recalc_sigpending();
6536                                 spin_unlock_irq(&current->sighand->siglock);
6537                                 continue;
6538                         }
6539                         ret = -EINTR;
6540                         break;
6541                 }
6542                 if (io_should_wake(&iowq, false))
6543                         break;
6544                 schedule();
6545         } while (1);
6546         finish_wait(&ctx->wait, &iowq.wq);
6547
6548         restore_saved_sigmask_unless(ret == -EINTR);
6549
6550         return READ_ONCE(rings->cq.head) == READ_ONCE(rings->cq.tail) ? ret : 0;
6551 }
6552
6553 static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
6554 {
6555 #if defined(CONFIG_UNIX)
6556         if (ctx->ring_sock) {
6557                 struct sock *sock = ctx->ring_sock->sk;
6558                 struct sk_buff *skb;
6559
6560                 while ((skb = skb_dequeue(&sock->sk_receive_queue)) != NULL)
6561                         kfree_skb(skb);
6562         }
6563 #else
6564         int i;
6565
6566         for (i = 0; i < ctx->nr_user_files; i++) {
6567                 struct file *file;
6568
6569                 file = io_file_from_index(ctx, i);
6570                 if (file)
6571                         fput(file);
6572         }
6573 #endif
6574 }
6575
6576 static void io_file_ref_kill(struct percpu_ref *ref)
6577 {
6578         struct fixed_file_data *data;
6579
6580         data = container_of(ref, struct fixed_file_data, refs);
6581         complete(&data->done);
6582 }
6583
6584 static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
6585 {
6586         struct fixed_file_data *data = ctx->file_data;
6587         struct fixed_file_ref_node *ref_node = NULL;
6588         unsigned nr_tables, i;
6589
6590         if (!data)
6591                 return -ENXIO;
6592
6593         spin_lock(&data->lock);
6594         if (!list_empty(&data->ref_list))
6595                 ref_node = list_first_entry(&data->ref_list,
6596                                 struct fixed_file_ref_node, node);
6597         spin_unlock(&data->lock);
6598         if (ref_node)
6599                 percpu_ref_kill(&ref_node->refs);
6600
6601         percpu_ref_kill(&data->refs);
6602
6603         /* wait for all refs nodes to complete */
6604         flush_delayed_work(&ctx->file_put_work);
6605         wait_for_completion(&data->done);
6606
6607         __io_sqe_files_unregister(ctx);
6608         nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE);
6609         for (i = 0; i < nr_tables; i++)
6610                 kfree(data->table[i].files);
6611         kfree(data->table);
6612         percpu_ref_exit(&data->refs);
6613         kfree(data);
6614         ctx->file_data = NULL;
6615         ctx->nr_user_files = 0;
6616         return 0;
6617 }
6618
6619 static void io_sq_thread_stop(struct io_ring_ctx *ctx)
6620 {
6621         if (ctx->sqo_thread) {
6622                 wait_for_completion(&ctx->sq_thread_comp);
6623                 /*
6624                  * The park is a bit of a work-around, without it we get
6625                  * warning spews on shutdown with SQPOLL set and affinity
6626                  * set to a single CPU.
6627                  */
6628                 kthread_park(ctx->sqo_thread);
6629                 kthread_stop(ctx->sqo_thread);
6630                 ctx->sqo_thread = NULL;
6631         }
6632 }
6633
6634 static void io_finish_async(struct io_ring_ctx *ctx)
6635 {
6636         io_sq_thread_stop(ctx);
6637
6638         if (ctx->io_wq) {
6639                 io_wq_destroy(ctx->io_wq);
6640                 ctx->io_wq = NULL;
6641         }
6642 }
6643
6644 #if defined(CONFIG_UNIX)
6645 /*
6646  * Ensure the UNIX gc is aware of our file set, so we are certain that
6647  * the io_uring can be safely unregistered on process exit, even if we have
6648  * loops in the file referencing.
6649  */
6650 static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset)
6651 {
6652         struct sock *sk = ctx->ring_sock->sk;
6653         struct scm_fp_list *fpl;
6654         struct sk_buff *skb;
6655         int i, nr_files;
6656
6657         fpl = kzalloc(sizeof(*fpl), GFP_KERNEL);
6658         if (!fpl)
6659                 return -ENOMEM;
6660
6661         skb = alloc_skb(0, GFP_KERNEL);
6662         if (!skb) {
6663                 kfree(fpl);
6664                 return -ENOMEM;
6665         }
6666
6667         skb->sk = sk;
6668
6669         nr_files = 0;
6670         fpl->user = get_uid(ctx->user);
6671         for (i = 0; i < nr; i++) {
6672                 struct file *file = io_file_from_index(ctx, i + offset);
6673
6674                 if (!file)
6675                         continue;
6676                 fpl->fp[nr_files] = get_file(file);
6677                 unix_inflight(fpl->user, fpl->fp[nr_files]);
6678                 nr_files++;
6679         }
6680
6681         if (nr_files) {
6682                 fpl->max = SCM_MAX_FD;
6683                 fpl->count = nr_files;
6684                 UNIXCB(skb).fp = fpl;
6685                 skb->destructor = unix_destruct_scm;
6686                 refcount_add(skb->truesize, &sk->sk_wmem_alloc);
6687                 skb_queue_head(&sk->sk_receive_queue, skb);
6688
6689                 for (i = 0; i < nr_files; i++)
6690                         fput(fpl->fp[i]);
6691         } else {
6692                 kfree_skb(skb);
6693                 kfree(fpl);
6694         }
6695
6696         return 0;
6697 }
6698
6699 /*
6700  * If UNIX sockets are enabled, fd passing can cause a reference cycle which
6701  * causes regular reference counting to break down. We rely on the UNIX
6702  * garbage collection to take care of this problem for us.
6703  */
6704 static int io_sqe_files_scm(struct io_ring_ctx *ctx)
6705 {
6706         unsigned left, total;
6707         int ret = 0;
6708
6709         total = 0;
6710         left = ctx->nr_user_files;
6711         while (left) {
6712                 unsigned this_files = min_t(unsigned, left, SCM_MAX_FD);
6713
6714                 ret = __io_sqe_files_scm(ctx, this_files, total);
6715                 if (ret)
6716                         break;
6717                 left -= this_files;
6718                 total += this_files;
6719         }
6720
6721         if (!ret)
6722                 return 0;
6723
6724         while (total < ctx->nr_user_files) {
6725                 struct file *file = io_file_from_index(ctx, total);
6726
6727                 if (file)
6728                         fput(file);
6729                 total++;
6730         }
6731
6732         return ret;
6733 }
6734 #else
6735 static int io_sqe_files_scm(struct io_ring_ctx *ctx)
6736 {
6737         return 0;
6738 }
6739 #endif
6740
6741 static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
6742                                     unsigned nr_files)
6743 {
6744         int i;
6745
6746         for (i = 0; i < nr_tables; i++) {
6747                 struct fixed_file_table *table = &ctx->file_data->table[i];
6748                 unsigned this_files;
6749
6750                 this_files = min(nr_files, IORING_MAX_FILES_TABLE);
6751                 table->files = kcalloc(this_files, sizeof(struct file *),
6752                                         GFP_KERNEL);
6753                 if (!table->files)
6754                         break;
6755                 nr_files -= this_files;
6756         }
6757
6758         if (i == nr_tables)
6759                 return 0;
6760
6761         for (i = 0; i < nr_tables; i++) {
6762                 struct fixed_file_table *table = &ctx->file_data->table[i];
6763                 kfree(table->files);
6764         }
6765         return 1;
6766 }
6767
6768 static void io_ring_file_put(struct io_ring_ctx *ctx, struct file *file)
6769 {
6770 #if defined(CONFIG_UNIX)
6771         struct sock *sock = ctx->ring_sock->sk;
6772         struct sk_buff_head list, *head = &sock->sk_receive_queue;
6773         struct sk_buff *skb;
6774         int i;
6775
6776         __skb_queue_head_init(&list);
6777
6778         /*
6779          * Find the skb that holds this file in its SCM_RIGHTS. When found,
6780          * remove this entry and rearrange the file array.
6781          */
6782         skb = skb_dequeue(head);
6783         while (skb) {
6784                 struct scm_fp_list *fp;
6785
6786                 fp = UNIXCB(skb).fp;
6787                 for (i = 0; i < fp->count; i++) {
6788                         int left;
6789
6790                         if (fp->fp[i] != file)
6791                                 continue;
6792
6793                         unix_notinflight(fp->user, fp->fp[i]);
6794                         left = fp->count - 1 - i;
6795                         if (left) {
6796                                 memmove(&fp->fp[i], &fp->fp[i + 1],
6797                                                 left * sizeof(struct file *));
6798                         }
6799                         fp->count--;
6800                         if (!fp->count) {
6801                                 kfree_skb(skb);
6802                                 skb = NULL;
6803                         } else {
6804                                 __skb_queue_tail(&list, skb);
6805                         }
6806                         fput(file);
6807                         file = NULL;
6808                         break;
6809                 }
6810
6811                 if (!file)
6812                         break;
6813
6814                 __skb_queue_tail(&list, skb);
6815
6816                 skb = skb_dequeue(head);
6817         }
6818
6819         if (skb_peek(&list)) {
6820                 spin_lock_irq(&head->lock);
6821                 while ((skb = __skb_dequeue(&list)) != NULL)
6822                         __skb_queue_tail(head, skb);
6823                 spin_unlock_irq(&head->lock);
6824         }
6825 #else
6826         fput(file);
6827 #endif
6828 }
6829
6830 struct io_file_put {
6831         struct list_head list;
6832         struct file *file;
6833 };
6834
6835 static void __io_file_put_work(struct fixed_file_ref_node *ref_node)
6836 {
6837         struct fixed_file_data *file_data = ref_node->file_data;
6838         struct io_ring_ctx *ctx = file_data->ctx;
6839         struct io_file_put *pfile, *tmp;
6840
6841         list_for_each_entry_safe(pfile, tmp, &ref_node->file_list, list) {
6842                 list_del(&pfile->list);
6843                 io_ring_file_put(ctx, pfile->file);
6844                 kfree(pfile);
6845         }
6846
6847         spin_lock(&file_data->lock);
6848         list_del(&ref_node->node);
6849         spin_unlock(&file_data->lock);
6850
6851         percpu_ref_exit(&ref_node->refs);
6852         kfree(ref_node);
6853         percpu_ref_put(&file_data->refs);
6854 }
6855
6856 static void io_file_put_work(struct work_struct *work)
6857 {
6858         struct io_ring_ctx *ctx;
6859         struct llist_node *node;
6860
6861         ctx = container_of(work, struct io_ring_ctx, file_put_work.work);
6862         node = llist_del_all(&ctx->file_put_llist);
6863
6864         while (node) {
6865                 struct fixed_file_ref_node *ref_node;
6866                 struct llist_node *next = node->next;
6867
6868                 ref_node = llist_entry(node, struct fixed_file_ref_node, llist);
6869                 __io_file_put_work(ref_node);
6870                 node = next;
6871         }
6872 }
6873
6874 static void io_file_data_ref_zero(struct percpu_ref *ref)
6875 {
6876         struct fixed_file_ref_node *ref_node;
6877         struct io_ring_ctx *ctx;
6878         bool first_add;
6879         int delay = HZ;
6880
6881         ref_node = container_of(ref, struct fixed_file_ref_node, refs);
6882         ctx = ref_node->file_data->ctx;
6883
6884         if (percpu_ref_is_dying(&ctx->file_data->refs))
6885                 delay = 0;
6886
6887         first_add = llist_add(&ref_node->llist, &ctx->file_put_llist);
6888         if (!delay)
6889                 mod_delayed_work(system_wq, &ctx->file_put_work, 0);
6890         else if (first_add)
6891                 queue_delayed_work(system_wq, &ctx->file_put_work, delay);
6892 }
6893
6894 static struct fixed_file_ref_node *alloc_fixed_file_ref_node(
6895                         struct io_ring_ctx *ctx)
6896 {
6897         struct fixed_file_ref_node *ref_node;
6898
6899         ref_node = kzalloc(sizeof(*ref_node), GFP_KERNEL);
6900         if (!ref_node)
6901                 return ERR_PTR(-ENOMEM);
6902
6903         if (percpu_ref_init(&ref_node->refs, io_file_data_ref_zero,
6904                             0, GFP_KERNEL)) {
6905                 kfree(ref_node);
6906                 return ERR_PTR(-ENOMEM);
6907         }
6908         INIT_LIST_HEAD(&ref_node->node);
6909         INIT_LIST_HEAD(&ref_node->file_list);
6910         ref_node->file_data = ctx->file_data;
6911         return ref_node;
6912 }
6913
6914 static void destroy_fixed_file_ref_node(struct fixed_file_ref_node *ref_node)
6915 {
6916         percpu_ref_exit(&ref_node->refs);
6917         kfree(ref_node);
6918 }
6919
6920 static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
6921                                  unsigned nr_args)
6922 {
6923         __s32 __user *fds = (__s32 __user *) arg;
6924         unsigned nr_tables;
6925         struct file *file;
6926         int fd, ret = 0;
6927         unsigned i;
6928         struct fixed_file_ref_node *ref_node;
6929
6930         if (ctx->file_data)
6931                 return -EBUSY;
6932         if (!nr_args)
6933                 return -EINVAL;
6934         if (nr_args > IORING_MAX_FIXED_FILES)
6935                 return -EMFILE;
6936
6937         ctx->file_data = kzalloc(sizeof(*ctx->file_data), GFP_KERNEL);
6938         if (!ctx->file_data)
6939                 return -ENOMEM;
6940         ctx->file_data->ctx = ctx;
6941         init_completion(&ctx->file_data->done);
6942         INIT_LIST_HEAD(&ctx->file_data->ref_list);
6943         spin_lock_init(&ctx->file_data->lock);
6944
6945         nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE);
6946         ctx->file_data->table = kcalloc(nr_tables,
6947                                         sizeof(struct fixed_file_table),
6948                                         GFP_KERNEL);
6949         if (!ctx->file_data->table) {
6950                 kfree(ctx->file_data);
6951                 ctx->file_data = NULL;
6952                 return -ENOMEM;
6953         }
6954
6955         if (percpu_ref_init(&ctx->file_data->refs, io_file_ref_kill,
6956                                 PERCPU_REF_ALLOW_REINIT, GFP_KERNEL)) {
6957                 kfree(ctx->file_data->table);
6958                 kfree(ctx->file_data);
6959                 ctx->file_data = NULL;
6960                 return -ENOMEM;
6961         }
6962
6963         if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) {
6964                 percpu_ref_exit(&ctx->file_data->refs);
6965                 kfree(ctx->file_data->table);
6966                 kfree(ctx->file_data);
6967                 ctx->file_data = NULL;
6968                 return -ENOMEM;
6969         }
6970
6971         for (i = 0; i < nr_args; i++, ctx->nr_user_files++) {
6972                 struct fixed_file_table *table;
6973                 unsigned index;
6974
6975                 ret = -EFAULT;
6976                 if (copy_from_user(&fd, &fds[i], sizeof(fd)))
6977                         break;
6978                 /* allow sparse sets */
6979                 if (fd == -1) {
6980                         ret = 0;
6981                         continue;
6982                 }
6983
6984                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
6985                 index = i & IORING_FILE_TABLE_MASK;
6986                 file = fget(fd);
6987
6988                 ret = -EBADF;
6989                 if (!file)
6990                         break;
6991
6992                 /*
6993                  * Don't allow io_uring instances to be registered. If UNIX
6994                  * isn't enabled, then this causes a reference cycle and this
6995                  * instance can never get freed. If UNIX is enabled we'll
6996                  * handle it just fine, but there's still no point in allowing
6997                  * a ring fd as it doesn't support regular read/write anyway.
6998                  */
6999                 if (file->f_op == &io_uring_fops) {
7000                         fput(file);
7001                         break;
7002                 }
7003                 ret = 0;
7004                 table->files[index] = file;
7005         }
7006
7007         if (ret) {
7008                 for (i = 0; i < ctx->nr_user_files; i++) {
7009                         file = io_file_from_index(ctx, i);
7010                         if (file)
7011                                 fput(file);
7012                 }
7013                 for (i = 0; i < nr_tables; i++)
7014                         kfree(ctx->file_data->table[i].files);
7015
7016                 percpu_ref_exit(&ctx->file_data->refs);
7017                 kfree(ctx->file_data->table);
7018                 kfree(ctx->file_data);
7019                 ctx->file_data = NULL;
7020                 ctx->nr_user_files = 0;
7021                 return ret;
7022         }
7023
7024         ret = io_sqe_files_scm(ctx);
7025         if (ret) {
7026                 io_sqe_files_unregister(ctx);
7027                 return ret;
7028         }
7029
7030         ref_node = alloc_fixed_file_ref_node(ctx);
7031         if (IS_ERR(ref_node)) {
7032                 io_sqe_files_unregister(ctx);
7033                 return PTR_ERR(ref_node);
7034         }
7035
7036         ctx->file_data->cur_refs = &ref_node->refs;
7037         spin_lock(&ctx->file_data->lock);
7038         list_add(&ref_node->node, &ctx->file_data->ref_list);
7039         spin_unlock(&ctx->file_data->lock);
7040         percpu_ref_get(&ctx->file_data->refs);
7041         return ret;
7042 }
7043
7044 static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
7045                                 int index)
7046 {
7047 #if defined(CONFIG_UNIX)
7048         struct sock *sock = ctx->ring_sock->sk;
7049         struct sk_buff_head *head = &sock->sk_receive_queue;
7050         struct sk_buff *skb;
7051
7052         /*
7053          * See if we can merge this file into an existing skb SCM_RIGHTS
7054          * file set. If there's no room, fall back to allocating a new skb
7055          * and filling it in.
7056          */
7057         spin_lock_irq(&head->lock);
7058         skb = skb_peek(head);
7059         if (skb) {
7060                 struct scm_fp_list *fpl = UNIXCB(skb).fp;
7061
7062                 if (fpl->count < SCM_MAX_FD) {
7063                         __skb_unlink(skb, head);
7064                         spin_unlock_irq(&head->lock);
7065                         fpl->fp[fpl->count] = get_file(file);
7066                         unix_inflight(fpl->user, fpl->fp[fpl->count]);
7067                         fpl->count++;
7068                         spin_lock_irq(&head->lock);
7069                         __skb_queue_head(head, skb);
7070                 } else {
7071                         skb = NULL;
7072                 }
7073         }
7074         spin_unlock_irq(&head->lock);
7075
7076         if (skb) {
7077                 fput(file);
7078                 return 0;
7079         }
7080
7081         return __io_sqe_files_scm(ctx, 1, index);
7082 #else
7083         return 0;
7084 #endif
7085 }
7086
7087 static int io_queue_file_removal(struct fixed_file_data *data,
7088                                  struct file *file)
7089 {
7090         struct io_file_put *pfile;
7091         struct percpu_ref *refs = data->cur_refs;
7092         struct fixed_file_ref_node *ref_node;
7093
7094         pfile = kzalloc(sizeof(*pfile), GFP_KERNEL);
7095         if (!pfile)
7096                 return -ENOMEM;
7097
7098         ref_node = container_of(refs, struct fixed_file_ref_node, refs);
7099         pfile->file = file;
7100         list_add(&pfile->list, &ref_node->file_list);
7101
7102         return 0;
7103 }
7104
7105 static int __io_sqe_files_update(struct io_ring_ctx *ctx,
7106                                  struct io_uring_files_update *up,
7107                                  unsigned nr_args)
7108 {
7109         struct fixed_file_data *data = ctx->file_data;
7110         struct fixed_file_ref_node *ref_node;
7111         struct file *file;
7112         __s32 __user *fds;
7113         int fd, i, err;
7114         __u32 done;
7115         bool needs_switch = false;
7116
7117         if (check_add_overflow(up->offset, nr_args, &done))
7118                 return -EOVERFLOW;
7119         if (done > ctx->nr_user_files)
7120                 return -EINVAL;
7121
7122         ref_node = alloc_fixed_file_ref_node(ctx);
7123         if (IS_ERR(ref_node))
7124                 return PTR_ERR(ref_node);
7125
7126         done = 0;
7127         fds = u64_to_user_ptr(up->fds);
7128         while (nr_args) {
7129                 struct fixed_file_table *table;
7130                 unsigned index;
7131
7132                 err = 0;
7133                 if (copy_from_user(&fd, &fds[done], sizeof(fd))) {
7134                         err = -EFAULT;
7135                         break;
7136                 }
7137                 i = array_index_nospec(up->offset, ctx->nr_user_files);
7138                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
7139                 index = i & IORING_FILE_TABLE_MASK;
7140                 if (table->files[index]) {
7141                         file = io_file_from_index(ctx, index);
7142                         err = io_queue_file_removal(data, file);
7143                         if (err)
7144                                 break;
7145                         table->files[index] = NULL;
7146                         needs_switch = true;
7147                 }
7148                 if (fd != -1) {
7149                         file = fget(fd);
7150                         if (!file) {
7151                                 err = -EBADF;
7152                                 break;
7153                         }
7154                         /*
7155                          * Don't allow io_uring instances to be registered. If
7156                          * UNIX isn't enabled, then this causes a reference
7157                          * cycle and this instance can never get freed. If UNIX
7158                          * is enabled we'll handle it just fine, but there's
7159                          * still no point in allowing a ring fd as it doesn't
7160                          * support regular read/write anyway.
7161                          */
7162                         if (file->f_op == &io_uring_fops) {
7163                                 fput(file);
7164                                 err = -EBADF;
7165                                 break;
7166                         }
7167                         table->files[index] = file;
7168                         err = io_sqe_file_register(ctx, file, i);
7169                         if (err) {
7170                                 fput(file);
7171                                 break;
7172                         }
7173                 }
7174                 nr_args--;
7175                 done++;
7176                 up->offset++;
7177         }
7178
7179         if (needs_switch) {
7180                 percpu_ref_kill(data->cur_refs);
7181                 spin_lock(&data->lock);
7182                 list_add(&ref_node->node, &data->ref_list);
7183                 data->cur_refs = &ref_node->refs;
7184                 spin_unlock(&data->lock);
7185                 percpu_ref_get(&ctx->file_data->refs);
7186         } else
7187                 destroy_fixed_file_ref_node(ref_node);
7188
7189         return done ? done : err;
7190 }
7191
7192 static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
7193                                unsigned nr_args)
7194 {
7195         struct io_uring_files_update up;
7196
7197         if (!ctx->file_data)
7198                 return -ENXIO;
7199         if (!nr_args)
7200                 return -EINVAL;
7201         if (copy_from_user(&up, arg, sizeof(up)))
7202                 return -EFAULT;
7203         if (up.resv)
7204                 return -EINVAL;
7205
7206         return __io_sqe_files_update(ctx, &up, nr_args);
7207 }
7208
7209 static void io_free_work(struct io_wq_work *work)
7210 {
7211         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
7212
7213         /* Consider that io_steal_work() relies on this ref */
7214         io_put_req(req);
7215 }
7216
7217 static int io_init_wq_offload(struct io_ring_ctx *ctx,
7218                               struct io_uring_params *p)
7219 {
7220         struct io_wq_data data;
7221         struct fd f;
7222         struct io_ring_ctx *ctx_attach;
7223         unsigned int concurrency;
7224         int ret = 0;
7225
7226         data.user = ctx->user;
7227         data.free_work = io_free_work;
7228         data.do_work = io_wq_submit_work;
7229
7230         if (!(p->flags & IORING_SETUP_ATTACH_WQ)) {
7231                 /* Do QD, or 4 * CPUS, whatever is smallest */
7232                 concurrency = min(ctx->sq_entries, 4 * num_online_cpus());
7233
7234                 ctx->io_wq = io_wq_create(concurrency, &data);
7235                 if (IS_ERR(ctx->io_wq)) {
7236                         ret = PTR_ERR(ctx->io_wq);
7237                         ctx->io_wq = NULL;
7238                 }
7239                 return ret;
7240         }
7241
7242         f = fdget(p->wq_fd);
7243         if (!f.file)
7244                 return -EBADF;
7245
7246         if (f.file->f_op != &io_uring_fops) {
7247                 ret = -EINVAL;
7248                 goto out_fput;
7249         }
7250
7251         ctx_attach = f.file->private_data;
7252         /* @io_wq is protected by holding the fd */
7253         if (!io_wq_get(ctx_attach->io_wq, &data)) {
7254                 ret = -EINVAL;
7255                 goto out_fput;
7256         }
7257
7258         ctx->io_wq = ctx_attach->io_wq;
7259 out_fput:
7260         fdput(f);
7261         return ret;
7262 }
7263
7264 static int io_sq_offload_start(struct io_ring_ctx *ctx,
7265                                struct io_uring_params *p)
7266 {
7267         int ret;
7268
7269         if (ctx->flags & IORING_SETUP_SQPOLL) {
7270                 mmgrab(current->mm);
7271                 ctx->sqo_mm = current->mm;
7272
7273                 ret = -EPERM;
7274                 if (!capable(CAP_SYS_ADMIN))
7275                         goto err;
7276
7277                 ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
7278                 if (!ctx->sq_thread_idle)
7279                         ctx->sq_thread_idle = HZ;
7280
7281                 if (p->flags & IORING_SETUP_SQ_AFF) {
7282                         int cpu = p->sq_thread_cpu;
7283
7284                         ret = -EINVAL;
7285                         if (cpu >= nr_cpu_ids)
7286                                 goto err;
7287                         if (!cpu_online(cpu))
7288                                 goto err;
7289
7290                         ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
7291                                                         ctx, cpu,
7292                                                         "io_uring-sq");
7293                 } else {
7294                         ctx->sqo_thread = kthread_create(io_sq_thread, ctx,
7295                                                         "io_uring-sq");
7296                 }
7297                 if (IS_ERR(ctx->sqo_thread)) {
7298                         ret = PTR_ERR(ctx->sqo_thread);
7299                         ctx->sqo_thread = NULL;
7300                         goto err;
7301                 }
7302                 wake_up_process(ctx->sqo_thread);
7303         } else if (p->flags & IORING_SETUP_SQ_AFF) {
7304                 /* Can't have SQ_AFF without SQPOLL */
7305                 ret = -EINVAL;
7306                 goto err;
7307         }
7308
7309         ret = io_init_wq_offload(ctx, p);
7310         if (ret)
7311                 goto err;
7312
7313         return 0;
7314 err:
7315         io_finish_async(ctx);
7316         if (ctx->sqo_mm) {
7317                 mmdrop(ctx->sqo_mm);
7318                 ctx->sqo_mm = NULL;
7319         }
7320         return ret;
7321 }
7322
7323 static inline void __io_unaccount_mem(struct user_struct *user,
7324                                       unsigned long nr_pages)
7325 {
7326         atomic_long_sub(nr_pages, &user->locked_vm);
7327 }
7328
7329 static inline int __io_account_mem(struct user_struct *user,
7330                                    unsigned long nr_pages)
7331 {
7332         unsigned long page_limit, cur_pages, new_pages;
7333
7334         /* Don't allow more pages than we can safely lock */
7335         page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
7336
7337         do {
7338                 cur_pages = atomic_long_read(&user->locked_vm);
7339                 new_pages = cur_pages + nr_pages;
7340                 if (new_pages > page_limit)
7341                         return -ENOMEM;
7342         } while (atomic_long_cmpxchg(&user->locked_vm, cur_pages,
7343                                         new_pages) != cur_pages);
7344
7345         return 0;
7346 }
7347
7348 static void io_unaccount_mem(struct io_ring_ctx *ctx, unsigned long nr_pages,
7349                              enum io_mem_account acct)
7350 {
7351         if (ctx->limit_mem)
7352                 __io_unaccount_mem(ctx->user, nr_pages);
7353
7354         if (ctx->sqo_mm) {
7355                 if (acct == ACCT_LOCKED)
7356                         ctx->sqo_mm->locked_vm -= nr_pages;
7357                 else if (acct == ACCT_PINNED)
7358                         atomic64_sub(nr_pages, &ctx->sqo_mm->pinned_vm);
7359         }
7360 }
7361
7362 static int io_account_mem(struct io_ring_ctx *ctx, unsigned long nr_pages,
7363                           enum io_mem_account acct)
7364 {
7365         int ret;
7366
7367         if (ctx->limit_mem) {
7368                 ret = __io_account_mem(ctx->user, nr_pages);
7369                 if (ret)
7370                         return ret;
7371         }
7372
7373         if (ctx->sqo_mm) {
7374                 if (acct == ACCT_LOCKED)
7375                         ctx->sqo_mm->locked_vm += nr_pages;
7376                 else if (acct == ACCT_PINNED)
7377                         atomic64_add(nr_pages, &ctx->sqo_mm->pinned_vm);
7378         }
7379
7380         return 0;
7381 }
7382
7383 static void io_mem_free(void *ptr)
7384 {
7385         struct page *page;
7386
7387         if (!ptr)
7388                 return;
7389
7390         page = virt_to_head_page(ptr);
7391         if (put_page_testzero(page))
7392                 free_compound_page(page);
7393 }
7394
7395 static void *io_mem_alloc(size_t size)
7396 {
7397         gfp_t gfp_flags = GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN | __GFP_COMP |
7398                                 __GFP_NORETRY;
7399
7400         return (void *) __get_free_pages(gfp_flags, get_order(size));
7401 }
7402
7403 static unsigned long rings_size(unsigned sq_entries, unsigned cq_entries,
7404                                 size_t *sq_offset)
7405 {
7406         struct io_rings *rings;
7407         size_t off, sq_array_size;
7408
7409         off = struct_size(rings, cqes, cq_entries);
7410         if (off == SIZE_MAX)
7411                 return SIZE_MAX;
7412
7413 #ifdef CONFIG_SMP
7414         off = ALIGN(off, SMP_CACHE_BYTES);
7415         if (off == 0)
7416                 return SIZE_MAX;
7417 #endif
7418
7419         if (sq_offset)
7420                 *sq_offset = off;
7421
7422         sq_array_size = array_size(sizeof(u32), sq_entries);
7423         if (sq_array_size == SIZE_MAX)
7424                 return SIZE_MAX;
7425
7426         if (check_add_overflow(off, sq_array_size, &off))
7427                 return SIZE_MAX;
7428
7429         return off;
7430 }
7431
7432 static unsigned long ring_pages(unsigned sq_entries, unsigned cq_entries)
7433 {
7434         size_t pages;
7435
7436         pages = (size_t)1 << get_order(
7437                 rings_size(sq_entries, cq_entries, NULL));
7438         pages += (size_t)1 << get_order(
7439                 array_size(sizeof(struct io_uring_sqe), sq_entries));
7440
7441         return pages;
7442 }
7443
7444 static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx)
7445 {
7446         int i, j;
7447
7448         if (!ctx->user_bufs)
7449                 return -ENXIO;
7450
7451         for (i = 0; i < ctx->nr_user_bufs; i++) {
7452                 struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
7453
7454                 for (j = 0; j < imu->nr_bvecs; j++)
7455                         unpin_user_page(imu->bvec[j].bv_page);
7456
7457                 io_unaccount_mem(ctx, imu->nr_bvecs, ACCT_PINNED);
7458                 kvfree(imu->bvec);
7459                 imu->nr_bvecs = 0;
7460         }
7461
7462         kfree(ctx->user_bufs);
7463         ctx->user_bufs = NULL;
7464         ctx->nr_user_bufs = 0;
7465         return 0;
7466 }
7467
7468 static int io_copy_iov(struct io_ring_ctx *ctx, struct iovec *dst,
7469                        void __user *arg, unsigned index)
7470 {
7471         struct iovec __user *src;
7472
7473 #ifdef CONFIG_COMPAT
7474         if (ctx->compat) {
7475                 struct compat_iovec __user *ciovs;
7476                 struct compat_iovec ciov;
7477
7478                 ciovs = (struct compat_iovec __user *) arg;
7479                 if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
7480                         return -EFAULT;
7481
7482                 dst->iov_base = u64_to_user_ptr((u64)ciov.iov_base);
7483                 dst->iov_len = ciov.iov_len;
7484                 return 0;
7485         }
7486 #endif
7487         src = (struct iovec __user *) arg;
7488         if (copy_from_user(dst, &src[index], sizeof(*dst)))
7489                 return -EFAULT;
7490         return 0;
7491 }
7492
7493 static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
7494                                   unsigned nr_args)
7495 {
7496         struct vm_area_struct **vmas = NULL;
7497         struct page **pages = NULL;
7498         int i, j, got_pages = 0;
7499         int ret = -EINVAL;
7500
7501         if (ctx->user_bufs)
7502                 return -EBUSY;
7503         if (!nr_args || nr_args > UIO_MAXIOV)
7504                 return -EINVAL;
7505
7506         ctx->user_bufs = kcalloc(nr_args, sizeof(struct io_mapped_ubuf),
7507                                         GFP_KERNEL);
7508         if (!ctx->user_bufs)
7509                 return -ENOMEM;
7510
7511         for (i = 0; i < nr_args; i++) {
7512                 struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
7513                 unsigned long off, start, end, ubuf;
7514                 int pret, nr_pages;
7515                 struct iovec iov;
7516                 size_t size;
7517
7518                 ret = io_copy_iov(ctx, &iov, arg, i);
7519                 if (ret)
7520                         goto err;
7521
7522                 /*
7523                  * Don't impose further limits on the size and buffer
7524                  * constraints here, we'll -EINVAL later when IO is
7525                  * submitted if they are wrong.
7526                  */
7527                 ret = -EFAULT;
7528                 if (!iov.iov_base || !iov.iov_len)
7529                         goto err;
7530
7531                 /* arbitrary limit, but we need something */
7532                 if (iov.iov_len > SZ_1G)
7533                         goto err;
7534
7535                 ubuf = (unsigned long) iov.iov_base;
7536                 end = (ubuf + iov.iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
7537                 start = ubuf >> PAGE_SHIFT;
7538                 nr_pages = end - start;
7539
7540                 ret = io_account_mem(ctx, nr_pages, ACCT_PINNED);
7541                 if (ret)
7542                         goto err;
7543
7544                 ret = 0;
7545                 if (!pages || nr_pages > got_pages) {
7546                         kvfree(vmas);
7547                         kvfree(pages);
7548                         pages = kvmalloc_array(nr_pages, sizeof(struct page *),
7549                                                 GFP_KERNEL);
7550                         vmas = kvmalloc_array(nr_pages,
7551                                         sizeof(struct vm_area_struct *),
7552                                         GFP_KERNEL);
7553                         if (!pages || !vmas) {
7554                                 ret = -ENOMEM;
7555                                 io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7556                                 goto err;
7557                         }
7558                         got_pages = nr_pages;
7559                 }
7560
7561                 imu->bvec = kvmalloc_array(nr_pages, sizeof(struct bio_vec),
7562                                                 GFP_KERNEL);
7563                 ret = -ENOMEM;
7564                 if (!imu->bvec) {
7565                         io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7566                         goto err;
7567                 }
7568
7569                 ret = 0;
7570                 mmap_read_lock(current->mm);
7571                 pret = pin_user_pages(ubuf, nr_pages,
7572                                       FOLL_WRITE | FOLL_LONGTERM,
7573                                       pages, vmas);
7574                 if (pret == nr_pages) {
7575                         /* don't support file backed memory */
7576                         for (j = 0; j < nr_pages; j++) {
7577                                 struct vm_area_struct *vma = vmas[j];
7578
7579                                 if (vma->vm_file &&
7580                                     !is_file_hugepages(vma->vm_file)) {
7581                                         ret = -EOPNOTSUPP;
7582                                         break;
7583                                 }
7584                         }
7585                 } else {
7586                         ret = pret < 0 ? pret : -EFAULT;
7587                 }
7588                 mmap_read_unlock(current->mm);
7589                 if (ret) {
7590                         /*
7591                          * if we did partial map, or found file backed vmas,
7592                          * release any pages we did get
7593                          */
7594                         if (pret > 0)
7595                                 unpin_user_pages(pages, pret);
7596                         io_unaccount_mem(ctx, nr_pages, ACCT_PINNED);
7597                         kvfree(imu->bvec);
7598                         goto err;
7599                 }
7600
7601                 off = ubuf & ~PAGE_MASK;
7602                 size = iov.iov_len;
7603                 for (j = 0; j < nr_pages; j++) {
7604                         size_t vec_len;
7605
7606                         vec_len = min_t(size_t, size, PAGE_SIZE - off);
7607                         imu->bvec[j].bv_page = pages[j];
7608                         imu->bvec[j].bv_len = vec_len;
7609                         imu->bvec[j].bv_offset = off;
7610                         off = 0;
7611                         size -= vec_len;
7612                 }
7613                 /* store original address for later verification */
7614                 imu->ubuf = ubuf;
7615                 imu->len = iov.iov_len;
7616                 imu->nr_bvecs = nr_pages;
7617
7618                 ctx->nr_user_bufs++;
7619         }
7620         kvfree(pages);
7621         kvfree(vmas);
7622         return 0;
7623 err:
7624         kvfree(pages);
7625         kvfree(vmas);
7626         io_sqe_buffer_unregister(ctx);
7627         return ret;
7628 }
7629
7630 static int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg)
7631 {
7632         __s32 __user *fds = arg;
7633         int fd;
7634
7635         if (ctx->cq_ev_fd)
7636                 return -EBUSY;
7637
7638         if (copy_from_user(&fd, fds, sizeof(*fds)))
7639                 return -EFAULT;
7640
7641         ctx->cq_ev_fd = eventfd_ctx_fdget(fd);
7642         if (IS_ERR(ctx->cq_ev_fd)) {
7643                 int ret = PTR_ERR(ctx->cq_ev_fd);
7644                 ctx->cq_ev_fd = NULL;
7645                 return ret;
7646         }
7647
7648         return 0;
7649 }
7650
7651 static int io_eventfd_unregister(struct io_ring_ctx *ctx)
7652 {
7653         if (ctx->cq_ev_fd) {
7654                 eventfd_ctx_put(ctx->cq_ev_fd);
7655                 ctx->cq_ev_fd = NULL;
7656                 return 0;
7657         }
7658
7659         return -ENXIO;
7660 }
7661
7662 static int __io_destroy_buffers(int id, void *p, void *data)
7663 {
7664         struct io_ring_ctx *ctx = data;
7665         struct io_buffer *buf = p;
7666
7667         __io_remove_buffers(ctx, buf, id, -1U);
7668         return 0;
7669 }
7670
7671 static void io_destroy_buffers(struct io_ring_ctx *ctx)
7672 {
7673         idr_for_each(&ctx->io_buffer_idr, __io_destroy_buffers, ctx);
7674         idr_destroy(&ctx->io_buffer_idr);
7675 }
7676
7677 static void io_ring_ctx_free(struct io_ring_ctx *ctx)
7678 {
7679         io_finish_async(ctx);
7680         if (ctx->sqo_mm) {
7681                 mmdrop(ctx->sqo_mm);
7682                 ctx->sqo_mm = NULL;
7683         }
7684
7685         io_sqe_buffer_unregister(ctx);
7686         io_sqe_files_unregister(ctx);
7687         io_eventfd_unregister(ctx);
7688         io_destroy_buffers(ctx);
7689         idr_destroy(&ctx->personality_idr);
7690
7691 #if defined(CONFIG_UNIX)
7692         if (ctx->ring_sock) {
7693                 ctx->ring_sock->file = NULL; /* so that iput() is called */
7694                 sock_release(ctx->ring_sock);
7695         }
7696 #endif
7697
7698         io_mem_free(ctx->rings);
7699         io_mem_free(ctx->sq_sqes);
7700
7701         percpu_ref_exit(&ctx->refs);
7702         free_uid(ctx->user);
7703         put_cred(ctx->creds);
7704         kfree(ctx->cancel_hash);
7705         kmem_cache_free(req_cachep, ctx->fallback_req);
7706         kfree(ctx);
7707 }
7708
7709 static __poll_t io_uring_poll(struct file *file, poll_table *wait)
7710 {
7711         struct io_ring_ctx *ctx = file->private_data;
7712         __poll_t mask = 0;
7713
7714         poll_wait(file, &ctx->cq_wait, wait);
7715         /*
7716          * synchronizes with barrier from wq_has_sleeper call in
7717          * io_commit_cqring
7718          */
7719         smp_rmb();
7720         if (READ_ONCE(ctx->rings->sq.tail) - ctx->cached_sq_head !=
7721             ctx->rings->sq_ring_entries)
7722                 mask |= EPOLLOUT | EPOLLWRNORM;
7723         if (io_cqring_events(ctx, false))
7724                 mask |= EPOLLIN | EPOLLRDNORM;
7725
7726         return mask;
7727 }
7728
7729 static int io_uring_fasync(int fd, struct file *file, int on)
7730 {
7731         struct io_ring_ctx *ctx = file->private_data;
7732
7733         return fasync_helper(fd, file, on, &ctx->cq_fasync);
7734 }
7735
7736 static int io_remove_personalities(int id, void *p, void *data)
7737 {
7738         struct io_ring_ctx *ctx = data;
7739         const struct cred *cred;
7740
7741         cred = idr_remove(&ctx->personality_idr, id);
7742         if (cred)
7743                 put_cred(cred);
7744         return 0;
7745 }
7746
7747 static void io_ring_exit_work(struct work_struct *work)
7748 {
7749         struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx,
7750                                                exit_work);
7751
7752         /*
7753          * If we're doing polled IO and end up having requests being
7754          * submitted async (out-of-line), then completions can come in while
7755          * we're waiting for refs to drop. We need to reap these manually,
7756          * as nobody else will be looking for them.
7757          */
7758         do {
7759                 if (ctx->rings)
7760                         io_cqring_overflow_flush(ctx, true);
7761                 io_iopoll_try_reap_events(ctx);
7762         } while (!wait_for_completion_timeout(&ctx->ref_comp, HZ/20));
7763         io_ring_ctx_free(ctx);
7764 }
7765
7766 static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
7767 {
7768         mutex_lock(&ctx->uring_lock);
7769         percpu_ref_kill(&ctx->refs);
7770         mutex_unlock(&ctx->uring_lock);
7771
7772         io_kill_timeouts(ctx);
7773         io_poll_remove_all(ctx);
7774
7775         if (ctx->io_wq)
7776                 io_wq_cancel_all(ctx->io_wq);
7777
7778         /* if we failed setting up the ctx, we might not have any rings */
7779         if (ctx->rings)
7780                 io_cqring_overflow_flush(ctx, true);
7781         io_iopoll_try_reap_events(ctx);
7782         idr_for_each(&ctx->personality_idr, io_remove_personalities, ctx);
7783
7784         /*
7785          * Do this upfront, so we won't have a grace period where the ring
7786          * is closed but resources aren't reaped yet. This can cause
7787          * spurious failure in setting up a new ring.
7788          */
7789         io_unaccount_mem(ctx, ring_pages(ctx->sq_entries, ctx->cq_entries),
7790                          ACCT_LOCKED);
7791
7792         INIT_WORK(&ctx->exit_work, io_ring_exit_work);
7793         queue_work(system_wq, &ctx->exit_work);
7794 }
7795
7796 static int io_uring_release(struct inode *inode, struct file *file)
7797 {
7798         struct io_ring_ctx *ctx = file->private_data;
7799
7800         file->private_data = NULL;
7801         io_ring_ctx_wait_and_kill(ctx);
7802         return 0;
7803 }
7804
7805 static bool io_wq_files_match(struct io_wq_work *work, void *data)
7806 {
7807         struct files_struct *files = data;
7808
7809         return work->files == files;
7810 }
7811
7812 static void io_uring_cancel_files(struct io_ring_ctx *ctx,
7813                                   struct files_struct *files)
7814 {
7815         if (list_empty_careful(&ctx->inflight_list))
7816                 return;
7817
7818         /* cancel all at once, should be faster than doing it one by one*/
7819         io_wq_cancel_cb(ctx->io_wq, io_wq_files_match, files, true);
7820
7821         while (!list_empty_careful(&ctx->inflight_list)) {
7822                 struct io_kiocb *cancel_req = NULL, *req;
7823                 DEFINE_WAIT(wait);
7824
7825                 spin_lock_irq(&ctx->inflight_lock);
7826                 list_for_each_entry(req, &ctx->inflight_list, inflight_entry) {
7827                         if (req->work.files != files)
7828                                 continue;
7829                         /* req is being completed, ignore */
7830                         if (!refcount_inc_not_zero(&req->refs))
7831                                 continue;
7832                         cancel_req = req;
7833                         break;
7834                 }
7835                 if (cancel_req)
7836                         prepare_to_wait(&ctx->inflight_wait, &wait,
7837                                                 TASK_UNINTERRUPTIBLE);
7838                 spin_unlock_irq(&ctx->inflight_lock);
7839
7840                 /* We need to keep going until we don't find a matching req */
7841                 if (!cancel_req)
7842                         break;
7843
7844                 if (cancel_req->flags & REQ_F_OVERFLOW) {
7845                         spin_lock_irq(&ctx->completion_lock);
7846                         list_del(&cancel_req->compl.list);
7847                         cancel_req->flags &= ~REQ_F_OVERFLOW;
7848                         if (list_empty(&ctx->cq_overflow_list)) {
7849                                 clear_bit(0, &ctx->sq_check_overflow);
7850                                 clear_bit(0, &ctx->cq_check_overflow);
7851                                 ctx->rings->sq_flags &= ~IORING_SQ_CQ_OVERFLOW;
7852                         }
7853                         spin_unlock_irq(&ctx->completion_lock);
7854
7855                         WRITE_ONCE(ctx->rings->cq_overflow,
7856                                 atomic_inc_return(&ctx->cached_cq_overflow));
7857
7858                         /*
7859                          * Put inflight ref and overflow ref. If that's
7860                          * all we had, then we're done with this request.
7861                          */
7862                         if (refcount_sub_and_test(2, &cancel_req->refs)) {
7863                                 io_free_req(cancel_req);
7864                                 finish_wait(&ctx->inflight_wait, &wait);
7865                                 continue;
7866                         }
7867                 } else {
7868                         io_wq_cancel_work(ctx->io_wq, &cancel_req->work);
7869                         io_put_req(cancel_req);
7870                 }
7871
7872                 schedule();
7873                 finish_wait(&ctx->inflight_wait, &wait);
7874         }
7875 }
7876
7877 static bool io_cancel_task_cb(struct io_wq_work *work, void *data)
7878 {
7879         struct io_kiocb *req = container_of(work, struct io_kiocb, work);
7880         struct task_struct *task = data;
7881
7882         return req->task == task;
7883 }
7884
7885 static int io_uring_flush(struct file *file, void *data)
7886 {
7887         struct io_ring_ctx *ctx = file->private_data;
7888
7889         io_uring_cancel_files(ctx, data);
7890
7891         /*
7892          * If the task is going away, cancel work it may have pending
7893          */
7894         if (fatal_signal_pending(current) || (current->flags & PF_EXITING))
7895                 io_wq_cancel_cb(ctx->io_wq, io_cancel_task_cb, current, true);
7896
7897         return 0;
7898 }
7899
7900 static void *io_uring_validate_mmap_request(struct file *file,
7901                                             loff_t pgoff, size_t sz)
7902 {
7903         struct io_ring_ctx *ctx = file->private_data;
7904         loff_t offset = pgoff << PAGE_SHIFT;
7905         struct page *page;
7906         void *ptr;
7907
7908         switch (offset) {
7909         case IORING_OFF_SQ_RING:
7910         case IORING_OFF_CQ_RING:
7911                 ptr = ctx->rings;
7912                 break;
7913         case IORING_OFF_SQES:
7914                 ptr = ctx->sq_sqes;
7915                 break;
7916         default:
7917                 return ERR_PTR(-EINVAL);
7918         }
7919
7920         page = virt_to_head_page(ptr);
7921         if (sz > page_size(page))
7922                 return ERR_PTR(-EINVAL);
7923
7924         return ptr;
7925 }
7926
7927 #ifdef CONFIG_MMU
7928
7929 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
7930 {
7931         size_t sz = vma->vm_end - vma->vm_start;
7932         unsigned long pfn;
7933         void *ptr;
7934
7935         ptr = io_uring_validate_mmap_request(file, vma->vm_pgoff, sz);
7936         if (IS_ERR(ptr))
7937                 return PTR_ERR(ptr);
7938
7939         pfn = virt_to_phys(ptr) >> PAGE_SHIFT;
7940         return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
7941 }
7942
7943 #else /* !CONFIG_MMU */
7944
7945 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
7946 {
7947         return vma->vm_flags & (VM_SHARED | VM_MAYSHARE) ? 0 : -EINVAL;
7948 }
7949
7950 static unsigned int io_uring_nommu_mmap_capabilities(struct file *file)
7951 {
7952         return NOMMU_MAP_DIRECT | NOMMU_MAP_READ | NOMMU_MAP_WRITE;
7953 }
7954
7955 static unsigned long io_uring_nommu_get_unmapped_area(struct file *file,
7956         unsigned long addr, unsigned long len,
7957         unsigned long pgoff, unsigned long flags)
7958 {
7959         void *ptr;
7960
7961         ptr = io_uring_validate_mmap_request(file, pgoff, len);
7962         if (IS_ERR(ptr))
7963                 return PTR_ERR(ptr);
7964
7965         return (unsigned long) ptr;
7966 }
7967
7968 #endif /* !CONFIG_MMU */
7969
7970 SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
7971                 u32, min_complete, u32, flags, const sigset_t __user *, sig,
7972                 size_t, sigsz)
7973 {
7974         struct io_ring_ctx *ctx;
7975         long ret = -EBADF;
7976         int submitted = 0;
7977         struct fd f;
7978
7979         io_run_task_work();
7980
7981         if (flags & ~(IORING_ENTER_GETEVENTS | IORING_ENTER_SQ_WAKEUP))
7982                 return -EINVAL;
7983
7984         f = fdget(fd);
7985         if (!f.file)
7986                 return -EBADF;
7987
7988         ret = -EOPNOTSUPP;
7989         if (f.file->f_op != &io_uring_fops)
7990                 goto out_fput;
7991
7992         ret = -ENXIO;
7993         ctx = f.file->private_data;
7994         if (!percpu_ref_tryget(&ctx->refs))
7995                 goto out_fput;
7996
7997         /*
7998          * For SQ polling, the thread will do all submissions and completions.
7999          * Just return the requested submit count, and wake the thread if
8000          * we were asked to.
8001          */
8002         ret = 0;
8003         if (ctx->flags & IORING_SETUP_SQPOLL) {
8004                 if (!list_empty_careful(&ctx->cq_overflow_list))
8005                         io_cqring_overflow_flush(ctx, false);
8006                 if (flags & IORING_ENTER_SQ_WAKEUP)
8007                         wake_up(&ctx->sqo_wait);
8008                 submitted = to_submit;
8009         } else if (to_submit) {
8010                 mutex_lock(&ctx->uring_lock);
8011                 submitted = io_submit_sqes(ctx, to_submit, f.file, fd);
8012                 mutex_unlock(&ctx->uring_lock);
8013
8014                 if (submitted != to_submit)
8015                         goto out;
8016         }
8017         if (flags & IORING_ENTER_GETEVENTS) {
8018                 min_complete = min(min_complete, ctx->cq_entries);
8019
8020                 /*
8021                  * When SETUP_IOPOLL and SETUP_SQPOLL are both enabled, user
8022                  * space applications don't need to do io completion events
8023                  * polling again, they can rely on io_sq_thread to do polling
8024                  * work, which can reduce cpu usage and uring_lock contention.
8025                  */
8026                 if (ctx->flags & IORING_SETUP_IOPOLL &&
8027                     !(ctx->flags & IORING_SETUP_SQPOLL)) {
8028                         ret = io_iopoll_check(ctx, min_complete);
8029                 } else {
8030                         ret = io_cqring_wait(ctx, min_complete, sig, sigsz);
8031                 }
8032         }
8033
8034 out:
8035         percpu_ref_put(&ctx->refs);
8036 out_fput:
8037         fdput(f);
8038         return submitted ? submitted : ret;
8039 }
8040
8041 #ifdef CONFIG_PROC_FS
8042 static int io_uring_show_cred(int id, void *p, void *data)
8043 {
8044         const struct cred *cred = p;
8045         struct seq_file *m = data;
8046         struct user_namespace *uns = seq_user_ns(m);
8047         struct group_info *gi;
8048         kernel_cap_t cap;
8049         unsigned __capi;
8050         int g;
8051
8052         seq_printf(m, "%5d\n", id);
8053         seq_put_decimal_ull(m, "\tUid:\t", from_kuid_munged(uns, cred->uid));
8054         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->euid));
8055         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->suid));
8056         seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->fsuid));
8057         seq_put_decimal_ull(m, "\n\tGid:\t", from_kgid_munged(uns, cred->gid));
8058         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->egid));
8059         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->sgid));
8060         seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->fsgid));
8061         seq_puts(m, "\n\tGroups:\t");
8062         gi = cred->group_info;
8063         for (g = 0; g < gi->ngroups; g++) {
8064                 seq_put_decimal_ull(m, g ? " " : "",
8065                                         from_kgid_munged(uns, gi->gid[g]));
8066         }
8067         seq_puts(m, "\n\tCapEff:\t");
8068         cap = cred->cap_effective;
8069         CAP_FOR_EACH_U32(__capi)
8070                 seq_put_hex_ll(m, NULL, cap.cap[CAP_LAST_U32 - __capi], 8);
8071         seq_putc(m, '\n');
8072         return 0;
8073 }
8074
8075 static void __io_uring_show_fdinfo(struct io_ring_ctx *ctx, struct seq_file *m)
8076 {
8077         int i;
8078
8079         mutex_lock(&ctx->uring_lock);
8080         seq_printf(m, "UserFiles:\t%u\n", ctx->nr_user_files);
8081         for (i = 0; i < ctx->nr_user_files; i++) {
8082                 struct fixed_file_table *table;
8083                 struct file *f;
8084
8085                 table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
8086                 f = table->files[i & IORING_FILE_TABLE_MASK];
8087                 if (f)
8088                         seq_printf(m, "%5u: %s\n", i, file_dentry(f)->d_iname);
8089                 else
8090                         seq_printf(m, "%5u: <none>\n", i);
8091         }
8092         seq_printf(m, "UserBufs:\t%u\n", ctx->nr_user_bufs);
8093         for (i = 0; i < ctx->nr_user_bufs; i++) {
8094                 struct io_mapped_ubuf *buf = &ctx->user_bufs[i];
8095
8096                 seq_printf(m, "%5u: 0x%llx/%u\n", i, buf->ubuf,
8097                                                 (unsigned int) buf->len);
8098         }
8099         if (!idr_is_empty(&ctx->personality_idr)) {
8100                 seq_printf(m, "Personalities:\n");
8101                 idr_for_each(&ctx->personality_idr, io_uring_show_cred, m);
8102         }
8103         seq_printf(m, "PollList:\n");
8104         spin_lock_irq(&ctx->completion_lock);
8105         for (i = 0; i < (1U << ctx->cancel_hash_bits); i++) {
8106                 struct hlist_head *list = &ctx->cancel_hash[i];
8107                 struct io_kiocb *req;
8108
8109                 hlist_for_each_entry(req, list, hash_node)
8110                         seq_printf(m, "  op=%d, task_works=%d\n", req->opcode,
8111                                         req->task->task_works != NULL);
8112         }
8113         spin_unlock_irq(&ctx->completion_lock);
8114         mutex_unlock(&ctx->uring_lock);
8115 }
8116
8117 static void io_uring_show_fdinfo(struct seq_file *m, struct file *f)
8118 {
8119         struct io_ring_ctx *ctx = f->private_data;
8120
8121         if (percpu_ref_tryget(&ctx->refs)) {
8122                 __io_uring_show_fdinfo(ctx, m);
8123                 percpu_ref_put(&ctx->refs);
8124         }
8125 }
8126 #endif
8127
8128 static const struct file_operations io_uring_fops = {
8129         .release        = io_uring_release,
8130         .flush          = io_uring_flush,
8131         .mmap           = io_uring_mmap,
8132 #ifndef CONFIG_MMU
8133         .get_unmapped_area = io_uring_nommu_get_unmapped_area,
8134         .mmap_capabilities = io_uring_nommu_mmap_capabilities,
8135 #endif
8136         .poll           = io_uring_poll,
8137         .fasync         = io_uring_fasync,
8138 #ifdef CONFIG_PROC_FS
8139         .show_fdinfo    = io_uring_show_fdinfo,
8140 #endif
8141 };
8142
8143 static int io_allocate_scq_urings(struct io_ring_ctx *ctx,
8144                                   struct io_uring_params *p)
8145 {
8146         struct io_rings *rings;
8147         size_t size, sq_array_offset;
8148
8149         size = rings_size(p->sq_entries, p->cq_entries, &sq_array_offset);
8150         if (size == SIZE_MAX)
8151                 return -EOVERFLOW;
8152
8153         rings = io_mem_alloc(size);
8154         if (!rings)
8155                 return -ENOMEM;
8156
8157         ctx->rings = rings;
8158         ctx->sq_array = (u32 *)((char *)rings + sq_array_offset);
8159         rings->sq_ring_mask = p->sq_entries - 1;
8160         rings->cq_ring_mask = p->cq_entries - 1;
8161         rings->sq_ring_entries = p->sq_entries;
8162         rings->cq_ring_entries = p->cq_entries;
8163         ctx->sq_mask = rings->sq_ring_mask;
8164         ctx->cq_mask = rings->cq_ring_mask;
8165         ctx->sq_entries = rings->sq_ring_entries;
8166         ctx->cq_entries = rings->cq_ring_entries;
8167
8168         size = array_size(sizeof(struct io_uring_sqe), p->sq_entries);
8169         if (size == SIZE_MAX) {
8170                 io_mem_free(ctx->rings);
8171                 ctx->rings = NULL;
8172                 return -EOVERFLOW;
8173         }
8174
8175         ctx->sq_sqes = io_mem_alloc(size);
8176         if (!ctx->sq_sqes) {
8177                 io_mem_free(ctx->rings);
8178                 ctx->rings = NULL;
8179                 return -ENOMEM;
8180         }
8181
8182         return 0;
8183 }
8184
8185 /*
8186  * Allocate an anonymous fd, this is what constitutes the application
8187  * visible backing of an io_uring instance. The application mmaps this
8188  * fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
8189  * we have to tie this fd to a socket for file garbage collection purposes.
8190  */
8191 static int io_uring_get_fd(struct io_ring_ctx *ctx)
8192 {
8193         struct file *file;
8194         int ret;
8195
8196 #if defined(CONFIG_UNIX)
8197         ret = sock_create_kern(&init_net, PF_UNIX, SOCK_RAW, IPPROTO_IP,
8198                                 &ctx->ring_sock);
8199         if (ret)
8200                 return ret;
8201 #endif
8202
8203         ret = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
8204         if (ret < 0)
8205                 goto err;
8206
8207         file = anon_inode_getfile("[io_uring]", &io_uring_fops, ctx,
8208                                         O_RDWR | O_CLOEXEC);
8209         if (IS_ERR(file)) {
8210                 put_unused_fd(ret);
8211                 ret = PTR_ERR(file);
8212                 goto err;
8213         }
8214
8215 #if defined(CONFIG_UNIX)
8216         ctx->ring_sock->file = file;
8217 #endif
8218         fd_install(ret, file);
8219         return ret;
8220 err:
8221 #if defined(CONFIG_UNIX)
8222         sock_release(ctx->ring_sock);
8223         ctx->ring_sock = NULL;
8224 #endif
8225         return ret;
8226 }
8227
8228 static int io_uring_create(unsigned entries, struct io_uring_params *p,
8229                            struct io_uring_params __user *params)
8230 {
8231         struct user_struct *user = NULL;
8232         struct io_ring_ctx *ctx;
8233         bool limit_mem;
8234         int ret;
8235
8236         if (!entries)
8237                 return -EINVAL;
8238         if (entries > IORING_MAX_ENTRIES) {
8239                 if (!(p->flags & IORING_SETUP_CLAMP))
8240                         return -EINVAL;
8241                 entries = IORING_MAX_ENTRIES;
8242         }
8243
8244         /*
8245          * Use twice as many entries for the CQ ring. It's possible for the
8246          * application to drive a higher depth than the size of the SQ ring,
8247          * since the sqes are only used at submission time. This allows for
8248          * some flexibility in overcommitting a bit. If the application has
8249          * set IORING_SETUP_CQSIZE, it will have passed in the desired number
8250          * of CQ ring entries manually.
8251          */
8252         p->sq_entries = roundup_pow_of_two(entries);
8253         if (p->flags & IORING_SETUP_CQSIZE) {
8254                 /*
8255                  * If IORING_SETUP_CQSIZE is set, we do the same roundup
8256                  * to a power-of-two, if it isn't already. We do NOT impose
8257                  * any cq vs sq ring sizing.
8258                  */
8259                 if (p->cq_entries < p->sq_entries)
8260                         return -EINVAL;
8261                 if (p->cq_entries > IORING_MAX_CQ_ENTRIES) {
8262                         if (!(p->flags & IORING_SETUP_CLAMP))
8263                                 return -EINVAL;
8264                         p->cq_entries = IORING_MAX_CQ_ENTRIES;
8265                 }
8266                 p->cq_entries = roundup_pow_of_two(p->cq_entries);
8267         } else {
8268                 p->cq_entries = 2 * p->sq_entries;
8269         }
8270
8271         user = get_uid(current_user());
8272         limit_mem = !capable(CAP_IPC_LOCK);
8273
8274         if (limit_mem) {
8275                 ret = __io_account_mem(user,
8276                                 ring_pages(p->sq_entries, p->cq_entries));
8277                 if (ret) {
8278                         free_uid(user);
8279                         return ret;
8280                 }
8281         }
8282
8283         ctx = io_ring_ctx_alloc(p);
8284         if (!ctx) {
8285                 if (limit_mem)
8286                         __io_unaccount_mem(user, ring_pages(p->sq_entries,
8287                                                                 p->cq_entries));
8288                 free_uid(user);
8289                 return -ENOMEM;
8290         }
8291         ctx->compat = in_compat_syscall();
8292         ctx->user = user;
8293         ctx->creds = get_current_cred();
8294
8295         ret = io_allocate_scq_urings(ctx, p);
8296         if (ret)
8297                 goto err;
8298
8299         ret = io_sq_offload_start(ctx, p);
8300         if (ret)
8301                 goto err;
8302
8303         memset(&p->sq_off, 0, sizeof(p->sq_off));
8304         p->sq_off.head = offsetof(struct io_rings, sq.head);
8305         p->sq_off.tail = offsetof(struct io_rings, sq.tail);
8306         p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask);
8307         p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries);
8308         p->sq_off.flags = offsetof(struct io_rings, sq_flags);
8309         p->sq_off.dropped = offsetof(struct io_rings, sq_dropped);
8310         p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings;
8311
8312         memset(&p->cq_off, 0, sizeof(p->cq_off));
8313         p->cq_off.head = offsetof(struct io_rings, cq.head);
8314         p->cq_off.tail = offsetof(struct io_rings, cq.tail);
8315         p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask);
8316         p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries);
8317         p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
8318         p->cq_off.cqes = offsetof(struct io_rings, cqes);
8319         p->cq_off.flags = offsetof(struct io_rings, cq_flags);
8320
8321         p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
8322                         IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
8323                         IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL |
8324                         IORING_FEAT_POLL_32BITS;
8325
8326         if (copy_to_user(params, p, sizeof(*p))) {
8327                 ret = -EFAULT;
8328                 goto err;
8329         }
8330         /*
8331          * Install ring fd as the very last thing, so we don't risk someone
8332          * having closed it before we finish setup
8333          */
8334         ret = io_uring_get_fd(ctx);
8335         if (ret < 0)
8336                 goto err;
8337
8338         trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
8339         io_account_mem(ctx, ring_pages(p->sq_entries, p->cq_entries),
8340                        ACCT_LOCKED);
8341         ctx->limit_mem = limit_mem;
8342         return ret;
8343 err:
8344         io_ring_ctx_wait_and_kill(ctx);
8345         return ret;
8346 }
8347
8348 /*
8349  * Sets up an aio uring context, and returns the fd. Applications asks for a
8350  * ring size, we return the actual sq/cq ring sizes (among other things) in the
8351  * params structure passed in.
8352  */
8353 static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
8354 {
8355         struct io_uring_params p;
8356         int i;
8357
8358         if (copy_from_user(&p, params, sizeof(p)))
8359                 return -EFAULT;
8360         for (i = 0; i < ARRAY_SIZE(p.resv); i++) {
8361                 if (p.resv[i])
8362                         return -EINVAL;
8363         }
8364
8365         if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
8366                         IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE |
8367                         IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ))
8368                 return -EINVAL;
8369
8370         return  io_uring_create(entries, &p, params);
8371 }
8372
8373 SYSCALL_DEFINE2(io_uring_setup, u32, entries,
8374                 struct io_uring_params __user *, params)
8375 {
8376         return io_uring_setup(entries, params);
8377 }
8378
8379 static int io_probe(struct io_ring_ctx *ctx, void __user *arg, unsigned nr_args)
8380 {
8381         struct io_uring_probe *p;
8382         size_t size;
8383         int i, ret;
8384
8385         size = struct_size(p, ops, nr_args);
8386         if (size == SIZE_MAX)
8387                 return -EOVERFLOW;
8388         p = kzalloc(size, GFP_KERNEL);
8389         if (!p)
8390                 return -ENOMEM;
8391
8392         ret = -EFAULT;
8393         if (copy_from_user(p, arg, size))
8394                 goto out;
8395         ret = -EINVAL;
8396         if (memchr_inv(p, 0, size))
8397                 goto out;
8398
8399         p->last_op = IORING_OP_LAST - 1;
8400         if (nr_args > IORING_OP_LAST)
8401                 nr_args = IORING_OP_LAST;
8402
8403         for (i = 0; i < nr_args; i++) {
8404                 p->ops[i].op = i;
8405                 if (!io_op_defs[i].not_supported)
8406                         p->ops[i].flags = IO_URING_OP_SUPPORTED;
8407         }
8408         p->ops_len = i;
8409
8410         ret = 0;
8411         if (copy_to_user(arg, p, size))
8412                 ret = -EFAULT;
8413 out:
8414         kfree(p);
8415         return ret;
8416 }
8417
8418 static int io_register_personality(struct io_ring_ctx *ctx)
8419 {
8420         const struct cred *creds = get_current_cred();
8421         int id;
8422
8423         id = idr_alloc_cyclic(&ctx->personality_idr, (void *) creds, 1,
8424                                 USHRT_MAX, GFP_KERNEL);
8425         if (id < 0)
8426                 put_cred(creds);
8427         return id;
8428 }
8429
8430 static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id)
8431 {
8432         const struct cred *old_creds;
8433
8434         old_creds = idr_remove(&ctx->personality_idr, id);
8435         if (old_creds) {
8436                 put_cred(old_creds);
8437                 return 0;
8438         }
8439
8440         return -EINVAL;
8441 }
8442
8443 static bool io_register_op_must_quiesce(int op)
8444 {
8445         switch (op) {
8446         case IORING_UNREGISTER_FILES:
8447         case IORING_REGISTER_FILES_UPDATE:
8448         case IORING_REGISTER_PROBE:
8449         case IORING_REGISTER_PERSONALITY:
8450         case IORING_UNREGISTER_PERSONALITY:
8451                 return false;
8452         default:
8453                 return true;
8454         }
8455 }
8456
8457 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
8458                                void __user *arg, unsigned nr_args)
8459         __releases(ctx->uring_lock)
8460         __acquires(ctx->uring_lock)
8461 {
8462         int ret;
8463
8464         /*
8465          * We're inside the ring mutex, if the ref is already dying, then
8466          * someone else killed the ctx or is already going through
8467          * io_uring_register().
8468          */
8469         if (percpu_ref_is_dying(&ctx->refs))
8470                 return -ENXIO;
8471
8472         if (io_register_op_must_quiesce(opcode)) {
8473                 percpu_ref_kill(&ctx->refs);
8474
8475                 /*
8476                  * Drop uring mutex before waiting for references to exit. If
8477                  * another thread is currently inside io_uring_enter() it might
8478                  * need to grab the uring_lock to make progress. If we hold it
8479                  * here across the drain wait, then we can deadlock. It's safe
8480                  * to drop the mutex here, since no new references will come in
8481                  * after we've killed the percpu ref.
8482                  */
8483                 mutex_unlock(&ctx->uring_lock);
8484                 ret = wait_for_completion_interruptible(&ctx->ref_comp);
8485                 mutex_lock(&ctx->uring_lock);
8486                 if (ret) {
8487                         percpu_ref_resurrect(&ctx->refs);
8488                         ret = -EINTR;
8489                         goto out;
8490                 }
8491         }
8492
8493         switch (opcode) {
8494         case IORING_REGISTER_BUFFERS:
8495                 ret = io_sqe_buffer_register(ctx, arg, nr_args);
8496                 break;
8497         case IORING_UNREGISTER_BUFFERS:
8498                 ret = -EINVAL;
8499                 if (arg || nr_args)
8500                         break;
8501                 ret = io_sqe_buffer_unregister(ctx);
8502                 break;
8503         case IORING_REGISTER_FILES:
8504                 ret = io_sqe_files_register(ctx, arg, nr_args);
8505                 break;
8506         case IORING_UNREGISTER_FILES:
8507                 ret = -EINVAL;
8508                 if (arg || nr_args)
8509                         break;
8510                 ret = io_sqe_files_unregister(ctx);
8511                 break;
8512         case IORING_REGISTER_FILES_UPDATE:
8513                 ret = io_sqe_files_update(ctx, arg, nr_args);
8514                 break;
8515         case IORING_REGISTER_EVENTFD:
8516         case IORING_REGISTER_EVENTFD_ASYNC:
8517                 ret = -EINVAL;
8518                 if (nr_args != 1)
8519                         break;
8520                 ret = io_eventfd_register(ctx, arg);
8521                 if (ret)
8522                         break;
8523                 if (opcode == IORING_REGISTER_EVENTFD_ASYNC)
8524                         ctx->eventfd_async = 1;
8525                 else
8526                         ctx->eventfd_async = 0;
8527                 break;
8528         case IORING_UNREGISTER_EVENTFD:
8529                 ret = -EINVAL;
8530                 if (arg || nr_args)
8531                         break;
8532                 ret = io_eventfd_unregister(ctx);
8533                 break;
8534         case IORING_REGISTER_PROBE:
8535                 ret = -EINVAL;
8536                 if (!arg || nr_args > 256)
8537                         break;
8538                 ret = io_probe(ctx, arg, nr_args);
8539                 break;
8540         case IORING_REGISTER_PERSONALITY:
8541                 ret = -EINVAL;
8542                 if (arg || nr_args)
8543                         break;
8544                 ret = io_register_personality(ctx);
8545                 break;
8546         case IORING_UNREGISTER_PERSONALITY:
8547                 ret = -EINVAL;
8548                 if (arg)
8549                         break;
8550                 ret = io_unregister_personality(ctx, nr_args);
8551                 break;
8552         default:
8553                 ret = -EINVAL;
8554                 break;
8555         }
8556
8557         if (io_register_op_must_quiesce(opcode)) {
8558                 /* bring the ctx back to life */
8559                 percpu_ref_reinit(&ctx->refs);
8560 out:
8561                 reinit_completion(&ctx->ref_comp);
8562         }
8563         return ret;
8564 }
8565
8566 SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
8567                 void __user *, arg, unsigned int, nr_args)
8568 {
8569         struct io_ring_ctx *ctx;
8570         long ret = -EBADF;
8571         struct fd f;
8572
8573         f = fdget(fd);
8574         if (!f.file)
8575                 return -EBADF;
8576
8577         ret = -EOPNOTSUPP;
8578         if (f.file->f_op != &io_uring_fops)
8579                 goto out_fput;
8580
8581         ctx = f.file->private_data;
8582
8583         mutex_lock(&ctx->uring_lock);
8584         ret = __io_uring_register(ctx, opcode, arg, nr_args);
8585         mutex_unlock(&ctx->uring_lock);
8586         trace_io_uring_register(ctx, opcode, ctx->nr_user_files, ctx->nr_user_bufs,
8587                                                         ctx->cq_ev_fd != NULL, ret);
8588 out_fput:
8589         fdput(f);
8590         return ret;
8591 }
8592
8593 static int __init io_uring_init(void)
8594 {
8595 #define __BUILD_BUG_VERIFY_ELEMENT(stype, eoffset, etype, ename) do { \
8596         BUILD_BUG_ON(offsetof(stype, ename) != eoffset); \
8597         BUILD_BUG_ON(sizeof(etype) != sizeof_field(stype, ename)); \
8598 } while (0)
8599
8600 #define BUILD_BUG_SQE_ELEM(eoffset, etype, ename) \
8601         __BUILD_BUG_VERIFY_ELEMENT(struct io_uring_sqe, eoffset, etype, ename)
8602         BUILD_BUG_ON(sizeof(struct io_uring_sqe) != 64);
8603         BUILD_BUG_SQE_ELEM(0,  __u8,   opcode);
8604         BUILD_BUG_SQE_ELEM(1,  __u8,   flags);
8605         BUILD_BUG_SQE_ELEM(2,  __u16,  ioprio);
8606         BUILD_BUG_SQE_ELEM(4,  __s32,  fd);
8607         BUILD_BUG_SQE_ELEM(8,  __u64,  off);
8608         BUILD_BUG_SQE_ELEM(8,  __u64,  addr2);
8609         BUILD_BUG_SQE_ELEM(16, __u64,  addr);
8610         BUILD_BUG_SQE_ELEM(16, __u64,  splice_off_in);
8611         BUILD_BUG_SQE_ELEM(24, __u32,  len);
8612         BUILD_BUG_SQE_ELEM(28,     __kernel_rwf_t, rw_flags);
8613         BUILD_BUG_SQE_ELEM(28, /* compat */   int, rw_flags);
8614         BUILD_BUG_SQE_ELEM(28, /* compat */ __u32, rw_flags);
8615         BUILD_BUG_SQE_ELEM(28, __u32,  fsync_flags);
8616         BUILD_BUG_SQE_ELEM(28, /* compat */ __u16,  poll_events);
8617         BUILD_BUG_SQE_ELEM(28, __u32,  poll32_events);
8618         BUILD_BUG_SQE_ELEM(28, __u32,  sync_range_flags);
8619         BUILD_BUG_SQE_ELEM(28, __u32,  msg_flags);
8620         BUILD_BUG_SQE_ELEM(28, __u32,  timeout_flags);
8621         BUILD_BUG_SQE_ELEM(28, __u32,  accept_flags);
8622         BUILD_BUG_SQE_ELEM(28, __u32,  cancel_flags);
8623         BUILD_BUG_SQE_ELEM(28, __u32,  open_flags);
8624         BUILD_BUG_SQE_ELEM(28, __u32,  statx_flags);
8625         BUILD_BUG_SQE_ELEM(28, __u32,  fadvise_advice);
8626         BUILD_BUG_SQE_ELEM(28, __u32,  splice_flags);
8627         BUILD_BUG_SQE_ELEM(32, __u64,  user_data);
8628         BUILD_BUG_SQE_ELEM(40, __u16,  buf_index);
8629         BUILD_BUG_SQE_ELEM(42, __u16,  personality);
8630         BUILD_BUG_SQE_ELEM(44, __s32,  splice_fd_in);
8631
8632         BUILD_BUG_ON(ARRAY_SIZE(io_op_defs) != IORING_OP_LAST);
8633         BUILD_BUG_ON(__REQ_F_LAST_BIT >= 8 * sizeof(int));
8634         req_cachep = KMEM_CACHE(io_kiocb, SLAB_HWCACHE_ALIGN | SLAB_PANIC);
8635         return 0;
8636 };
8637 __initcall(io_uring_init);