fs/io_uring.c

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