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