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