fs/io_uring.c

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