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