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