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