io_uring.c 115.8 KB
Newer Older
J
Jens Axboe 已提交
1 2 3 4 5 6
// SPDX-License-Identifier: GPL-2.0
/*
 * Shared application/kernel submission and completion ring pairs, for
 * supporting fast/efficient IO.
 *
 * A note on the read/write ordering memory barriers that are matched between
S
Stefan Bühler 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * the application and kernel side.
 *
 * After the application reads the CQ ring tail, it must use an
 * appropriate smp_rmb() to pair with the smp_wmb() the kernel uses
 * before writing the tail (using smp_load_acquire to read the tail will
 * do). It also needs a smp_mb() before updating CQ head (ordering the
 * entry load(s) with the head store), pairing with an implicit barrier
 * through a control-dependency in io_get_cqring (smp_store_release to
 * store head will do). Failure to do so could lead to reading invalid
 * CQ entries.
 *
 * Likewise, the application must use an appropriate smp_wmb() before
 * writing the SQ tail (ordering SQ entry stores with the tail store),
 * which pairs with smp_load_acquire in io_get_sqring (smp_store_release
 * to store the tail will do). And it needs a barrier ordering the SQ
 * head load before writing new SQ entries (smp_load_acquire to read
 * head will do).
 *
 * When using the SQ poll thread (IORING_SETUP_SQPOLL), the application
 * needs to check the SQ flags for IORING_SQ_NEED_WAKEUP *after*
 * updating the SQ tail; a full memory barrier smp_mb() is needed
 * between.
J
Jens Axboe 已提交
29 30 31 32 33 34 35 36 37 38 39
 *
 * Also see the examples in the liburing library:
 *
 *	git://git.kernel.dk/liburing
 *
 * io_uring also uses READ/WRITE_ONCE() for _any_ store or load that happens
 * from data shared between the kernel and application. This is done both
 * for ordering purposes, but also to ensure that once a value is loaded from
 * data that the application could potentially modify, it remains stable.
 *
 * Copyright (C) 2018-2019 Jens Axboe
C
Christoph Hellwig 已提交
40
 * Copyright (c) 2018-2019 Christoph Hellwig
J
Jens Axboe 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/syscalls.h>
#include <linux/compat.h>
#include <linux/refcount.h>
#include <linux/uio.h>

#include <linux/sched/signal.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/fdtable.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/mmu_context.h>
#include <linux/percpu.h>
#include <linux/slab.h>
J
Jens Axboe 已提交
59
#include <linux/kthread.h>
J
Jens Axboe 已提交
60
#include <linux/blkdev.h>
61
#include <linux/bvec.h>
J
Jens Axboe 已提交
62 63 64
#include <linux/net.h>
#include <net/sock.h>
#include <net/af_unix.h>
J
Jens Axboe 已提交
65
#include <net/scm.h>
J
Jens Axboe 已提交
66 67 68 69
#include <linux/anon_inodes.h>
#include <linux/sched/mm.h>
#include <linux/uaccess.h>
#include <linux/nospec.h>
70 71
#include <linux/sizes.h>
#include <linux/hugetlb.h>
J
Jens Axboe 已提交
72

73 74 75
#define CREATE_TRACE_POINTS
#include <trace/events/io_uring.h>

J
Jens Axboe 已提交
76 77 78
#include <uapi/linux/io_uring.h>

#include "internal.h"
79
#include "io-wq.h"
J
Jens Axboe 已提交
80

81
#define IORING_MAX_ENTRIES	32768
82
#define IORING_MAX_CQ_ENTRIES	(2 * IORING_MAX_ENTRIES)
83 84 85 86 87 88 89 90

/*
 * Shift of 9 is 512 entries, or exactly one page on 64-bit archs
 */
#define IORING_FILE_TABLE_SHIFT	9
#define IORING_MAX_FILES_TABLE	(1U << IORING_FILE_TABLE_SHIFT)
#define IORING_FILE_TABLE_MASK	(IORING_MAX_FILES_TABLE - 1)
#define IORING_MAX_FIXED_FILES	(64 * IORING_MAX_FILES_TABLE)
J
Jens Axboe 已提交
91 92 93 94 95 96

struct io_uring {
	u32 head ____cacheline_aligned_in_smp;
	u32 tail ____cacheline_aligned_in_smp;
};

S
Stefan Bühler 已提交
97
/*
98 99
 * This data is shared with the application through the mmap at offsets
 * IORING_OFF_SQ_RING and IORING_OFF_CQ_RING.
S
Stefan Bühler 已提交
100 101 102 103
 *
 * The offsets to the member fields are published through struct
 * io_sqring_offsets when calling io_uring_setup.
 */
104
struct io_rings {
S
Stefan Bühler 已提交
105 106 107 108
	/*
	 * Head and tail offsets into the ring; the offsets need to be
	 * masked to get valid indices.
	 *
109 110 111
	 * The kernel controls head of the sq ring and the tail of the cq ring,
	 * and the application controls tail of the sq ring and the head of the
	 * cq ring.
S
Stefan Bühler 已提交
112
	 */
113
	struct io_uring		sq, cq;
S
Stefan Bühler 已提交
114
	/*
115
	 * Bitmasks to apply to head and tail offsets (constant, equals
S
Stefan Bühler 已提交
116 117
	 * ring_entries - 1)
	 */
118 119 120
	u32			sq_ring_mask, cq_ring_mask;
	/* Ring sizes (constant, power of 2) */
	u32			sq_ring_entries, cq_ring_entries;
S
Stefan Bühler 已提交
121 122 123 124 125 126 127 128 129 130 131 132
	/*
	 * Number of invalid entries dropped by the kernel due to
	 * invalid index stored in array
	 *
	 * Written by the kernel, shouldn't be modified by the
	 * application (i.e. get number of "new events" by comparing to
	 * cached value).
	 *
	 * After a new SQ head value was read by the application this
	 * counter includes all submissions that were dropped reaching
	 * the new SQ head (and possibly more).
	 */
133
	u32			sq_dropped;
S
Stefan Bühler 已提交
134 135 136 137 138 139 140 141 142
	/*
	 * Runtime flags
	 *
	 * Written by the kernel, shouldn't be modified by the
	 * application.
	 *
	 * The application needs a full memory barrier before checking
	 * for IORING_SQ_NEED_WAKEUP after updating the sq tail.
	 */
143
	u32			sq_flags;
S
Stefan Bühler 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156
	/*
	 * Number of completion events lost because the queue was full;
	 * this should be avoided by the application by making sure
	 * there are not more requests pending thatn there is space in
	 * the completion queue.
	 *
	 * Written by the kernel, shouldn't be modified by the
	 * application (i.e. get number of "new events" by comparing to
	 * cached value).
	 *
	 * As completion events come in out of order this counter is not
	 * ordered with any other data.
	 */
157
	u32			cq_overflow;
S
Stefan Bühler 已提交
158 159 160 161 162 163 164
	/*
	 * Ring buffer of completion events.
	 *
	 * The kernel writes completion events fresh every time they are
	 * produced, so the application is allowed to modify pending
	 * entries.
	 */
165
	struct io_uring_cqe	cqes[] ____cacheline_aligned_in_smp;
J
Jens Axboe 已提交
166 167
};

168 169 170 171 172 173 174
struct io_mapped_ubuf {
	u64		ubuf;
	size_t		len;
	struct		bio_vec *bvec;
	unsigned int	nr_bvecs;
};

175 176
struct fixed_file_table {
	struct file		**files;
177 178
};

J
Jens Axboe 已提交
179 180 181 182 183 184 185 186 187
struct io_ring_ctx {
	struct {
		struct percpu_ref	refs;
	} ____cacheline_aligned_in_smp;

	struct {
		unsigned int		flags;
		bool			compat;
		bool			account_mem;
188
		bool			cq_overflow_flushed;
J
Jens Axboe 已提交
189

190 191 192 193 194 195 196 197 198 199 200 201
		/*
		 * Ring buffer of indices into array of io_uring_sqe, which is
		 * mmapped by the application using the IORING_OFF_SQES offset.
		 *
		 * This indirection could e.g. be used to assign fixed
		 * io_uring_sqe entries to operations and only submit them to
		 * the queue when needed.
		 *
		 * The kernel modifies neither the indices array nor the entries
		 * array.
		 */
		u32			*sq_array;
J
Jens Axboe 已提交
202 203 204
		unsigned		cached_sq_head;
		unsigned		sq_entries;
		unsigned		sq_mask;
J
Jens Axboe 已提交
205
		unsigned		sq_thread_idle;
206
		unsigned		cached_sq_dropped;
207
		atomic_t		cached_cq_overflow;
J
Jens Axboe 已提交
208
		struct io_uring_sqe	*sq_sqes;
209 210

		struct list_head	defer_list;
J
Jens Axboe 已提交
211
		struct list_head	timeout_list;
212
		struct list_head	cq_overflow_list;
213 214

		wait_queue_head_t	inflight_wait;
J
Jens Axboe 已提交
215 216
	} ____cacheline_aligned_in_smp;

217 218
	struct io_rings	*rings;

J
Jens Axboe 已提交
219
	/* IO offload */
220
	struct io_wq		*io_wq;
J
Jens Axboe 已提交
221
	struct task_struct	*sqo_thread;	/* if using sq thread polling */
J
Jens Axboe 已提交
222
	struct mm_struct	*sqo_mm;
J
Jens Axboe 已提交
223
	wait_queue_head_t	sqo_wait;
224

J
Jens Axboe 已提交
225 226 227 228 229
	/*
	 * If used, fixed file set. Writers must ensure that ->refs is dead,
	 * readers must ensure that ->refs is alive as long as the file* is
	 * used. Only updated through io_uring_register(2).
	 */
230
	struct fixed_file_table	*file_table;
J
Jens Axboe 已提交
231 232
	unsigned		nr_user_files;

233 234 235 236
	/* if used, fixed mapped user buffers */
	unsigned		nr_user_bufs;
	struct io_mapped_ubuf	*user_bufs;

J
Jens Axboe 已提交
237 238
	struct user_struct	*user;

239 240 241
	/* 0 is for ctx quiesce/reinit/free, 1 is for sqo_thread started */
	struct completion	*completions;

242 243 244
	/* if all else fails... */
	struct io_kiocb		*fallback_req;

245 246 247 248 249 250 251 252 253 254 255 256 257
#if defined(CONFIG_UNIX)
	struct socket		*ring_sock;
#endif

	struct {
		unsigned		cached_cq_tail;
		unsigned		cq_entries;
		unsigned		cq_mask;
		atomic_t		cq_timeouts;
		struct wait_queue_head	cq_wait;
		struct fasync_struct	*cq_fasync;
		struct eventfd_ctx	*cq_ev_fd;
	} ____cacheline_aligned_in_smp;
J
Jens Axboe 已提交
258 259 260 261 262 263 264 265

	struct {
		struct mutex		uring_lock;
		wait_queue_head_t	wait;
	} ____cacheline_aligned_in_smp;

	struct {
		spinlock_t		completion_lock;
J
Jens Axboe 已提交
266 267 268 269 270 271 272 273
		bool			poll_multi_file;
		/*
		 * ->poll_list is protected by the ctx->uring_lock for
		 * io_uring instances that don't use IORING_SETUP_SQPOLL.
		 * For SQPOLL, only the single threaded io_sq_thread() will
		 * manipulate the list, hence no extra locking is needed there.
		 */
		struct list_head	poll_list;
274
		struct rb_root		cancel_tree;
275

276 277
		spinlock_t		inflight_lock;
		struct list_head	inflight_list;
J
Jens Axboe 已提交
278 279 280 281 282
	} ____cacheline_aligned_in_smp;
};

struct sqe_submit {
	const struct io_uring_sqe	*sqe;
283 284
	struct file			*ring_file;
	int				ring_fd;
285
	u32				sequence;
J
Jens Axboe 已提交
286
	bool				has_user;
287
	bool				in_async;
J
Jens Axboe 已提交
288
	bool				needs_fixed_file;
J
Jens Axboe 已提交
289 290
};

J
Jens Axboe 已提交
291 292 293 294
/*
 * First field must be the file pointer in all the
 * iocb unions! See also 'struct kiocb' in <linux/fs.h>
 */
295 296 297 298
struct io_poll_iocb {
	struct file			*file;
	struct wait_queue_head		*head;
	__poll_t			events;
J
Jens Axboe 已提交
299
	bool				done;
300 301 302 303
	bool				canceled;
	struct wait_queue_entry		wait;
};

J
Jens Axboe 已提交
304 305 306 307 308
struct io_timeout {
	struct file			*file;
	struct hrtimer			timer;
};

J
Jens Axboe 已提交
309 310 311 312 313 314
/*
 * NOTE! Each of the iocb union members has the file pointer
 * as the first entry in their struct definition. So you can
 * access the file pointer through any of the sub-structs,
 * or directly as just 'ki_filp' in this struct.
 */
J
Jens Axboe 已提交
315
struct io_kiocb {
316
	union {
J
Jens Axboe 已提交
317
		struct file		*file;
318 319
		struct kiocb		rw;
		struct io_poll_iocb	poll;
J
Jens Axboe 已提交
320
		struct io_timeout	timeout;
321
	};
J
Jens Axboe 已提交
322 323 324 325

	struct sqe_submit	submit;

	struct io_ring_ctx	*ctx;
326 327 328 329
	union {
		struct list_head	list;
		struct rb_node		rb_node;
	};
J
Jens Axboe 已提交
330
	struct list_head	link_list;
J
Jens Axboe 已提交
331
	unsigned int		flags;
J
Jens Axboe 已提交
332
	refcount_t		refs;
333
#define REQ_F_NOWAIT		1	/* must not punt to workers */
J
Jens Axboe 已提交
334
#define REQ_F_IOPOLL_COMPLETED	2	/* polled IO has completed */
J
Jens Axboe 已提交
335
#define REQ_F_FIXED_FILE	4	/* ctx owns file */
336
#define REQ_F_SEQ_PREV		8	/* sequential with previous */
337 338
#define REQ_F_IO_DRAIN		16	/* drain existing IO first */
#define REQ_F_IO_DRAINED	32	/* drain done */
J
Jens Axboe 已提交
339
#define REQ_F_LINK		64	/* linked sqes */
340
#define REQ_F_LINK_TIMEOUT	128	/* has linked timeout */
341
#define REQ_F_FAIL_LINK		256	/* fail rest of links */
342
#define REQ_F_SHADOW_DRAIN	512	/* link-drain shadow req */
J
Jens Axboe 已提交
343
#define REQ_F_TIMEOUT		1024	/* timeout request */
344 345
#define REQ_F_ISREG		2048	/* regular file */
#define REQ_F_MUST_PUNT		4096	/* must be punted even for NONBLOCK */
346
#define REQ_F_TIMEOUT_NOSEQ	8192	/* no timeout sequence */
347 348
#define REQ_F_INFLIGHT		16384	/* on inflight list */
#define REQ_F_COMP_LOCKED	32768	/* completion under lock */
J
Jens Axboe 已提交
349
	u64			user_data;
J
Jens Axboe 已提交
350
	u32			result;
351
	u32			sequence;
J
Jens Axboe 已提交
352

353 354
	struct list_head	inflight_entry;

355
	struct io_wq_work	work;
J
Jens Axboe 已提交
356 357 358
};

#define IO_PLUG_THRESHOLD		2
J
Jens Axboe 已提交
359
#define IO_IOPOLL_BATCH			8
J
Jens Axboe 已提交
360

361 362 363
struct io_submit_state {
	struct blk_plug		plug;

J
Jens Axboe 已提交
364 365 366 367 368 369 370
	/*
	 * io_kiocb alloc cache
	 */
	void			*reqs[IO_IOPOLL_BATCH];
	unsigned		int free_reqs;
	unsigned		int cur_req;

371 372 373 374 375 376 377 378 379 380
	/*
	 * File reference cache
	 */
	struct file		*file;
	unsigned int		fd;
	unsigned int		has_refs;
	unsigned int		used_refs;
	unsigned int		ios_left;
};

381
static void io_wq_submit_work(struct io_wq_work **workptr);
382
static void io_cqring_fill_event(struct io_kiocb *req, long res);
383
static void __io_free_req(struct io_kiocb *req);
384
static void io_put_req(struct io_kiocb *req);
385
static void io_double_put_req(struct io_kiocb *req);
386

J
Jens Axboe 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
static struct kmem_cache *req_cachep;

static const struct file_operations io_uring_fops;

struct sock *io_uring_get_socket(struct file *file)
{
#if defined(CONFIG_UNIX)
	if (file->f_op == &io_uring_fops) {
		struct io_ring_ctx *ctx = file->private_data;

		return ctx->ring_sock->sk;
	}
#endif
	return NULL;
}
EXPORT_SYMBOL(io_uring_get_socket);

static void io_ring_ctx_ref_free(struct percpu_ref *ref)
{
	struct io_ring_ctx *ctx = container_of(ref, struct io_ring_ctx, refs);

408
	complete(&ctx->completions[0]);
J
Jens Axboe 已提交
409 410 411 412 413 414 415 416 417 418
}

static struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
{
	struct io_ring_ctx *ctx;

	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return NULL;

419 420 421 422
	ctx->fallback_req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
	if (!ctx->fallback_req)
		goto err;

423 424 425 426
	ctx->completions = kmalloc(2 * sizeof(struct completion), GFP_KERNEL);
	if (!ctx->completions)
		goto err;

427
	if (percpu_ref_init(&ctx->refs, io_ring_ctx_ref_free,
428 429
			    PERCPU_REF_ALLOW_REINIT, GFP_KERNEL))
		goto err;
J
Jens Axboe 已提交
430 431 432

	ctx->flags = p->flags;
	init_waitqueue_head(&ctx->cq_wait);
433
	INIT_LIST_HEAD(&ctx->cq_overflow_list);
434 435
	init_completion(&ctx->completions[0]);
	init_completion(&ctx->completions[1]);
J
Jens Axboe 已提交
436 437 438
	mutex_init(&ctx->uring_lock);
	init_waitqueue_head(&ctx->wait);
	spin_lock_init(&ctx->completion_lock);
J
Jens Axboe 已提交
439
	INIT_LIST_HEAD(&ctx->poll_list);
440
	ctx->cancel_tree = RB_ROOT;
441
	INIT_LIST_HEAD(&ctx->defer_list);
J
Jens Axboe 已提交
442
	INIT_LIST_HEAD(&ctx->timeout_list);
443 444 445
	init_waitqueue_head(&ctx->inflight_wait);
	spin_lock_init(&ctx->inflight_lock);
	INIT_LIST_HEAD(&ctx->inflight_list);
J
Jens Axboe 已提交
446
	return ctx;
447
err:
448 449
	if (ctx->fallback_req)
		kmem_cache_free(req_cachep, ctx->fallback_req);
450 451 452
	kfree(ctx->completions);
	kfree(ctx);
	return NULL;
J
Jens Axboe 已提交
453 454
}

B
Bob Liu 已提交
455
static inline bool __req_need_defer(struct io_kiocb *req)
456
{
457 458
	struct io_ring_ctx *ctx = req->ctx;

459 460
	return req->sequence != ctx->cached_cq_tail + ctx->cached_sq_dropped
					+ atomic_read(&ctx->cached_cq_overflow);
461 462
}

B
Bob Liu 已提交
463
static inline bool req_need_defer(struct io_kiocb *req)
464
{
B
Bob Liu 已提交
465 466
	if ((req->flags & (REQ_F_IO_DRAIN|REQ_F_IO_DRAINED)) == REQ_F_IO_DRAIN)
		return __req_need_defer(req);
467

B
Bob Liu 已提交
468
	return false;
469 470
}

471
static struct io_kiocb *io_get_deferred_req(struct io_ring_ctx *ctx)
472 473 474
{
	struct io_kiocb *req;

475
	req = list_first_entry_or_null(&ctx->defer_list, struct io_kiocb, list);
B
Bob Liu 已提交
476
	if (req && !req_need_defer(req)) {
477 478 479 480 481 482 483
		list_del_init(&req->list);
		return req;
	}

	return NULL;
}

J
Jens Axboe 已提交
484 485
static struct io_kiocb *io_get_timeout_req(struct io_ring_ctx *ctx)
{
486 487 488
	struct io_kiocb *req;

	req = list_first_entry_or_null(&ctx->timeout_list, struct io_kiocb, list);
489 490 491
	if (req) {
		if (req->flags & REQ_F_TIMEOUT_NOSEQ)
			return NULL;
492
		if (!__req_need_defer(req)) {
493 494 495
			list_del_init(&req->list);
			return req;
		}
496 497 498
	}

	return NULL;
J
Jens Axboe 已提交
499 500
}

501
static void __io_commit_cqring(struct io_ring_ctx *ctx)
J
Jens Axboe 已提交
502
{
503
	struct io_rings *rings = ctx->rings;
J
Jens Axboe 已提交
504

505
	if (ctx->cached_cq_tail != READ_ONCE(rings->cq.tail)) {
J
Jens Axboe 已提交
506
		/* order cqe stores with ring update */
507
		smp_store_release(&rings->cq.tail, ctx->cached_cq_tail);
J
Jens Axboe 已提交
508 509 510 511 512 513 514 515

		if (wq_has_sleeper(&ctx->cq_wait)) {
			wake_up_interruptible(&ctx->cq_wait);
			kill_fasync(&ctx->cq_fasync, SIGIO, POLL_IN);
		}
	}
}

516
static inline bool io_sqe_needs_user(const struct io_uring_sqe *sqe)
517
{
518 519 520 521 522 523 524
	u8 opcode = READ_ONCE(sqe->opcode);

	return !(opcode == IORING_OP_READ_FIXED ||
		 opcode == IORING_OP_WRITE_FIXED);
}

static inline bool io_prep_async_work(struct io_kiocb *req)
525
{
526
	bool do_hashed = false;
527

528 529 530 531
	if (req->submit.sqe) {
		switch (req->submit.sqe->opcode) {
		case IORING_OP_WRITEV:
		case IORING_OP_WRITE_FIXED:
532
			do_hashed = true;
533 534 535 536 537 538 539 540 541 542 543 544 545 546
			/* fall-through */
		case IORING_OP_READV:
		case IORING_OP_READ_FIXED:
		case IORING_OP_SENDMSG:
		case IORING_OP_RECVMSG:
		case IORING_OP_ACCEPT:
		case IORING_OP_POLL_ADD:
			/*
			 * We know REQ_F_ISREG is not set on some of these
			 * opcodes, but this enables us to keep the check in
			 * just one place.
			 */
			if (!(req->flags & REQ_F_ISREG))
				req->work.flags |= IO_WQ_WORK_UNBOUND;
547 548
			break;
		}
549 550
		if (io_sqe_needs_user(req->submit.sqe))
			req->work.flags |= IO_WQ_WORK_NEEDS_USER;
551 552
	}

553 554 555
	return do_hashed;
}

556
static inline void io_queue_async_work(struct io_kiocb *req)
557 558
{
	bool do_hashed = io_prep_async_work(req);
559
	struct io_ring_ctx *ctx = req->ctx;
560 561 562 563 564 565 566 567 568

	trace_io_uring_queue_async_work(ctx, do_hashed, req, &req->work,
					req->flags);
	if (!do_hashed) {
		io_wq_enqueue(ctx->io_wq, &req->work);
	} else {
		io_wq_enqueue_hashed(ctx->io_wq, &req->work,
					file_inode(req->file));
	}
569 570
}

J
Jens Axboe 已提交
571 572 573 574 575 576 577
static void io_kill_timeout(struct io_kiocb *req)
{
	int ret;

	ret = hrtimer_try_to_cancel(&req->timeout.timer);
	if (ret != -1) {
		atomic_inc(&req->ctx->cq_timeouts);
578
		list_del_init(&req->list);
579
		io_cqring_fill_event(req, 0);
580
		io_put_req(req);
J
Jens Axboe 已提交
581 582 583 584 585 586 587 588 589 590 591 592 593
	}
}

static void io_kill_timeouts(struct io_ring_ctx *ctx)
{
	struct io_kiocb *req, *tmp;

	spin_lock_irq(&ctx->completion_lock);
	list_for_each_entry_safe(req, tmp, &ctx->timeout_list, list)
		io_kill_timeout(req);
	spin_unlock_irq(&ctx->completion_lock);
}

594 595 596 597
static void io_commit_cqring(struct io_ring_ctx *ctx)
{
	struct io_kiocb *req;

J
Jens Axboe 已提交
598 599 600
	while ((req = io_get_timeout_req(ctx)) != NULL)
		io_kill_timeout(req);

601 602 603
	__io_commit_cqring(ctx);

	while ((req = io_get_deferred_req(ctx)) != NULL) {
604 605 606 607 608
		if (req->flags & REQ_F_SHADOW_DRAIN) {
			/* Just for drain, free it. */
			__io_free_req(req);
			continue;
		}
609
		req->flags |= REQ_F_IO_DRAINED;
610
		io_queue_async_work(req);
611 612 613
	}
}

J
Jens Axboe 已提交
614 615
static struct io_uring_cqe *io_get_cqring(struct io_ring_ctx *ctx)
{
616
	struct io_rings *rings = ctx->rings;
J
Jens Axboe 已提交
617 618 619
	unsigned tail;

	tail = ctx->cached_cq_tail;
620 621 622 623 624
	/*
	 * writes to the cq entry need to come after reading head; the
	 * control dependency is enough as we're using WRITE_ONCE to
	 * fill the cq entry
	 */
625
	if (tail - READ_ONCE(rings->cq.head) == rings->cq_ring_entries)
J
Jens Axboe 已提交
626 627 628
		return NULL;

	ctx->cached_cq_tail++;
629
	return &rings->cqes[tail & ctx->cq_mask];
J
Jens Axboe 已提交
630 631
}

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
static void io_cqring_ev_posted(struct io_ring_ctx *ctx)
{
	if (waitqueue_active(&ctx->wait))
		wake_up(&ctx->wait);
	if (waitqueue_active(&ctx->sqo_wait))
		wake_up(&ctx->sqo_wait);
	if (ctx->cq_ev_fd)
		eventfd_signal(ctx->cq_ev_fd, 1);
}

static void io_cqring_overflow_flush(struct io_ring_ctx *ctx, bool force)
{
	struct io_rings *rings = ctx->rings;
	struct io_uring_cqe *cqe;
	struct io_kiocb *req;
	unsigned long flags;
	LIST_HEAD(list);

	if (!force) {
		if (list_empty_careful(&ctx->cq_overflow_list))
			return;
		if ((ctx->cached_cq_tail - READ_ONCE(rings->cq.head) ==
		    rings->cq_ring_entries))
			return;
	}

	spin_lock_irqsave(&ctx->completion_lock, flags);

	/* if force is set, the ring is going away. always drop after that */
	if (force)
		ctx->cq_overflow_flushed = true;

	while (!list_empty(&ctx->cq_overflow_list)) {
		cqe = io_get_cqring(ctx);
		if (!cqe && !force)
			break;

		req = list_first_entry(&ctx->cq_overflow_list, struct io_kiocb,
						list);
		list_move(&req->list, &list);
		if (cqe) {
			WRITE_ONCE(cqe->user_data, req->user_data);
			WRITE_ONCE(cqe->res, req->result);
			WRITE_ONCE(cqe->flags, 0);
		} else {
			WRITE_ONCE(ctx->rings->cq_overflow,
				atomic_inc_return(&ctx->cached_cq_overflow));
		}
	}

	io_commit_cqring(ctx);
	spin_unlock_irqrestore(&ctx->completion_lock, flags);
	io_cqring_ev_posted(ctx);

	while (!list_empty(&list)) {
		req = list_first_entry(&list, struct io_kiocb, list);
		list_del(&req->list);
689
		io_put_req(req);
690 691 692
	}
}

693
static void io_cqring_fill_event(struct io_kiocb *req, long res)
J
Jens Axboe 已提交
694
{
695
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
696 697
	struct io_uring_cqe *cqe;

698
	trace_io_uring_complete(ctx, req->user_data, res);
J
Jens Axboe 已提交
699

J
Jens Axboe 已提交
700 701 702 703 704 705
	/*
	 * If we can't get a cq entry, userspace overflowed the
	 * submission (by quite a lot). Increment the overflow count in
	 * the ring.
	 */
	cqe = io_get_cqring(ctx);
706
	if (likely(cqe)) {
707
		WRITE_ONCE(cqe->user_data, req->user_data);
J
Jens Axboe 已提交
708
		WRITE_ONCE(cqe->res, res);
709
		WRITE_ONCE(cqe->flags, 0);
710
	} else if (ctx->cq_overflow_flushed) {
711 712
		WRITE_ONCE(ctx->rings->cq_overflow,
				atomic_inc_return(&ctx->cached_cq_overflow));
713 714 715 716
	} else {
		refcount_inc(&req->refs);
		req->result = res;
		list_add_tail(&req->list, &ctx->cq_overflow_list);
J
Jens Axboe 已提交
717 718 719
	}
}

720
static void io_cqring_add_event(struct io_kiocb *req, long res)
J
Jens Axboe 已提交
721
{
722
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
723 724 725
	unsigned long flags;

	spin_lock_irqsave(&ctx->completion_lock, flags);
726
	io_cqring_fill_event(req, res);
J
Jens Axboe 已提交
727 728 729
	io_commit_cqring(ctx);
	spin_unlock_irqrestore(&ctx->completion_lock, flags);

J
Jens Axboe 已提交
730
	io_cqring_ev_posted(ctx);
J
Jens Axboe 已提交
731 732
}

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
static inline bool io_is_fallback_req(struct io_kiocb *req)
{
	return req == (struct io_kiocb *)
			((unsigned long) req->ctx->fallback_req & ~1UL);
}

static struct io_kiocb *io_get_fallback_req(struct io_ring_ctx *ctx)
{
	struct io_kiocb *req;

	req = ctx->fallback_req;
	if (!test_and_set_bit_lock(0, (unsigned long *) ctx->fallback_req))
		return req;

	return NULL;
}

J
Jens Axboe 已提交
750 751
static struct io_kiocb *io_get_req(struct io_ring_ctx *ctx,
				   struct io_submit_state *state)
J
Jens Axboe 已提交
752
{
753
	gfp_t gfp = GFP_KERNEL | __GFP_NOWARN;
J
Jens Axboe 已提交
754 755 756 757 758
	struct io_kiocb *req;

	if (!percpu_ref_tryget(&ctx->refs))
		return NULL;

J
Jens Axboe 已提交
759
	if (!state) {
760
		req = kmem_cache_alloc(req_cachep, gfp);
J
Jens Axboe 已提交
761
		if (unlikely(!req))
762
			goto fallback;
J
Jens Axboe 已提交
763 764 765 766 767
	} else if (!state->free_reqs) {
		size_t sz;
		int ret;

		sz = min_t(size_t, state->ios_left, ARRAY_SIZE(state->reqs));
768 769 770 771 772 773 774 775 776
		ret = kmem_cache_alloc_bulk(req_cachep, gfp, sz, state->reqs);

		/*
		 * Bulk alloc is all-or-nothing. If we fail to get a batch,
		 * retry single alloc to be on the safe side.
		 */
		if (unlikely(ret <= 0)) {
			state->reqs[0] = kmem_cache_alloc(req_cachep, gfp);
			if (!state->reqs[0])
777
				goto fallback;
778 779
			ret = 1;
		}
J
Jens Axboe 已提交
780 781 782 783 784 785 786
		state->free_reqs = ret - 1;
		state->cur_req = 1;
		req = state->reqs[0];
	} else {
		req = state->reqs[state->cur_req];
		state->free_reqs--;
		state->cur_req++;
J
Jens Axboe 已提交
787 788
	}

789
got_it:
790
	req->file = NULL;
J
Jens Axboe 已提交
791 792
	req->ctx = ctx;
	req->flags = 0;
793 794
	/* one is dropped after submission, the other at completion */
	refcount_set(&req->refs, 2);
J
Jens Axboe 已提交
795
	req->result = 0;
796
	INIT_IO_WORK(&req->work, io_wq_submit_work);
J
Jens Axboe 已提交
797
	return req;
798 799 800 801
fallback:
	req = io_get_fallback_req(ctx);
	if (req)
		goto got_it;
802
	percpu_ref_put(&ctx->refs);
J
Jens Axboe 已提交
803 804 805
	return NULL;
}

J
Jens Axboe 已提交
806 807 808 809
static void io_free_req_many(struct io_ring_ctx *ctx, void **reqs, int *nr)
{
	if (*nr) {
		kmem_cache_free_bulk(req_cachep, *nr, reqs);
810
		percpu_ref_put_many(&ctx->refs, *nr);
J
Jens Axboe 已提交
811 812 813 814
		*nr = 0;
	}
}

J
Jens Axboe 已提交
815
static void __io_free_req(struct io_kiocb *req)
J
Jens Axboe 已提交
816
{
817 818
	struct io_ring_ctx *ctx = req->ctx;

J
Jens Axboe 已提交
819 820
	if (req->file && !(req->flags & REQ_F_FIXED_FILE))
		fput(req->file);
821 822 823 824 825 826 827 828 829 830
	if (req->flags & REQ_F_INFLIGHT) {
		unsigned long flags;

		spin_lock_irqsave(&ctx->inflight_lock, flags);
		list_del(&req->inflight_entry);
		if (waitqueue_active(&ctx->inflight_wait))
			wake_up(&ctx->inflight_wait);
		spin_unlock_irqrestore(&ctx->inflight_lock, flags);
	}
	percpu_ref_put(&ctx->refs);
831 832 833 834
	if (likely(!io_is_fallback_req(req)))
		kmem_cache_free(req_cachep, req);
	else
		clear_bit_unlock(0, (unsigned long *) ctx->fallback_req);
835 836
}

837
static bool io_link_cancel_timeout(struct io_kiocb *req)
838
{
839
	struct io_ring_ctx *ctx = req->ctx;
840 841 842 843
	int ret;

	ret = hrtimer_try_to_cancel(&req->timeout.timer);
	if (ret != -1) {
844
		io_cqring_fill_event(req, -ECANCELED);
845 846
		io_commit_cqring(ctx);
		req->flags &= ~REQ_F_LINK;
847
		io_put_req(req);
848 849 850 851
		return true;
	}

	return false;
852 853
}

854
static void io_req_link_next(struct io_kiocb *req, struct io_kiocb **nxtptr)
J
Jens Axboe 已提交
855
{
856
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
857
	struct io_kiocb *nxt;
858
	bool wake_ev = false;
J
Jens Axboe 已提交
859 860 861 862 863 864 865

	/*
	 * The list should never be empty when we are called here. But could
	 * potentially happen if the chain is messed up, check to be on the
	 * safe side.
	 */
	nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb, list);
866
	while (nxt) {
867
		list_del_init(&nxt->list);
J
Jens Axboe 已提交
868 869 870 871 872 873
		if (!list_empty(&req->link_list)) {
			INIT_LIST_HEAD(&nxt->link_list);
			list_splice(&req->link_list, &nxt->link_list);
			nxt->flags |= REQ_F_LINK;
		}

874 875 876 877
		/*
		 * If we're in async work, we can continue processing the chain
		 * in this context instead of having to queue up new async work.
		 */
878
		if (req->flags & REQ_F_LINK_TIMEOUT) {
879
			wake_ev = io_link_cancel_timeout(nxt);
880 881 882 883

			/* we dropped this link, get next */
			nxt = list_first_entry_or_null(&req->link_list,
							struct io_kiocb, list);
884
		} else if (nxtptr && io_wq_current_is_worker()) {
885
			*nxtptr = nxt;
886 887
			break;
		} else {
888
			io_queue_async_work(nxt);
889 890
			break;
		}
J
Jens Axboe 已提交
891
	}
892 893 894

	if (wake_ev)
		io_cqring_ev_posted(ctx);
J
Jens Axboe 已提交
895 896 897 898 899 900 901
}

/*
 * Called if REQ_F_LINK is set, and we fail the head request
 */
static void io_fail_links(struct io_kiocb *req)
{
902
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
903
	struct io_kiocb *link;
904 905 906
	unsigned long flags;

	spin_lock_irqsave(&ctx->completion_lock, flags);
J
Jens Axboe 已提交
907 908 909

	while (!list_empty(&req->link_list)) {
		link = list_first_entry(&req->link_list, struct io_kiocb, list);
910
		list_del_init(&link->list);
J
Jens Axboe 已提交
911

912
		trace_io_uring_fail_link(req, link);
913 914 915

		if ((req->flags & REQ_F_LINK_TIMEOUT) &&
		    link->submit.sqe->opcode == IORING_OP_LINK_TIMEOUT) {
916
			io_link_cancel_timeout(link);
917
		} else {
918 919
			io_cqring_fill_event(link, -ECANCELED);
			io_double_put_req(link);
920
		}
J
Jens Axboe 已提交
921
	}
922 923 924 925

	io_commit_cqring(ctx);
	spin_unlock_irqrestore(&ctx->completion_lock, flags);
	io_cqring_ev_posted(ctx);
J
Jens Axboe 已提交
926 927
}

928
static void io_free_req_find_next(struct io_kiocb *req, struct io_kiocb **nxt)
J
Jens Axboe 已提交
929
{
930 931 932 933 934
	if (likely(!(req->flags & REQ_F_LINK))) {
		__io_free_req(req);
		return;
	}

J
Jens Axboe 已提交
935 936 937 938 939 940
	/*
	 * If LINK is set, we have dependent requests in this chain. If we
	 * didn't fail this request, queue the first one up, moving any other
	 * dependencies to the next request. In case of failure, fail the rest
	 * of the chain.
	 */
941 942
	if (req->flags & REQ_F_FAIL_LINK) {
		io_fail_links(req);
943 944
	} else if ((req->flags & (REQ_F_LINK_TIMEOUT | REQ_F_COMP_LOCKED)) ==
			REQ_F_LINK_TIMEOUT) {
945 946 947 948 949 950
		struct io_ring_ctx *ctx = req->ctx;
		unsigned long flags;

		/*
		 * If this is a timeout link, we could be racing with the
		 * timeout timer. Grab the completion lock for this case to
951
		 * protect against that.
952 953 954 955 956 957
		 */
		spin_lock_irqsave(&ctx->completion_lock, flags);
		io_req_link_next(req, nxt);
		spin_unlock_irqrestore(&ctx->completion_lock, flags);
	} else {
		io_req_link_next(req, nxt);
J
Jens Axboe 已提交
958 959 960 961 962
	}

	__io_free_req(req);
}

963 964 965 966 967
static void io_free_req(struct io_kiocb *req)
{
	io_free_req_find_next(req, NULL);
}

968 969 970 971
/*
 * Drop reference to request, return next in chain (if there is one) if this
 * was the last reference to this request.
 */
972
static void io_put_req_find_next(struct io_kiocb *req, struct io_kiocb **nxtptr)
973
{
974 975
	struct io_kiocb *nxt = NULL;

976
	if (refcount_dec_and_test(&req->refs))
977
		io_free_req_find_next(req, &nxt);
978 979

	if (nxt) {
980
		if (nxtptr)
981
			*nxtptr = nxt;
982
		else
983
			io_queue_async_work(nxt);
984
	}
J
Jens Axboe 已提交
985 986
}

987 988 989 990
static void io_put_req(struct io_kiocb *req)
{
	if (refcount_dec_and_test(&req->refs))
		io_free_req(req);
J
Jens Axboe 已提交
991 992
}

993 994 995 996 997 998 999
static void io_double_put_req(struct io_kiocb *req)
{
	/* drop both submit and complete references */
	if (refcount_sub_and_test(2, &req->refs))
		__io_free_req(req);
}

1000
static unsigned io_cqring_events(struct io_ring_ctx *ctx, bool noflush)
1001
{
1002 1003
	struct io_rings *rings = ctx->rings;

1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	/*
	 * noflush == true is from the waitqueue handler, just ensure we wake
	 * up the task, and the next invocation will flush the entries. We
	 * cannot safely to it from here.
	 */
	if (noflush && !list_empty(&ctx->cq_overflow_list))
		return -1U;

	io_cqring_overflow_flush(ctx, false);

1014 1015
	/* See comment at the top of this file */
	smp_rmb();
1016
	return READ_ONCE(rings->cq.tail) - READ_ONCE(rings->cq.head);
1017 1018
}

1019 1020 1021 1022 1023 1024 1025 1026
static inline unsigned int io_sqring_entries(struct io_ring_ctx *ctx)
{
	struct io_rings *rings = ctx->rings;

	/* make sure SQ entry isn't read before tail */
	return smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;
}

J
Jens Axboe 已提交
1027 1028 1029 1030 1031 1032 1033 1034
/*
 * Find and free completed poll iocbs
 */
static void io_iopoll_complete(struct io_ring_ctx *ctx, unsigned int *nr_events,
			       struct list_head *done)
{
	void *reqs[IO_IOPOLL_BATCH];
	struct io_kiocb *req;
J
Jens Axboe 已提交
1035
	int to_free;
J
Jens Axboe 已提交
1036

J
Jens Axboe 已提交
1037
	to_free = 0;
J
Jens Axboe 已提交
1038 1039 1040 1041
	while (!list_empty(done)) {
		req = list_first_entry(done, struct io_kiocb, list);
		list_del(&req->list);

1042
		io_cqring_fill_event(req, req->result);
J
Jens Axboe 已提交
1043 1044
		(*nr_events)++;

J
Jens Axboe 已提交
1045 1046 1047 1048
		if (refcount_dec_and_test(&req->refs)) {
			/* If we're not using fixed files, we have to pair the
			 * completion part with the file put. Use regular
			 * completions for those, only batch free for fixed
J
Jens Axboe 已提交
1049
			 * file and non-linked commands.
J
Jens Axboe 已提交
1050
			 */
1051 1052
			if (((req->flags & (REQ_F_FIXED_FILE|REQ_F_LINK)) ==
			    REQ_F_FIXED_FILE) && !io_is_fallback_req(req)) {
J
Jens Axboe 已提交
1053 1054 1055
				reqs[to_free++] = req;
				if (to_free == ARRAY_SIZE(reqs))
					io_free_req_many(ctx, reqs, &to_free);
J
Jens Axboe 已提交
1056
			} else {
J
Jens Axboe 已提交
1057
				io_free_req(req);
J
Jens Axboe 已提交
1058
			}
1059
		}
J
Jens Axboe 已提交
1060 1061
	}

J
Jens Axboe 已提交
1062
	io_commit_cqring(ctx);
J
Jens Axboe 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	io_free_req_many(ctx, reqs, &to_free);
}

static int io_do_iopoll(struct io_ring_ctx *ctx, unsigned int *nr_events,
			long min)
{
	struct io_kiocb *req, *tmp;
	LIST_HEAD(done);
	bool spin;
	int ret;

	/*
	 * Only spin for completions if we don't have multiple devices hanging
	 * off our complete list, and we're under the requested amount.
	 */
	spin = !ctx->poll_multi_file && *nr_events < min;

	ret = 0;
	list_for_each_entry_safe(req, tmp, &ctx->poll_list, list) {
		struct kiocb *kiocb = &req->rw;

		/*
		 * Move completed entries to our local list. If we find a
		 * request that requires polling, break out and complete
		 * the done list first, if we have entries there.
		 */
		if (req->flags & REQ_F_IOPOLL_COMPLETED) {
			list_move_tail(&req->list, &done);
			continue;
		}
		if (!list_empty(&done))
			break;

		ret = kiocb->ki_filp->f_op->iopoll(kiocb, spin);
		if (ret < 0)
			break;

		if (ret && spin)
			spin = false;
		ret = 0;
	}

	if (!list_empty(&done))
		io_iopoll_complete(ctx, nr_events, &done);

	return ret;
}

/*
 * Poll for a mininum of 'min' events. Note that if min == 0 we consider that a
 * non-spinning poll check - we'll still enter the driver poll loop, but only
 * as a non-spinning completion check.
 */
static int io_iopoll_getevents(struct io_ring_ctx *ctx, unsigned int *nr_events,
				long min)
{
1119
	while (!list_empty(&ctx->poll_list) && !need_resched()) {
J
Jens Axboe 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
		int ret;

		ret = io_do_iopoll(ctx, nr_events, min);
		if (ret < 0)
			return ret;
		if (!min || *nr_events >= min)
			return 0;
	}

	return 1;
}

/*
 * We can't just wait for polled events to come to us, we have to actively
 * find and complete them.
 */
static void io_iopoll_reap_events(struct io_ring_ctx *ctx)
{
	if (!(ctx->flags & IORING_SETUP_IOPOLL))
		return;

	mutex_lock(&ctx->uring_lock);
	while (!list_empty(&ctx->poll_list)) {
		unsigned int nr_events = 0;

		io_iopoll_getevents(ctx, &nr_events, 1);
1146 1147 1148 1149 1150 1151

		/*
		 * Ensure we allow local-to-the-cpu processing to take place,
		 * in this case we need to ensure that we reap all events.
		 */
		cond_resched();
J
Jens Axboe 已提交
1152 1153 1154 1155
	}
	mutex_unlock(&ctx->uring_lock);
}

1156 1157
static int __io_iopoll_check(struct io_ring_ctx *ctx, unsigned *nr_events,
			    long min)
J
Jens Axboe 已提交
1158
{
1159
	int iters = 0, ret = 0;
1160

J
Jens Axboe 已提交
1161 1162 1163
	do {
		int tmin = 0;

1164 1165 1166 1167 1168
		/*
		 * Don't enter poll loop if we already have events pending.
		 * If we do, we can potentially be spinning for commands that
		 * already triggered a CQE (eg in error).
		 */
1169
		if (io_cqring_events(ctx, false))
1170 1171
			break;

1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
		/*
		 * If a submit got punted to a workqueue, we can have the
		 * application entering polling for a command before it gets
		 * issued. That app will hold the uring_lock for the duration
		 * of the poll right here, so we need to take a breather every
		 * now and then to ensure that the issue has a chance to add
		 * the poll to the issued list. Otherwise we can spin here
		 * forever, while the workqueue is stuck trying to acquire the
		 * very same mutex.
		 */
		if (!(++iters & 7)) {
			mutex_unlock(&ctx->uring_lock);
			mutex_lock(&ctx->uring_lock);
		}

J
Jens Axboe 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195
		if (*nr_events < min)
			tmin = min - *nr_events;

		ret = io_iopoll_getevents(ctx, nr_events, tmin);
		if (ret <= 0)
			break;
		ret = 0;
	} while (min && !*nr_events && !need_resched());

1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
	return ret;
}

static int io_iopoll_check(struct io_ring_ctx *ctx, unsigned *nr_events,
			   long min)
{
	int ret;

	/*
	 * We disallow the app entering submit/complete with polling, but we
	 * still need to lock the ring to prevent racing with polled issue
	 * that got punted to a workqueue.
	 */
	mutex_lock(&ctx->uring_lock);
	ret = __io_iopoll_check(ctx, nr_events, min);
1211
	mutex_unlock(&ctx->uring_lock);
J
Jens Axboe 已提交
1212 1213 1214
	return ret;
}

1215
static void kiocb_end_write(struct io_kiocb *req)
J
Jens Axboe 已提交
1216
{
1217 1218 1219 1220 1221 1222
	/*
	 * Tell lockdep we inherited freeze protection from submission
	 * thread.
	 */
	if (req->flags & REQ_F_ISREG) {
		struct inode *inode = file_inode(req->file);
J
Jens Axboe 已提交
1223

1224
		__sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
J
Jens Axboe 已提交
1225
	}
1226
	file_end_write(req->file);
J
Jens Axboe 已提交
1227 1228
}

1229
static void io_complete_rw_common(struct kiocb *kiocb, long res)
J
Jens Axboe 已提交
1230 1231 1232
{
	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);

1233 1234
	if (kiocb->ki_flags & IOCB_WRITE)
		kiocb_end_write(req);
J
Jens Axboe 已提交
1235

J
Jens Axboe 已提交
1236 1237
	if ((req->flags & REQ_F_LINK) && res != req->result)
		req->flags |= REQ_F_FAIL_LINK;
1238
	io_cqring_add_event(req, res);
1239 1240 1241 1242 1243 1244 1245
}

static void io_complete_rw(struct kiocb *kiocb, long res, long res2)
{
	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);

	io_complete_rw_common(kiocb, res);
1246
	io_put_req(req);
J
Jens Axboe 已提交
1247 1248
}

1249 1250 1251
static struct io_kiocb *__io_complete_rw(struct kiocb *kiocb, long res)
{
	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);
1252
	struct io_kiocb *nxt = NULL;
1253 1254

	io_complete_rw_common(kiocb, res);
1255 1256 1257
	io_put_req_find_next(req, &nxt);

	return nxt;
J
Jens Axboe 已提交
1258 1259
}

J
Jens Axboe 已提交
1260 1261 1262 1263
static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2)
{
	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);

1264 1265
	if (kiocb->ki_flags & IOCB_WRITE)
		kiocb_end_write(req);
J
Jens Axboe 已提交
1266

J
Jens Axboe 已提交
1267 1268 1269
	if ((req->flags & REQ_F_LINK) && res != req->result)
		req->flags |= REQ_F_FAIL_LINK;
	req->result = res;
J
Jens Axboe 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
	if (res != -EAGAIN)
		req->flags |= REQ_F_IOPOLL_COMPLETED;
}

/*
 * After the iocb has been issued, it's safe to be found on the poll list.
 * Adding the kiocb to the list AFTER submission ensures that we don't
 * find it from a io_iopoll_getevents() thread before the issuer is done
 * accessing the kiocb cookie.
 */
static void io_iopoll_req_issued(struct io_kiocb *req)
{
	struct io_ring_ctx *ctx = req->ctx;

	/*
	 * Track whether we have multiple files in our lists. This will impact
	 * how we do polling eventually, not spinning if we're on potentially
	 * different devices.
	 */
	if (list_empty(&ctx->poll_list)) {
		ctx->poll_multi_file = false;
	} else if (!ctx->poll_multi_file) {
		struct io_kiocb *list_req;

		list_req = list_first_entry(&ctx->poll_list, struct io_kiocb,
						list);
		if (list_req->rw.ki_filp != req->rw.ki_filp)
			ctx->poll_multi_file = true;
	}

	/*
	 * For fast devices, IO may have already completed. If it has, add
	 * it to the front so we find it first.
	 */
	if (req->flags & REQ_F_IOPOLL_COMPLETED)
		list_add(&req->list, &ctx->poll_list);
	else
		list_add_tail(&req->list, &ctx->poll_list);
}

1310
static void io_file_put(struct io_submit_state *state)
1311
{
1312
	if (state->file) {
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
		int diff = state->has_refs - state->used_refs;

		if (diff)
			fput_many(state->file, diff);
		state->file = NULL;
	}
}

/*
 * Get as many references to a file as we have IOs left in this submission,
 * assuming most submissions are for one file, or at least that each file
 * has more than one submission.
 */
static struct file *io_file_get(struct io_submit_state *state, int fd)
{
	if (!state)
		return fget(fd);

	if (state->file) {
		if (state->fd == fd) {
			state->used_refs++;
			state->ios_left--;
			return state->file;
		}
1337
		io_file_put(state);
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
	}
	state->file = fget_many(fd, state->ios_left);
	if (!state->file)
		return NULL;

	state->fd = fd;
	state->has_refs = state->ios_left;
	state->used_refs = 1;
	state->ios_left--;
	return state->file;
}

J
Jens Axboe 已提交
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
/*
 * If we tracked the file through the SCM inflight mechanism, we could support
 * any file. For now, just ensure that anything potentially problematic is done
 * inline.
 */
static bool io_file_supports_async(struct file *file)
{
	umode_t mode = file_inode(file)->i_mode;

	if (S_ISBLK(mode) || S_ISCHR(mode))
		return true;
	if (S_ISREG(mode) && file->f_op != &io_uring_fops)
		return true;

	return false;
}

1367
static int io_prep_rw(struct io_kiocb *req, bool force_nonblock)
J
Jens Axboe 已提交
1368
{
1369
	const struct io_uring_sqe *sqe = req->submit.sqe;
J
Jens Axboe 已提交
1370
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
1371
	struct kiocb *kiocb = &req->rw;
J
Jens Axboe 已提交
1372 1373
	unsigned ioprio;
	int ret;
J
Jens Axboe 已提交
1374

J
Jens Axboe 已提交
1375 1376
	if (!req->file)
		return -EBADF;
J
Jens Axboe 已提交
1377

1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
	if (S_ISREG(file_inode(req->file)->i_mode))
		req->flags |= REQ_F_ISREG;

	/*
	 * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
	 * we know to async punt it even if it was opened O_NONBLOCK
	 */
	if (force_nonblock && !io_file_supports_async(req->file)) {
		req->flags |= REQ_F_MUST_PUNT;
		return -EAGAIN;
	}
J
Jens Axboe 已提交
1389

J
Jens Axboe 已提交
1390 1391 1392 1393 1394 1395 1396 1397
	kiocb->ki_pos = READ_ONCE(sqe->off);
	kiocb->ki_flags = iocb_flags(kiocb->ki_filp);
	kiocb->ki_hint = ki_hint_validate(file_write_hint(kiocb->ki_filp));

	ioprio = READ_ONCE(sqe->ioprio);
	if (ioprio) {
		ret = ioprio_check_cap(ioprio);
		if (ret)
J
Jens Axboe 已提交
1398
			return ret;
J
Jens Axboe 已提交
1399 1400 1401 1402 1403 1404 1405

		kiocb->ki_ioprio = ioprio;
	} else
		kiocb->ki_ioprio = get_current_ioprio();

	ret = kiocb_set_rw_flags(kiocb, READ_ONCE(sqe->rw_flags));
	if (unlikely(ret))
J
Jens Axboe 已提交
1406
		return ret;
1407 1408

	/* don't allow async punt if RWF_NOWAIT was requested */
1409 1410
	if ((kiocb->ki_flags & IOCB_NOWAIT) ||
	    (req->file->f_flags & O_NONBLOCK))
1411 1412 1413
		req->flags |= REQ_F_NOWAIT;

	if (force_nonblock)
J
Jens Axboe 已提交
1414
		kiocb->ki_flags |= IOCB_NOWAIT;
1415

J
Jens Axboe 已提交
1416 1417 1418
	if (ctx->flags & IORING_SETUP_IOPOLL) {
		if (!(kiocb->ki_flags & IOCB_DIRECT) ||
		    !kiocb->ki_filp->f_op->iopoll)
J
Jens Axboe 已提交
1419
			return -EOPNOTSUPP;
J
Jens Axboe 已提交
1420

J
Jens Axboe 已提交
1421 1422
		kiocb->ki_flags |= IOCB_HIPRI;
		kiocb->ki_complete = io_complete_rw_iopoll;
1423
		req->result = 0;
J
Jens Axboe 已提交
1424
	} else {
J
Jens Axboe 已提交
1425 1426
		if (kiocb->ki_flags & IOCB_HIPRI)
			return -EINVAL;
J
Jens Axboe 已提交
1427 1428
		kiocb->ki_complete = io_complete_rw;
	}
J
Jens Axboe 已提交
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
	return 0;
}

static inline void io_rw_done(struct kiocb *kiocb, ssize_t ret)
{
	switch (ret) {
	case -EIOCBQUEUED:
		break;
	case -ERESTARTSYS:
	case -ERESTARTNOINTR:
	case -ERESTARTNOHAND:
	case -ERESTART_RESTARTBLOCK:
		/*
		 * We can't just restart the syscall, since previously
		 * submitted sqes may already be in progress. Just fail this
		 * IO with EINTR.
		 */
		ret = -EINTR;
		/* fall through */
	default:
		kiocb->ki_complete(kiocb, ret, 0);
	}
}

1453 1454 1455 1456 1457 1458 1459 1460 1461
static void kiocb_done(struct kiocb *kiocb, ssize_t ret, struct io_kiocb **nxt,
		       bool in_async)
{
	if (in_async && ret >= 0 && nxt && kiocb->ki_complete == io_complete_rw)
		*nxt = __io_complete_rw(kiocb, ret);
	else
		io_rw_done(kiocb, ret);
}

1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
static int io_import_fixed(struct io_ring_ctx *ctx, int rw,
			   const struct io_uring_sqe *sqe,
			   struct iov_iter *iter)
{
	size_t len = READ_ONCE(sqe->len);
	struct io_mapped_ubuf *imu;
	unsigned index, buf_index;
	size_t offset;
	u64 buf_addr;

	/* attempt to use fixed buffers without having provided iovecs */
	if (unlikely(!ctx->user_bufs))
		return -EFAULT;

	buf_index = READ_ONCE(sqe->buf_index);
	if (unlikely(buf_index >= ctx->nr_user_bufs))
		return -EFAULT;

	index = array_index_nospec(buf_index, ctx->nr_user_bufs);
	imu = &ctx->user_bufs[index];
	buf_addr = READ_ONCE(sqe->addr);

	/* overflow */
	if (buf_addr + len < buf_addr)
		return -EFAULT;
	/* not inside the mapped region */
	if (buf_addr < imu->ubuf || buf_addr + len > imu->ubuf + imu->len)
		return -EFAULT;

	/*
	 * May not be a start of buffer, set size appropriately
	 * and advance us to the beginning.
	 */
	offset = buf_addr - imu->ubuf;
	iov_iter_bvec(iter, rw, imu->bvec, imu->nr_bvecs, offset + len);
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527

	if (offset) {
		/*
		 * Don't use iov_iter_advance() here, as it's really slow for
		 * using the latter parts of a big fixed buffer - it iterates
		 * over each segment manually. We can cheat a bit here, because
		 * we know that:
		 *
		 * 1) it's a BVEC iter, we set it up
		 * 2) all bvecs are PAGE_SIZE in size, except potentially the
		 *    first and last bvec
		 *
		 * So just find our index, and adjust the iterator afterwards.
		 * If the offset is within the first bvec (or the whole first
		 * bvec, just use iov_iter_advance(). This makes it easier
		 * since we can just skip the first segment, which may not
		 * be PAGE_SIZE aligned.
		 */
		const struct bio_vec *bvec = imu->bvec;

		if (offset <= bvec->bv_len) {
			iov_iter_advance(iter, offset);
		} else {
			unsigned long seg_skip;

			/* skip first vec */
			offset -= bvec->bv_len;
			seg_skip = 1 + (offset >> PAGE_SHIFT);

			iter->bvec = bvec + seg_skip;
			iter->nr_segs -= seg_skip;
1528
			iter->count -= bvec->bv_len + offset;
1529 1530 1531 1532
			iter->iov_offset = offset & ~PAGE_MASK;
		}
	}

1533
	return len;
1534 1535
}

1536 1537 1538
static ssize_t io_import_iovec(struct io_ring_ctx *ctx, int rw,
			       const struct sqe_submit *s, struct iovec **iovec,
			       struct iov_iter *iter)
J
Jens Axboe 已提交
1539 1540 1541 1542
{
	const struct io_uring_sqe *sqe = s->sqe;
	void __user *buf = u64_to_user_ptr(READ_ONCE(sqe->addr));
	size_t sqe_len = READ_ONCE(sqe->len);
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
	u8 opcode;

	/*
	 * We're reading ->opcode for the second time, but the first read
	 * doesn't care whether it's _FIXED or not, so it doesn't matter
	 * whether ->opcode changes concurrently. The first read does care
	 * about whether it is a READ or a WRITE, so we don't trust this read
	 * for that purpose and instead let the caller pass in the read/write
	 * flag.
	 */
	opcode = READ_ONCE(sqe->opcode);
	if (opcode == IORING_OP_READ_FIXED ||
	    opcode == IORING_OP_WRITE_FIXED) {
1556
		ssize_t ret = io_import_fixed(ctx, rw, sqe, iter);
1557 1558 1559
		*iovec = NULL;
		return ret;
	}
J
Jens Axboe 已提交
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572

	if (!s->has_user)
		return -EFAULT;

#ifdef CONFIG_COMPAT
	if (ctx->compat)
		return compat_import_iovec(rw, buf, sqe_len, UIO_FASTIOV,
						iovec, iter);
#endif

	return import_iovec(rw, buf, sqe_len, UIO_FASTIOV, iovec, iter);
}

1573
/*
1574 1575
 * For files that don't have ->read_iter() and ->write_iter(), handle them
 * by looping over ->read() or ->write() manually.
1576
 */
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
static ssize_t loop_rw_iter(int rw, struct file *file, struct kiocb *kiocb,
			   struct iov_iter *iter)
{
	ssize_t ret = 0;

	/*
	 * Don't support polled IO through this interface, and we can't
	 * support non-blocking either. For the latter, this just causes
	 * the kiocb to be handled from an async context.
	 */
	if (kiocb->ki_flags & IOCB_HIPRI)
		return -EOPNOTSUPP;
	if (kiocb->ki_flags & IOCB_NOWAIT)
		return -EAGAIN;

	while (iov_iter_count(iter)) {
		struct iovec iovec = iov_iter_iovec(iter);
		ssize_t nr;

		if (rw == READ) {
			nr = file->f_op->read(file, iovec.iov_base,
					      iovec.iov_len, &kiocb->ki_pos);
		} else {
			nr = file->f_op->write(file, iovec.iov_base,
					       iovec.iov_len, &kiocb->ki_pos);
		}

		if (nr < 0) {
			if (!ret)
				ret = nr;
			break;
		}
		ret += nr;
		if (nr != iovec.iov_len)
			break;
		iov_iter_advance(iter, nr);
	}

	return ret;
}

1618
static int io_read(struct io_kiocb *req, struct io_kiocb **nxt,
1619
		   bool force_nonblock)
J
Jens Axboe 已提交
1620 1621 1622 1623 1624
{
	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
	struct kiocb *kiocb = &req->rw;
	struct iov_iter iter;
	struct file *file;
1625
	size_t iov_count;
1626
	ssize_t read_size, ret;
J
Jens Axboe 已提交
1627

1628
	ret = io_prep_rw(req, force_nonblock);
J
Jens Axboe 已提交
1629 1630 1631 1632 1633
	if (ret)
		return ret;
	file = kiocb->ki_filp;

	if (unlikely(!(file->f_mode & FMODE_READ)))
J
Jens Axboe 已提交
1634
		return -EBADF;
J
Jens Axboe 已提交
1635

1636
	ret = io_import_iovec(req->ctx, READ, &req->submit, &iovec, &iter);
1637
	if (ret < 0)
J
Jens Axboe 已提交
1638
		return ret;
J
Jens Axboe 已提交
1639

1640
	read_size = ret;
J
Jens Axboe 已提交
1641 1642 1643
	if (req->flags & REQ_F_LINK)
		req->result = read_size;

1644 1645
	iov_count = iov_iter_count(&iter);
	ret = rw_verify_area(READ, file, &kiocb->ki_pos, iov_count);
J
Jens Axboe 已提交
1646 1647 1648
	if (!ret) {
		ssize_t ret2;

1649 1650 1651 1652 1653
		if (file->f_op->read_iter)
			ret2 = call_read_iter(file, kiocb, &iter);
		else
			ret2 = loop_rw_iter(READ, file, kiocb, &iter);

1654 1655 1656 1657 1658 1659 1660 1661
		/*
		 * In case of a short read, punt to async. This can happen
		 * if we have data partially cached. Alternatively we can
		 * return the short read, in which case the application will
		 * need to issue another SQE and wait for it. That SQE will
		 * need async punt anyway, so it's more efficient to do it
		 * here.
		 */
1662 1663 1664
		if (force_nonblock && !(req->flags & REQ_F_NOWAIT) &&
		    (req->flags & REQ_F_ISREG) &&
		    ret2 > 0 && ret2 < read_size)
1665 1666
			ret2 = -EAGAIN;
		/* Catch -EAGAIN return for forced non-blocking submission */
1667
		if (!force_nonblock || ret2 != -EAGAIN)
1668
			kiocb_done(kiocb, ret2, nxt, req->submit.in_async);
1669
		else
J
Jens Axboe 已提交
1670 1671 1672 1673 1674 1675
			ret = -EAGAIN;
	}
	kfree(iovec);
	return ret;
}

1676
static int io_write(struct io_kiocb *req, struct io_kiocb **nxt,
1677
		    bool force_nonblock)
J
Jens Axboe 已提交
1678 1679 1680 1681 1682
{
	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
	struct kiocb *kiocb = &req->rw;
	struct iov_iter iter;
	struct file *file;
1683
	size_t iov_count;
1684
	ssize_t ret;
J
Jens Axboe 已提交
1685

1686
	ret = io_prep_rw(req, force_nonblock);
J
Jens Axboe 已提交
1687 1688 1689 1690 1691
	if (ret)
		return ret;

	file = kiocb->ki_filp;
	if (unlikely(!(file->f_mode & FMODE_WRITE)))
J
Jens Axboe 已提交
1692
		return -EBADF;
J
Jens Axboe 已提交
1693

1694
	ret = io_import_iovec(req->ctx, WRITE, &req->submit, &iovec, &iter);
1695
	if (ret < 0)
J
Jens Axboe 已提交
1696
		return ret;
J
Jens Axboe 已提交
1697

J
Jens Axboe 已提交
1698 1699 1700
	if (req->flags & REQ_F_LINK)
		req->result = ret;

1701 1702 1703
	iov_count = iov_iter_count(&iter);

	ret = -EAGAIN;
1704
	if (force_nonblock && !(kiocb->ki_flags & IOCB_DIRECT))
1705 1706 1707
		goto out_free;

	ret = rw_verify_area(WRITE, file, &kiocb->ki_pos, iov_count);
J
Jens Axboe 已提交
1708
	if (!ret) {
1709 1710
		ssize_t ret2;

J
Jens Axboe 已提交
1711 1712 1713 1714 1715 1716 1717
		/*
		 * Open-code file_start_write here to grab freeze protection,
		 * which will be released by another thread in
		 * io_complete_rw().  Fool lockdep by telling it the lock got
		 * released so that it doesn't complain about the held lock when
		 * we return to userspace.
		 */
1718
		if (req->flags & REQ_F_ISREG) {
J
Jens Axboe 已提交
1719 1720 1721 1722 1723 1724
			__sb_start_write(file_inode(file)->i_sb,
						SB_FREEZE_WRITE, true);
			__sb_writers_release(file_inode(file)->i_sb,
						SB_FREEZE_WRITE);
		}
		kiocb->ki_flags |= IOCB_WRITE;
1725

1726 1727 1728 1729
		if (file->f_op->write_iter)
			ret2 = call_write_iter(file, kiocb, &iter);
		else
			ret2 = loop_rw_iter(WRITE, file, kiocb, &iter);
1730
		if (!force_nonblock || ret2 != -EAGAIN)
1731
			kiocb_done(kiocb, ret2, nxt, req->submit.in_async);
1732
		else
1733
			ret = -EAGAIN;
J
Jens Axboe 已提交
1734
	}
1735
out_free:
J
Jens Axboe 已提交
1736 1737 1738 1739 1740 1741 1742
	kfree(iovec);
	return ret;
}

/*
 * IORING_OP_NOP just posts a completion event, nothing else.
 */
1743
static int io_nop(struct io_kiocb *req)
J
Jens Axboe 已提交
1744 1745 1746
{
	struct io_ring_ctx *ctx = req->ctx;

J
Jens Axboe 已提交
1747 1748 1749
	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;

1750
	io_cqring_add_event(req, 0);
1751
	io_put_req(req);
J
Jens Axboe 已提交
1752 1753 1754
	return 0;
}

C
Christoph Hellwig 已提交
1755 1756
static int io_prep_fsync(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
J
Jens Axboe 已提交
1757
	struct io_ring_ctx *ctx = req->ctx;
C
Christoph Hellwig 已提交
1758

J
Jens Axboe 已提交
1759 1760
	if (!req->file)
		return -EBADF;
C
Christoph Hellwig 已提交
1761

J
Jens Axboe 已提交
1762
	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
J
Jens Axboe 已提交
1763
		return -EINVAL;
1764
	if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
C
Christoph Hellwig 已提交
1765 1766 1767 1768 1769 1770
		return -EINVAL;

	return 0;
}

static int io_fsync(struct io_kiocb *req, const struct io_uring_sqe *sqe,
1771
		    struct io_kiocb **nxt, bool force_nonblock)
C
Christoph Hellwig 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
{
	loff_t sqe_off = READ_ONCE(sqe->off);
	loff_t sqe_len = READ_ONCE(sqe->len);
	loff_t end = sqe_off + sqe_len;
	unsigned fsync_flags;
	int ret;

	fsync_flags = READ_ONCE(sqe->fsync_flags);
	if (unlikely(fsync_flags & ~IORING_FSYNC_DATASYNC))
		return -EINVAL;

	ret = io_prep_fsync(req, sqe);
	if (ret)
		return ret;

	/* fsync always requires a blocking context */
	if (force_nonblock)
		return -EAGAIN;

	ret = vfs_fsync_range(req->rw.ki_filp, sqe_off,
				end > 0 ? end : LLONG_MAX,
				fsync_flags & IORING_FSYNC_DATASYNC);

J
Jens Axboe 已提交
1795 1796
	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
1797
	io_cqring_add_event(req, ret);
1798
	io_put_req_find_next(req, nxt);
C
Christoph Hellwig 已提交
1799 1800 1801
	return 0;
}

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
static int io_prep_sfr(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_ring_ctx *ctx = req->ctx;
	int ret = 0;

	if (!req->file)
		return -EBADF;

	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
	if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
		return -EINVAL;

	return ret;
}

static int io_sync_file_range(struct io_kiocb *req,
			      const struct io_uring_sqe *sqe,
1820
			      struct io_kiocb **nxt,
1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
			      bool force_nonblock)
{
	loff_t sqe_off;
	loff_t sqe_len;
	unsigned flags;
	int ret;

	ret = io_prep_sfr(req, sqe);
	if (ret)
		return ret;

	/* sync_file_range always requires a blocking context */
	if (force_nonblock)
		return -EAGAIN;

	sqe_off = READ_ONCE(sqe->off);
	sqe_len = READ_ONCE(sqe->len);
	flags = READ_ONCE(sqe->sync_range_flags);

	ret = sync_file_range(req->rw.ki_filp, sqe_off, sqe_len, flags);

J
Jens Axboe 已提交
1842 1843
	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
1844
	io_cqring_add_event(req, ret);
1845
	io_put_req_find_next(req, nxt);
1846 1847 1848
	return 0;
}

J
Jens Axboe 已提交
1849
#if defined(CONFIG_NET)
J
Jens Axboe 已提交
1850
static int io_send_recvmsg(struct io_kiocb *req, const struct io_uring_sqe *sqe,
1851
			   struct io_kiocb **nxt, bool force_nonblock,
J
Jens Axboe 已提交
1852 1853 1854
		   long (*fn)(struct socket *, struct user_msghdr __user *,
				unsigned int))
{
J
Jens Axboe 已提交
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	struct socket *sock;
	int ret;

	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;

	sock = sock_from_file(req->file, &ret);
	if (sock) {
		struct user_msghdr __user *msg;
		unsigned flags;

		flags = READ_ONCE(sqe->msg_flags);
		if (flags & MSG_DONTWAIT)
			req->flags |= REQ_F_NOWAIT;
		else if (force_nonblock)
			flags |= MSG_DONTWAIT;

		msg = (struct user_msghdr __user *) (unsigned long)
			READ_ONCE(sqe->addr);

J
Jens Axboe 已提交
1875
		ret = fn(sock, msg, flags);
J
Jens Axboe 已提交
1876 1877 1878 1879
		if (force_nonblock && ret == -EAGAIN)
			return ret;
	}

1880
	io_cqring_add_event(req, ret);
1881 1882
	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
1883
	io_put_req_find_next(req, nxt);
1884 1885
	return 0;
}
J
Jens Axboe 已提交
1886 1887 1888
#endif

static int io_sendmsg(struct io_kiocb *req, const struct io_uring_sqe *sqe,
1889
		      struct io_kiocb **nxt, bool force_nonblock)
J
Jens Axboe 已提交
1890 1891
{
#if defined(CONFIG_NET)
1892 1893
	return io_send_recvmsg(req, sqe, nxt, force_nonblock,
				__sys_sendmsg_sock);
J
Jens Axboe 已提交
1894 1895 1896 1897 1898 1899
#else
	return -EOPNOTSUPP;
#endif
}

static int io_recvmsg(struct io_kiocb *req, const struct io_uring_sqe *sqe,
1900
		      struct io_kiocb **nxt, bool force_nonblock)
J
Jens Axboe 已提交
1901 1902
{
#if defined(CONFIG_NET)
1903 1904
	return io_send_recvmsg(req, sqe, nxt, force_nonblock,
				__sys_recvmsg_sock);
J
Jens Axboe 已提交
1905 1906 1907 1908
#else
	return -EOPNOTSUPP;
#endif
}
1909

1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
static int io_accept(struct io_kiocb *req, const struct io_uring_sqe *sqe,
		     struct io_kiocb **nxt, bool force_nonblock)
{
#if defined(CONFIG_NET)
	struct sockaddr __user *addr;
	int __user *addr_len;
	unsigned file_flags;
	int flags, ret;

	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
		return -EINVAL;
	if (sqe->ioprio || sqe->off || sqe->len || sqe->buf_index)
		return -EINVAL;

	addr = (struct sockaddr __user *) (unsigned long) READ_ONCE(sqe->addr);
	addr_len = (int __user *) (unsigned long) READ_ONCE(sqe->addr2);
	flags = READ_ONCE(sqe->accept_flags);
	file_flags = force_nonblock ? O_NONBLOCK : 0;

	ret = __sys_accept4_file(req->file, file_flags, addr, addr_len, flags);
	if (ret == -EAGAIN && force_nonblock) {
		req->work.flags |= IO_WQ_WORK_NEEDS_FILES;
		return -EAGAIN;
	}
1934 1935
	if (ret == -ERESTARTSYS)
		ret = -EINTR;
1936 1937
	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
1938
	io_cqring_add_event(req, ret);
1939
	io_put_req_find_next(req, nxt);
1940
	return 0;
J
Jens Axboe 已提交
1941 1942 1943 1944
#else
	return -EOPNOTSUPP;
#endif
}
1945

1946 1947 1948 1949 1950 1951 1952 1953
static inline void io_poll_remove_req(struct io_kiocb *req)
{
	if (!RB_EMPTY_NODE(&req->rb_node)) {
		rb_erase(&req->rb_node, &req->ctx->cancel_tree);
		RB_CLEAR_NODE(&req->rb_node);
	}
}

1954 1955 1956 1957 1958 1959 1960 1961
static void io_poll_remove_one(struct io_kiocb *req)
{
	struct io_poll_iocb *poll = &req->poll;

	spin_lock(&poll->head->lock);
	WRITE_ONCE(poll->canceled, true);
	if (!list_empty(&poll->wait.entry)) {
		list_del_init(&poll->wait.entry);
1962
		io_queue_async_work(req);
1963 1964
	}
	spin_unlock(&poll->head->lock);
1965
	io_poll_remove_req(req);
1966 1967 1968 1969
}

static void io_poll_remove_all(struct io_ring_ctx *ctx)
{
1970
	struct rb_node *node;
1971 1972 1973
	struct io_kiocb *req;

	spin_lock_irq(&ctx->completion_lock);
1974 1975
	while ((node = rb_first(&ctx->cancel_tree)) != NULL) {
		req = rb_entry(node, struct io_kiocb, rb_node);
1976 1977 1978 1979 1980
		io_poll_remove_one(req);
	}
	spin_unlock_irq(&ctx->completion_lock);
}

1981 1982
static int io_poll_cancel(struct io_ring_ctx *ctx, __u64 sqe_addr)
{
1983
	struct rb_node *p, *parent = NULL;
1984 1985
	struct io_kiocb *req;

1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
	p = ctx->cancel_tree.rb_node;
	while (p) {
		parent = p;
		req = rb_entry(parent, struct io_kiocb, rb_node);
		if (sqe_addr < req->user_data) {
			p = p->rb_left;
		} else if (sqe_addr > req->user_data) {
			p = p->rb_right;
		} else {
			io_poll_remove_one(req);
			return 0;
		}
1998 1999 2000 2001 2002
	}

	return -ENOENT;
}

2003 2004 2005 2006 2007 2008 2009
/*
 * Find a running poll command that matches one specified in sqe->addr,
 * and remove it if found.
 */
static int io_poll_remove(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_ring_ctx *ctx = req->ctx;
2010
	int ret;
2011 2012 2013 2014 2015 2016 2017 2018

	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
	if (sqe->ioprio || sqe->off || sqe->len || sqe->buf_index ||
	    sqe->poll_events)
		return -EINVAL;

	spin_lock_irq(&ctx->completion_lock);
2019
	ret = io_poll_cancel(ctx, READ_ONCE(sqe->addr));
2020 2021
	spin_unlock_irq(&ctx->completion_lock);

2022
	io_cqring_add_event(req, ret);
2023 2024
	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
2025
	io_put_req(req);
2026 2027 2028
	return 0;
}

2029
static void io_poll_complete(struct io_kiocb *req, __poll_t mask)
2030
{
2031 2032
	struct io_ring_ctx *ctx = req->ctx;

J
Jens Axboe 已提交
2033
	req->poll.done = true;
2034
	io_cqring_fill_event(req, mangle_poll(mask));
J
Jens Axboe 已提交
2035
	io_commit_cqring(ctx);
2036 2037
}

2038
static void io_poll_complete_work(struct io_wq_work **workptr)
2039
{
2040
	struct io_wq_work *work = *workptr;
2041 2042 2043 2044
	struct io_kiocb *req = container_of(work, struct io_kiocb, work);
	struct io_poll_iocb *poll = &req->poll;
	struct poll_table_struct pt = { ._key = poll->events };
	struct io_ring_ctx *ctx = req->ctx;
2045
	struct io_kiocb *nxt = NULL;
2046 2047
	__poll_t mask = 0;

2048 2049 2050
	if (work->flags & IO_WQ_WORK_CANCEL)
		WRITE_ONCE(poll->canceled, true);

2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
	if (!READ_ONCE(poll->canceled))
		mask = vfs_poll(poll->file, &pt) & poll->events;

	/*
	 * Note that ->ki_cancel callers also delete iocb from active_reqs after
	 * calling ->ki_cancel.  We need the ctx_lock roundtrip here to
	 * synchronize with them.  In the cancellation case the list_del_init
	 * itself is not actually needed, but harmless so we keep it in to
	 * avoid further branches in the fast path.
	 */
	spin_lock_irq(&ctx->completion_lock);
	if (!mask && !READ_ONCE(poll->canceled)) {
		add_wait_queue(poll->head, &poll->wait);
		spin_unlock_irq(&ctx->completion_lock);
		return;
	}
2067
	io_poll_remove_req(req);
2068
	io_poll_complete(req, mask);
2069 2070
	spin_unlock_irq(&ctx->completion_lock);

J
Jens Axboe 已提交
2071
	io_cqring_ev_posted(ctx);
2072

2073
	io_put_req_find_next(req, &nxt);
2074 2075
	if (nxt)
		*workptr = &nxt->work;
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
}

static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
			void *key)
{
	struct io_poll_iocb *poll = container_of(wait, struct io_poll_iocb,
							wait);
	struct io_kiocb *req = container_of(poll, struct io_kiocb, poll);
	struct io_ring_ctx *ctx = req->ctx;
	__poll_t mask = key_to_poll(key);
J
Jens Axboe 已提交
2086
	unsigned long flags;
2087 2088

	/* for instances that support it check for an event match first: */
J
Jens Axboe 已提交
2089 2090
	if (mask && !(mask & poll->events))
		return 0;
2091

J
Jens Axboe 已提交
2092
	list_del_init(&poll->wait.entry);
2093

2094 2095 2096 2097 2098 2099
	/*
	 * Run completion inline if we can. We're using trylock here because
	 * we are violating the completion_lock -> poll wq lock ordering.
	 * If we have a link timeout we're going to need the completion_lock
	 * for finalizing the request, mark us as having grabbed that already.
	 */
J
Jens Axboe 已提交
2100
	if (mask && spin_trylock_irqsave(&ctx->completion_lock, flags)) {
2101
		io_poll_remove_req(req);
2102
		io_poll_complete(req, mask);
2103 2104
		req->flags |= REQ_F_COMP_LOCKED;
		io_put_req(req);
J
Jens Axboe 已提交
2105
		spin_unlock_irqrestore(&ctx->completion_lock, flags);
2106

J
Jens Axboe 已提交
2107 2108
		io_cqring_ev_posted(ctx);
	} else {
2109
		io_queue_async_work(req);
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
	}

	return 1;
}

struct io_poll_table {
	struct poll_table_struct pt;
	struct io_kiocb *req;
	int error;
};

static void io_poll_queue_proc(struct file *file, struct wait_queue_head *head,
			       struct poll_table_struct *p)
{
	struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);

	if (unlikely(pt->req->poll.head)) {
		pt->error = -EINVAL;
		return;
	}

	pt->error = 0;
	pt->req->poll.head = head;
	add_wait_queue(head, &pt->req->poll.wait);
}

2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
static void io_poll_req_insert(struct io_kiocb *req)
{
	struct io_ring_ctx *ctx = req->ctx;
	struct rb_node **p = &ctx->cancel_tree.rb_node;
	struct rb_node *parent = NULL;
	struct io_kiocb *tmp;

	while (*p) {
		parent = *p;
		tmp = rb_entry(parent, struct io_kiocb, rb_node);
		if (req->user_data < tmp->user_data)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}
	rb_link_node(&req->rb_node, parent, p);
	rb_insert_color(&req->rb_node, &ctx->cancel_tree);
}

2155 2156
static int io_poll_add(struct io_kiocb *req, const struct io_uring_sqe *sqe,
		       struct io_kiocb **nxt)
2157 2158 2159 2160
{
	struct io_poll_iocb *poll = &req->poll;
	struct io_ring_ctx *ctx = req->ctx;
	struct io_poll_table ipt;
J
Jens Axboe 已提交
2161
	bool cancel = false;
2162 2163 2164 2165 2166 2167 2168
	__poll_t mask;
	u16 events;

	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
	if (sqe->addr || sqe->ioprio || sqe->off || sqe->len || sqe->buf_index)
		return -EINVAL;
J
Jens Axboe 已提交
2169 2170
	if (!poll->file)
		return -EBADF;
2171

2172
	req->submit.sqe = NULL;
2173
	INIT_IO_WORK(&req->work, io_poll_complete_work);
2174 2175
	events = READ_ONCE(sqe->poll_events);
	poll->events = demangle_poll(events) | EPOLLERR | EPOLLHUP;
2176
	RB_CLEAR_NODE(&req->rb_node);
2177 2178

	poll->head = NULL;
J
Jens Axboe 已提交
2179
	poll->done = false;
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
	poll->canceled = false;

	ipt.pt._qproc = io_poll_queue_proc;
	ipt.pt._key = poll->events;
	ipt.req = req;
	ipt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */

	/* initialized the list so that we can do list_empty checks */
	INIT_LIST_HEAD(&poll->wait.entry);
	init_waitqueue_func_entry(&poll->wait, io_poll_wake);

2191 2192
	INIT_LIST_HEAD(&req->list);

2193 2194 2195
	mask = vfs_poll(poll->file, &ipt.pt) & poll->events;

	spin_lock_irq(&ctx->completion_lock);
J
Jens Axboe 已提交
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
	if (likely(poll->head)) {
		spin_lock(&poll->head->lock);
		if (unlikely(list_empty(&poll->wait.entry))) {
			if (ipt.error)
				cancel = true;
			ipt.error = 0;
			mask = 0;
		}
		if (mask || ipt.error)
			list_del_init(&poll->wait.entry);
		else if (cancel)
			WRITE_ONCE(poll->canceled, true);
		else if (!poll->done) /* actually waiting for an event */
2209
			io_poll_req_insert(req);
J
Jens Axboe 已提交
2210 2211 2212
		spin_unlock(&poll->head->lock);
	}
	if (mask) { /* no async, we'd stolen it */
2213
		ipt.error = 0;
2214
		io_poll_complete(req, mask);
2215 2216 2217
	}
	spin_unlock_irq(&ctx->completion_lock);

J
Jens Axboe 已提交
2218 2219
	if (mask) {
		io_cqring_ev_posted(ctx);
2220
		io_put_req_find_next(req, nxt);
2221
	}
J
Jens Axboe 已提交
2222
	return ipt.error;
2223 2224
}

J
Jens Axboe 已提交
2225 2226 2227
static enum hrtimer_restart io_timeout_fn(struct hrtimer *timer)
{
	struct io_ring_ctx *ctx;
2228
	struct io_kiocb *req;
J
Jens Axboe 已提交
2229 2230 2231 2232 2233 2234 2235
	unsigned long flags;

	req = container_of(timer, struct io_kiocb, timeout.timer);
	ctx = req->ctx;
	atomic_inc(&ctx->cq_timeouts);

	spin_lock_irqsave(&ctx->completion_lock, flags);
2236
	/*
2237 2238
	 * We could be racing with timeout deletion. If the list is empty,
	 * then timeout lookup already found it and will be handling it.
2239
	 */
2240
	if (!list_empty(&req->list)) {
2241
		struct io_kiocb *prev;
J
Jens Axboe 已提交
2242

2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253
		/*
		 * Adjust the reqs sequence before the current one because it
		 * will consume a slot in the cq_ring and the the cq_tail
		 * pointer will be increased, otherwise other timeout reqs may
		 * return in advance without waiting for enough wait_nr.
		 */
		prev = req;
		list_for_each_entry_continue_reverse(prev, &ctx->timeout_list, list)
			prev->sequence++;
		list_del_init(&req->list);
	}
J
Jens Axboe 已提交
2254

2255
	io_cqring_fill_event(req, -ETIME);
J
Jens Axboe 已提交
2256 2257 2258 2259
	io_commit_cqring(ctx);
	spin_unlock_irqrestore(&ctx->completion_lock, flags);

	io_cqring_ev_posted(ctx);
2260 2261
	if (req->flags & REQ_F_LINK)
		req->flags |= REQ_F_FAIL_LINK;
J
Jens Axboe 已提交
2262 2263 2264 2265
	io_put_req(req);
	return HRTIMER_NORESTART;
}

2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data)
{
	struct io_kiocb *req;
	int ret = -ENOENT;

	list_for_each_entry(req, &ctx->timeout_list, list) {
		if (user_data == req->user_data) {
			list_del_init(&req->list);
			ret = 0;
			break;
		}
	}

	if (ret == -ENOENT)
		return ret;

	ret = hrtimer_try_to_cancel(&req->timeout.timer);
	if (ret == -1)
		return -EALREADY;

	io_cqring_fill_event(req, -ECANCELED);
	io_put_req(req);
	return 0;
}

2291 2292 2293 2294 2295 2296 2297 2298
/*
 * Remove or update an existing timeout command
 */
static int io_timeout_remove(struct io_kiocb *req,
			     const struct io_uring_sqe *sqe)
{
	struct io_ring_ctx *ctx = req->ctx;
	unsigned flags;
2299
	int ret;
2300 2301 2302 2303 2304 2305 2306 2307 2308 2309

	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
	if (sqe->flags || sqe->ioprio || sqe->buf_index || sqe->len)
		return -EINVAL;
	flags = READ_ONCE(sqe->timeout_flags);
	if (flags)
		return -EINVAL;

	spin_lock_irq(&ctx->completion_lock);
2310
	ret = io_timeout_cancel(ctx, READ_ONCE(sqe->addr));
2311

2312
	io_cqring_fill_event(req, ret);
2313 2314
	io_commit_cqring(ctx);
	spin_unlock_irq(&ctx->completion_lock);
J
Jens Axboe 已提交
2315
	io_cqring_ev_posted(ctx);
2316 2317
	if (ret < 0 && req->flags & REQ_F_LINK)
		req->flags |= REQ_F_FAIL_LINK;
2318
	io_put_req(req);
2319
	return 0;
J
Jens Axboe 已提交
2320 2321 2322 2323
}

static int io_timeout(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
2324
	unsigned count;
J
Jens Axboe 已提交
2325 2326
	struct io_ring_ctx *ctx = req->ctx;
	struct list_head *entry;
2327
	enum hrtimer_mode mode;
2328
	struct timespec64 ts;
2329
	unsigned span = 0;
2330
	unsigned flags;
J
Jens Axboe 已提交
2331 2332 2333

	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
2334 2335 2336 2337
	if (sqe->flags || sqe->ioprio || sqe->buf_index || sqe->len != 1)
		return -EINVAL;
	flags = READ_ONCE(sqe->timeout_flags);
	if (flags & ~IORING_TIMEOUT_ABS)
J
Jens Axboe 已提交
2338
		return -EINVAL;
2339 2340

	if (get_timespec64(&ts, u64_to_user_ptr(sqe->addr)))
J
Jens Axboe 已提交
2341 2342
		return -EFAULT;

2343 2344 2345 2346 2347 2348
	if (flags & IORING_TIMEOUT_ABS)
		mode = HRTIMER_MODE_ABS;
	else
		mode = HRTIMER_MODE_REL;

	hrtimer_init(&req->timeout.timer, CLOCK_MONOTONIC, mode);
2349 2350
	req->flags |= REQ_F_TIMEOUT;

J
Jens Axboe 已提交
2351 2352
	/*
	 * sqe->off holds how many events that need to occur for this
2353 2354
	 * timeout event to be satisfied. If it isn't set, then this is
	 * a pure timeout request, sequence isn't used.
J
Jens Axboe 已提交
2355 2356
	 */
	count = READ_ONCE(sqe->off);
2357 2358 2359 2360 2361 2362
	if (!count) {
		req->flags |= REQ_F_TIMEOUT_NOSEQ;
		spin_lock_irq(&ctx->completion_lock);
		entry = ctx->timeout_list.prev;
		goto add;
	}
J
Jens Axboe 已提交
2363 2364

	req->sequence = ctx->cached_sq_head + count - 1;
2365 2366
	/* reuse it to store the count */
	req->submit.sequence = count;
J
Jens Axboe 已提交
2367 2368 2369 2370 2371 2372 2373 2374

	/*
	 * Insertion sort, ensuring the first entry in the list is always
	 * the one we need first.
	 */
	spin_lock_irq(&ctx->completion_lock);
	list_for_each_prev(entry, &ctx->timeout_list) {
		struct io_kiocb *nxt = list_entry(entry, struct io_kiocb, list);
2375 2376
		unsigned nxt_sq_head;
		long long tmp, tmp_nxt;
J
Jens Axboe 已提交
2377

2378 2379 2380
		if (nxt->flags & REQ_F_TIMEOUT_NOSEQ)
			continue;

2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
		/*
		 * Since cached_sq_head + count - 1 can overflow, use type long
		 * long to store it.
		 */
		tmp = (long long)ctx->cached_sq_head + count - 1;
		nxt_sq_head = nxt->sequence - nxt->submit.sequence + 1;
		tmp_nxt = (long long)nxt_sq_head + nxt->submit.sequence - 1;

		/*
		 * cached_sq_head may overflow, and it will never overflow twice
		 * once there is some timeout req still be valid.
		 */
		if (ctx->cached_sq_head < nxt_sq_head)
2394
			tmp += UINT_MAX;
2395

2396
		if (tmp > tmp_nxt)
J
Jens Axboe 已提交
2397
			break;
2398 2399 2400 2401 2402 2403 2404

		/*
		 * Sequence of reqs after the insert one and itself should
		 * be adjusted because each timeout req consumes a slot.
		 */
		span++;
		nxt->sequence++;
J
Jens Axboe 已提交
2405
	}
2406
	req->sequence -= span;
2407
add:
J
Jens Axboe 已提交
2408 2409
	list_add(&req->list, entry);
	req->timeout.timer.function = io_timeout_fn;
2410
	hrtimer_start(&req->timeout.timer, timespec64_to_ktime(ts), mode);
J
Jens Axboe 已提交
2411 2412 2413 2414
	spin_unlock_irq(&ctx->completion_lock);
	return 0;
}

2415 2416 2417 2418 2419 2420 2421
static bool io_cancel_cb(struct io_wq_work *work, void *data)
{
	struct io_kiocb *req = container_of(work, struct io_kiocb, work);

	return req->user_data == (unsigned long) data;
}

2422
static int io_async_cancel_one(struct io_ring_ctx *ctx, void *sqe_addr)
2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439
{
	enum io_wq_cancel cancel_ret;
	int ret = 0;

	cancel_ret = io_wq_cancel_cb(ctx->io_wq, io_cancel_cb, sqe_addr);
	switch (cancel_ret) {
	case IO_WQ_CANCEL_OK:
		ret = 0;
		break;
	case IO_WQ_CANCEL_RUNNING:
		ret = -EALREADY;
		break;
	case IO_WQ_CANCEL_NOTFOUND:
		ret = -ENOENT;
		break;
	}

2440 2441 2442
	return ret;
}

2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
static void io_async_find_and_cancel(struct io_ring_ctx *ctx,
				     struct io_kiocb *req, __u64 sqe_addr,
				     struct io_kiocb **nxt)
{
	unsigned long flags;
	int ret;

	ret = io_async_cancel_one(ctx, (void *) (unsigned long) sqe_addr);
	if (ret != -ENOENT) {
		spin_lock_irqsave(&ctx->completion_lock, flags);
		goto done;
	}

	spin_lock_irqsave(&ctx->completion_lock, flags);
	ret = io_timeout_cancel(ctx, sqe_addr);
	if (ret != -ENOENT)
		goto done;
	ret = io_poll_cancel(ctx, sqe_addr);
done:
	io_cqring_fill_event(req, ret);
	io_commit_cqring(ctx);
	spin_unlock_irqrestore(&ctx->completion_lock, flags);
	io_cqring_ev_posted(ctx);

	if (ret < 0 && (req->flags & REQ_F_LINK))
		req->flags |= REQ_F_FAIL_LINK;
	io_put_req_find_next(req, nxt);
}

2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
static int io_async_cancel(struct io_kiocb *req, const struct io_uring_sqe *sqe,
			   struct io_kiocb **nxt)
{
	struct io_ring_ctx *ctx = req->ctx;

	if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
		return -EINVAL;
	if (sqe->flags || sqe->ioprio || sqe->off || sqe->len ||
	    sqe->cancel_flags)
		return -EINVAL;

2483
	io_async_find_and_cancel(ctx, req, READ_ONCE(sqe->addr), nxt);
J
Jens Axboe 已提交
2484 2485 2486
	return 0;
}

2487
static int io_req_defer(struct io_kiocb *req)
2488
{
2489
	const struct io_uring_sqe *sqe = req->submit.sqe;
2490
	struct io_uring_sqe *sqe_copy;
2491
	struct io_ring_ctx *ctx = req->ctx;
2492

B
Bob Liu 已提交
2493 2494
	/* Still need defer if there is pending req in defer list. */
	if (!req_need_defer(req) && list_empty(&ctx->defer_list))
2495 2496 2497 2498 2499 2500 2501
		return 0;

	sqe_copy = kmalloc(sizeof(*sqe_copy), GFP_KERNEL);
	if (!sqe_copy)
		return -EAGAIN;

	spin_lock_irq(&ctx->completion_lock);
B
Bob Liu 已提交
2502
	if (!req_need_defer(req) && list_empty(&ctx->defer_list)) {
2503 2504 2505 2506 2507 2508 2509 2510
		spin_unlock_irq(&ctx->completion_lock);
		kfree(sqe_copy);
		return 0;
	}

	memcpy(sqe_copy, sqe, sizeof(*sqe_copy));
	req->submit.sqe = sqe_copy;

2511
	trace_io_uring_defer(ctx, req, false);
2512 2513 2514 2515 2516
	list_add_tail(&req->list, &ctx->defer_list);
	spin_unlock_irq(&ctx->completion_lock);
	return -EIOCBQUEUED;
}

2517 2518
static int __io_submit_sqe(struct io_kiocb *req, struct io_kiocb **nxt,
			   bool force_nonblock)
J
Jens Axboe 已提交
2519
{
2520
	int ret, opcode;
2521
	struct sqe_submit *s = &req->submit;
2522
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
2523 2524 2525 2526

	opcode = READ_ONCE(s->sqe->opcode);
	switch (opcode) {
	case IORING_OP_NOP:
2527
		ret = io_nop(req);
J
Jens Axboe 已提交
2528 2529
		break;
	case IORING_OP_READV:
2530 2531
		if (unlikely(s->sqe->buf_index))
			return -EINVAL;
2532
		ret = io_read(req, nxt, force_nonblock);
J
Jens Axboe 已提交
2533 2534
		break;
	case IORING_OP_WRITEV:
2535 2536
		if (unlikely(s->sqe->buf_index))
			return -EINVAL;
2537
		ret = io_write(req, nxt, force_nonblock);
2538 2539
		break;
	case IORING_OP_READ_FIXED:
2540
		ret = io_read(req, nxt, force_nonblock);
2541 2542
		break;
	case IORING_OP_WRITE_FIXED:
2543
		ret = io_write(req, nxt, force_nonblock);
J
Jens Axboe 已提交
2544
		break;
C
Christoph Hellwig 已提交
2545
	case IORING_OP_FSYNC:
2546
		ret = io_fsync(req, s->sqe, nxt, force_nonblock);
C
Christoph Hellwig 已提交
2547
		break;
2548
	case IORING_OP_POLL_ADD:
2549
		ret = io_poll_add(req, s->sqe, nxt);
2550 2551 2552 2553
		break;
	case IORING_OP_POLL_REMOVE:
		ret = io_poll_remove(req, s->sqe);
		break;
2554
	case IORING_OP_SYNC_FILE_RANGE:
2555
		ret = io_sync_file_range(req, s->sqe, nxt, force_nonblock);
2556
		break;
J
Jens Axboe 已提交
2557
	case IORING_OP_SENDMSG:
2558
		ret = io_sendmsg(req, s->sqe, nxt, force_nonblock);
J
Jens Axboe 已提交
2559
		break;
J
Jens Axboe 已提交
2560
	case IORING_OP_RECVMSG:
2561
		ret = io_recvmsg(req, s->sqe, nxt, force_nonblock);
J
Jens Axboe 已提交
2562
		break;
J
Jens Axboe 已提交
2563 2564 2565
	case IORING_OP_TIMEOUT:
		ret = io_timeout(req, s->sqe);
		break;
2566 2567 2568
	case IORING_OP_TIMEOUT_REMOVE:
		ret = io_timeout_remove(req, s->sqe);
		break;
2569 2570 2571
	case IORING_OP_ACCEPT:
		ret = io_accept(req, s->sqe, nxt, force_nonblock);
		break;
2572 2573 2574
	case IORING_OP_ASYNC_CANCEL:
		ret = io_async_cancel(req, s->sqe, nxt);
		break;
J
Jens Axboe 已提交
2575 2576 2577 2578 2579
	default:
		ret = -EINVAL;
		break;
	}

J
Jens Axboe 已提交
2580 2581 2582 2583
	if (ret)
		return ret;

	if (ctx->flags & IORING_SETUP_IOPOLL) {
J
Jens Axboe 已提交
2584
		if (req->result == -EAGAIN)
J
Jens Axboe 已提交
2585 2586 2587
			return -EAGAIN;

		/* workqueue context doesn't hold uring_lock, grab it now */
2588
		if (s->in_async)
J
Jens Axboe 已提交
2589 2590
			mutex_lock(&ctx->uring_lock);
		io_iopoll_req_issued(req);
2591
		if (s->in_async)
J
Jens Axboe 已提交
2592 2593 2594 2595
			mutex_unlock(&ctx->uring_lock);
	}

	return 0;
J
Jens Axboe 已提交
2596 2597
}

2598
static void io_wq_submit_work(struct io_wq_work **workptr)
J
Jens Axboe 已提交
2599
{
2600
	struct io_wq_work *work = *workptr;
J
Jens Axboe 已提交
2601
	struct io_kiocb *req = container_of(work, struct io_kiocb, work);
2602 2603 2604 2605
	struct sqe_submit *s = &req->submit;
	const struct io_uring_sqe *sqe = s->sqe;
	struct io_kiocb *nxt = NULL;
	int ret = 0;
J
Jens Axboe 已提交
2606

2607 2608
	/* Ensure we clear previously set non-block flag */
	req->rw.ki_flags &= ~IOCB_NOWAIT;
J
Jens Axboe 已提交
2609

2610 2611
	if (work->flags & IO_WQ_WORK_CANCEL)
		ret = -ECANCELED;
2612

2613 2614 2615 2616
	if (!ret) {
		s->has_user = (work->flags & IO_WQ_WORK_HAS_MM) != 0;
		s->in_async = true;
		do {
2617
			ret = __io_submit_sqe(req, &nxt, false);
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
			/*
			 * We can get EAGAIN for polled IO even though we're
			 * forcing a sync submission from here, since we can't
			 * wait for request slots on the block side.
			 */
			if (ret != -EAGAIN)
				break;
			cond_resched();
		} while (1);
	}
2628

2629
	/* drop submission reference */
2630
	io_put_req(req);
2631

2632
	if (ret) {
2633 2634
		if (req->flags & REQ_F_LINK)
			req->flags |= REQ_F_FAIL_LINK;
2635
		io_cqring_add_event(req, ret);
2636
		io_put_req(req);
2637
	}
J
Jens Axboe 已提交
2638

2639 2640
	/* async context always use a copy of the sqe */
	kfree(sqe);
J
Jens Axboe 已提交
2641

2642 2643 2644 2645
	/* if a dependent link is ready, pass it back */
	if (!ret && nxt) {
		io_prep_async_work(nxt);
		*workptr = &nxt->work;
2646
	}
J
Jens Axboe 已提交
2647 2648
}

J
Jens Axboe 已提交
2649 2650 2651 2652 2653 2654 2655
static bool io_op_needs_file(const struct io_uring_sqe *sqe)
{
	int op = READ_ONCE(sqe->opcode);

	switch (op) {
	case IORING_OP_NOP:
	case IORING_OP_POLL_REMOVE:
2656
	case IORING_OP_TIMEOUT:
2657 2658 2659
	case IORING_OP_TIMEOUT_REMOVE:
	case IORING_OP_ASYNC_CANCEL:
	case IORING_OP_LINK_TIMEOUT:
J
Jens Axboe 已提交
2660 2661 2662 2663 2664 2665
		return false;
	default:
		return true;
	}
}

2666 2667 2668 2669 2670 2671 2672 2673 2674
static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
					      int index)
{
	struct fixed_file_table *table;

	table = &ctx->file_table[index >> IORING_FILE_TABLE_SHIFT];
	return table->files[index & IORING_FILE_TABLE_MASK];
}

2675
static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req)
J
Jens Axboe 已提交
2676
{
2677
	struct sqe_submit *s = &req->submit;
2678
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
2679 2680 2681 2682 2683 2684
	unsigned flags;
	int fd;

	flags = READ_ONCE(s->sqe->flags);
	fd = READ_ONCE(s->sqe->fd);

2685
	if (flags & IOSQE_IO_DRAIN)
2686
		req->flags |= REQ_F_IO_DRAIN;
2687 2688 2689 2690 2691 2692
	/*
	 * All io need record the previous position, if LINK vs DARIN,
	 * it can be used to mark the position of the first IO in the
	 * link list.
	 */
	req->sequence = s->sequence;
2693

2694
	if (!io_op_needs_file(s->sqe))
J
Jens Axboe 已提交
2695 2696 2697
		return 0;

	if (flags & IOSQE_FIXED_FILE) {
2698
		if (unlikely(!ctx->file_table ||
J
Jens Axboe 已提交
2699 2700
		    (unsigned) fd >= ctx->nr_user_files))
			return -EBADF;
2701
		fd = array_index_nospec(fd, ctx->nr_user_files);
2702 2703
		req->file = io_file_from_index(ctx, fd);
		if (!req->file)
2704
			return -EBADF;
J
Jens Axboe 已提交
2705 2706 2707 2708
		req->flags |= REQ_F_FIXED_FILE;
	} else {
		if (s->needs_fixed_file)
			return -EBADF;
2709
		trace_io_uring_file_get(ctx, fd);
J
Jens Axboe 已提交
2710 2711 2712 2713 2714 2715 2716 2717
		req->file = io_file_get(state, fd);
		if (unlikely(!req->file))
			return -EBADF;
	}

	return 0;
}

2718
static int io_grab_files(struct io_kiocb *req)
2719 2720
{
	int ret = -EBADF;
2721
	struct io_ring_ctx *ctx = req->ctx;
2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742

	rcu_read_lock();
	spin_lock_irq(&ctx->inflight_lock);
	/*
	 * We use the f_ops->flush() handler to ensure that we can flush
	 * out work accessing these files if the fd is closed. Check if
	 * the fd has changed since we started down this path, and disallow
	 * this operation if it has.
	 */
	if (fcheck(req->submit.ring_fd) == req->submit.ring_file) {
		list_add(&req->inflight_entry, &ctx->inflight_list);
		req->flags |= REQ_F_INFLIGHT;
		req->work.files = current->files;
		ret = 0;
	}
	spin_unlock_irq(&ctx->inflight_lock);
	rcu_read_unlock();

	return ret;
}

2743
static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer)
J
Jens Axboe 已提交
2744
{
2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758
	struct io_kiocb *req = container_of(timer, struct io_kiocb,
						timeout.timer);
	struct io_ring_ctx *ctx = req->ctx;
	struct io_kiocb *prev = NULL;
	unsigned long flags;

	spin_lock_irqsave(&ctx->completion_lock, flags);

	/*
	 * We don't expect the list to be empty, that will only happen if we
	 * race with the completion of the linked work.
	 */
	if (!list_empty(&req->list)) {
		prev = list_entry(req->list.prev, struct io_kiocb, link_list);
2759 2760 2761 2762
		if (refcount_inc_not_zero(&prev->refs))
			list_del_init(&req->list);
		else
			prev = NULL;
2763 2764 2765 2766 2767
	}

	spin_unlock_irqrestore(&ctx->completion_lock, flags);

	if (prev) {
2768
		io_async_find_and_cancel(ctx, req, prev->user_data, NULL);
2769
		io_put_req(prev);
2770 2771 2772
	} else {
		io_cqring_add_event(req, -ETIME);
		io_put_req(req);
2773 2774 2775 2776
	}
	return HRTIMER_NORESTART;
}

2777 2778
static void io_queue_linked_timeout(struct io_kiocb *req, struct timespec64 *ts,
				    enum hrtimer_mode *mode)
2779
{
2780
	struct io_ring_ctx *ctx = req->ctx;
2781

2782 2783 2784 2785 2786 2787 2788 2789 2790
	/*
	 * If the list is now empty, then our linked request finished before
	 * we got a chance to setup the timer
	 */
	spin_lock_irq(&ctx->completion_lock);
	if (!list_empty(&req->list)) {
		req->timeout.timer.function = io_link_timeout_fn;
		hrtimer_start(&req->timeout.timer, timespec64_to_ktime(*ts),
				*mode);
2791
	}
2792
	spin_unlock_irq(&ctx->completion_lock);
2793 2794

	/* drop submission reference */
2795 2796
	io_put_req(req);
}
2797

2798 2799 2800 2801 2802 2803 2804 2805 2806
static int io_validate_link_timeout(const struct io_uring_sqe *sqe,
				    struct timespec64 *ts)
{
	if (sqe->ioprio || sqe->buf_index || sqe->len != 1 || sqe->off)
		return -EINVAL;
	if (sqe->timeout_flags & ~IORING_TIMEOUT_ABS)
		return -EINVAL;
	if (get_timespec64(ts, u64_to_user_ptr(sqe->addr)))
		return -EFAULT;
2807

2808
	return 0;
2809 2810
}

2811 2812 2813
static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req,
					       struct timespec64 *ts,
					       enum hrtimer_mode *mode)
2814 2815
{
	struct io_kiocb *nxt;
2816
	int ret;
2817 2818 2819 2820 2821

	if (!(req->flags & REQ_F_LINK))
		return NULL;

	nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb, list);
2822 2823
	if (!nxt || nxt->submit.sqe->opcode != IORING_OP_LINK_TIMEOUT)
		return NULL;
2824

2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
	ret = io_validate_link_timeout(nxt->submit.sqe, ts);
	if (ret) {
		list_del_init(&nxt->list);
		io_cqring_add_event(nxt, ret);
		io_double_put_req(nxt);
		return ERR_PTR(-ECANCELED);
	}

	if (nxt->submit.sqe->timeout_flags & IORING_TIMEOUT_ABS)
		*mode = HRTIMER_MODE_ABS;
	else
		*mode = HRTIMER_MODE_REL;

	req->flags |= REQ_F_LINK_TIMEOUT;
	hrtimer_init(&nxt->timeout.timer, CLOCK_MONOTONIC, *mode);
	return nxt;
2841 2842
}

2843
static void __io_queue_sqe(struct io_kiocb *req)
J
Jens Axboe 已提交
2844
{
2845
	enum hrtimer_mode mode;
2846
	struct io_kiocb *nxt;
2847
	struct timespec64 ts;
2848
	int ret;
J
Jens Axboe 已提交
2849

2850 2851 2852 2853 2854
	nxt = io_prep_linked_timeout(req, &ts, &mode);
	if (IS_ERR(nxt)) {
		ret = PTR_ERR(nxt);
		nxt = NULL;
		goto err;
2855 2856
	}

2857
	ret = __io_submit_sqe(req, NULL, true);
2858 2859 2860 2861 2862 2863 2864

	/*
	 * We async punt it if the file wasn't marked NOWAIT, or if the file
	 * doesn't support non-blocking read/write attempts
	 */
	if (ret == -EAGAIN && (!(req->flags & REQ_F_NOWAIT) ||
	    (req->flags & REQ_F_MUST_PUNT))) {
2865
		struct sqe_submit *s = &req->submit;
J
Jens Axboe 已提交
2866 2867
		struct io_uring_sqe *sqe_copy;

2868
		sqe_copy = kmemdup(s->sqe, sizeof(*sqe_copy), GFP_KERNEL);
J
Jens Axboe 已提交
2869 2870
		if (sqe_copy) {
			s->sqe = sqe_copy;
2871
			if (req->work.flags & IO_WQ_WORK_NEEDS_FILES) {
2872
				ret = io_grab_files(req);
2873 2874 2875 2876
				if (ret) {
					kfree(sqe_copy);
					goto err;
				}
2877
			}
2878 2879 2880

			/*
			 * Queued up for async execution, worker will release
J
Jens Axboe 已提交
2881
			 * submit reference when the iocb is actually submitted.
2882
			 */
2883
			io_queue_async_work(req);
2884 2885 2886 2887

			if (nxt)
				io_queue_linked_timeout(nxt, &ts, &mode);

2888
			return;
J
Jens Axboe 已提交
2889 2890
		}
	}
2891

2892
err:
2893
	/* drop submission reference */
2894
	io_put_req(req);
2895

2896 2897 2898 2899 2900 2901 2902
	if (nxt) {
		if (!ret)
			io_queue_linked_timeout(nxt, &ts, &mode);
		else
			io_put_req(nxt);
	}

2903
	/* and drop final reference, if we failed */
J
Jens Axboe 已提交
2904
	if (ret) {
2905
		io_cqring_add_event(req, ret);
J
Jens Axboe 已提交
2906 2907
		if (req->flags & REQ_F_LINK)
			req->flags |= REQ_F_FAIL_LINK;
2908
		io_put_req(req);
J
Jens Axboe 已提交
2909
	}
J
Jens Axboe 已提交
2910 2911
}

2912
static void io_queue_sqe(struct io_kiocb *req)
2913 2914 2915
{
	int ret;

2916
	ret = io_req_defer(req);
2917 2918
	if (ret) {
		if (ret != -EIOCBQUEUED) {
2919 2920
			io_cqring_add_event(req, ret);
			io_double_put_req(req);
2921
		}
2922 2923
	} else
		__io_queue_sqe(req);
2924 2925
}

2926
static void io_queue_link_head(struct io_kiocb *req, struct io_kiocb *shadow)
2927 2928 2929
{
	int ret;
	int need_submit = false;
2930
	struct io_ring_ctx *ctx = req->ctx;
2931

2932 2933 2934 2935
	if (!shadow) {
		io_queue_sqe(req);
		return;
	}
2936 2937 2938 2939 2940 2941 2942

	/*
	 * Mark the first IO in link list as DRAIN, let all the following
	 * IOs enter the defer list. all IO needs to be completed before link
	 * list.
	 */
	req->flags |= REQ_F_IO_DRAIN;
2943
	ret = io_req_defer(req);
2944 2945
	if (ret) {
		if (ret != -EIOCBQUEUED) {
2946 2947
			io_cqring_add_event(req, ret);
			io_double_put_req(req);
P
Pavel Begunkov 已提交
2948
			__io_free_req(shadow);
2949
			return;
2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
		}
	} else {
		/*
		 * If ret == 0 means that all IOs in front of link io are
		 * running done. let's queue link head.
		 */
		need_submit = true;
	}

	/* Insert shadow req to defer_list, blocking next IOs */
	spin_lock_irq(&ctx->completion_lock);
2961
	trace_io_uring_defer(ctx, shadow, true);
2962 2963 2964 2965
	list_add_tail(&shadow->list, &ctx->defer_list);
	spin_unlock_irq(&ctx->completion_lock);

	if (need_submit)
2966
		__io_queue_sqe(req);
2967 2968
}

J
Jens Axboe 已提交
2969 2970
#define SQE_VALID_FLAGS	(IOSQE_FIXED_FILE|IOSQE_IO_DRAIN|IOSQE_IO_LINK)

2971 2972
static void io_submit_sqe(struct io_kiocb *req, struct io_submit_state *state,
			  struct io_kiocb **link)
J
Jens Axboe 已提交
2973 2974
{
	struct io_uring_sqe *sqe_copy;
2975
	struct sqe_submit *s = &req->submit;
2976
	struct io_ring_ctx *ctx = req->ctx;
J
Jens Axboe 已提交
2977 2978
	int ret;

2979 2980
	req->user_data = s->sqe->user_data;

J
Jens Axboe 已提交
2981 2982 2983
	/* enforce forwards compatibility on users */
	if (unlikely(s->sqe->flags & ~SQE_VALID_FLAGS)) {
		ret = -EINVAL;
2984
		goto err_req;
J
Jens Axboe 已提交
2985 2986
	}

2987
	ret = io_req_set_file(state, req);
J
Jens Axboe 已提交
2988 2989
	if (unlikely(ret)) {
err_req:
2990 2991
		io_cqring_add_event(req, ret);
		io_double_put_req(req);
J
Jens Axboe 已提交
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
		return;
	}

	/*
	 * If we already have a head request, queue this one for async
	 * submittal once the head completes. If we don't have a head but
	 * IOSQE_IO_LINK is set in the sqe, start a new head. This one will be
	 * submitted sync once the chain is complete. If none of those
	 * conditions are true (normal request), then just queue it.
	 */
	if (*link) {
		struct io_kiocb *prev = *link;

		sqe_copy = kmemdup(s->sqe, sizeof(*sqe_copy), GFP_KERNEL);
		if (!sqe_copy) {
			ret = -EAGAIN;
			goto err_req;
		}

		s->sqe = sqe_copy;
3012
		trace_io_uring_link(ctx, req, prev);
J
Jens Axboe 已提交
3013 3014 3015 3016 3017 3018
		list_add_tail(&req->list, &prev->link_list);
	} else if (s->sqe->flags & IOSQE_IO_LINK) {
		req->flags |= REQ_F_LINK;

		INIT_LIST_HEAD(&req->link_list);
		*link = req;
3019 3020 3021 3022
	} else if (READ_ONCE(s->sqe->opcode) == IORING_OP_LINK_TIMEOUT) {
		/* Only valid as a linked SQE */
		ret = -EINVAL;
		goto err_req;
J
Jens Axboe 已提交
3023
	} else {
3024
		io_queue_sqe(req);
J
Jens Axboe 已提交
3025 3026 3027
	}
}

3028 3029 3030 3031 3032 3033
/*
 * Batched submission is done, ensure local IO is flushed out.
 */
static void io_submit_state_end(struct io_submit_state *state)
{
	blk_finish_plug(&state->plug);
3034
	io_file_put(state);
J
Jens Axboe 已提交
3035 3036 3037
	if (state->free_reqs)
		kmem_cache_free_bulk(req_cachep, state->free_reqs,
					&state->reqs[state->cur_req]);
3038 3039 3040 3041 3042 3043 3044 3045 3046
}

/*
 * Start submission side cache.
 */
static void io_submit_state_start(struct io_submit_state *state,
				  struct io_ring_ctx *ctx, unsigned max_ios)
{
	blk_start_plug(&state->plug);
J
Jens Axboe 已提交
3047
	state->free_reqs = 0;
3048 3049 3050 3051
	state->file = NULL;
	state->ios_left = max_ios;
}

J
Jens Axboe 已提交
3052 3053
static void io_commit_sqring(struct io_ring_ctx *ctx)
{
3054
	struct io_rings *rings = ctx->rings;
J
Jens Axboe 已提交
3055

3056
	if (ctx->cached_sq_head != READ_ONCE(rings->sq.head)) {
J
Jens Axboe 已提交
3057 3058 3059 3060 3061
		/*
		 * Ensure any loads from the SQEs are done at this point,
		 * since once we write the new head, the application could
		 * write new data to them.
		 */
3062
		smp_store_release(&rings->sq.head, ctx->cached_sq_head);
J
Jens Axboe 已提交
3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075
	}
}

/*
 * Fetch an sqe, if one is available. Note that s->sqe will point to memory
 * that is mapped by userspace. This means that care needs to be taken to
 * ensure that reads are stable, as we cannot rely on userspace always
 * being a good citizen. If members of the sqe are validated and then later
 * used, it's important that those reads are done through READ_ONCE() to
 * prevent a re-load down the line.
 */
static bool io_get_sqring(struct io_ring_ctx *ctx, struct sqe_submit *s)
{
3076 3077
	struct io_rings *rings = ctx->rings;
	u32 *sq_array = ctx->sq_array;
J
Jens Axboe 已提交
3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088
	unsigned head;

	/*
	 * The cached sq head (or cq tail) serves two purposes:
	 *
	 * 1) allows us to batch the cost of updating the user visible
	 *    head updates.
	 * 2) allows the kernel side to track the head on its own, even
	 *    though the application is the one updating it.
	 */
	head = ctx->cached_sq_head;
3089
	/* make sure SQ entry isn't read before tail */
3090
	if (head == smp_load_acquire(&rings->sq.tail))
J
Jens Axboe 已提交
3091 3092
		return false;

3093
	head = READ_ONCE(sq_array[head & ctx->sq_mask]);
J
Jens Axboe 已提交
3094
	if (head < ctx->sq_entries) {
3095
		s->ring_file = NULL;
J
Jens Axboe 已提交
3096
		s->sqe = &ctx->sq_sqes[head];
3097
		s->sequence = ctx->cached_sq_head;
J
Jens Axboe 已提交
3098 3099 3100 3101 3102 3103
		ctx->cached_sq_head++;
		return true;
	}

	/* drop invalid entries */
	ctx->cached_sq_head++;
3104 3105
	ctx->cached_sq_dropped++;
	WRITE_ONCE(rings->sq_dropped, ctx->cached_sq_dropped);
J
Jens Axboe 已提交
3106 3107 3108
	return false;
}

3109
static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr,
3110 3111
			  struct file *ring_file, int ring_fd,
			  struct mm_struct **mm, bool async)
J
Jens Axboe 已提交
3112 3113
{
	struct io_submit_state state, *statep = NULL;
J
Jens Axboe 已提交
3114
	struct io_kiocb *link = NULL;
3115
	struct io_kiocb *shadow_req = NULL;
J
Jens Axboe 已提交
3116
	int i, submitted = 0;
3117
	bool mm_fault = false;
J
Jens Axboe 已提交
3118

3119 3120 3121 3122
	if (!list_empty(&ctx->cq_overflow_list)) {
		io_cqring_overflow_flush(ctx, false);
		return -EBUSY;
	}
J
Jens Axboe 已提交
3123 3124 3125 3126 3127 3128 3129

	if (nr > IO_PLUG_THRESHOLD) {
		io_submit_state_start(&state, ctx, nr);
		statep = &state;
	}

	for (i = 0; i < nr; i++) {
3130
		struct io_kiocb *req;
3131
		unsigned int sqe_flags;
3132

3133 3134 3135 3136
		req = io_get_req(ctx, statep);
		if (unlikely(!req)) {
			if (!submitted)
				submitted = -EAGAIN;
3137
			break;
3138
		}
3139
		if (!io_get_sqring(ctx, &req->submit)) {
3140 3141 3142
			__io_free_req(req);
			break;
		}
3143

3144
		if (io_sqe_needs_user(req->submit.sqe) && !*mm) {
3145 3146 3147 3148 3149
			mm_fault = mm_fault || !mmget_not_zero(ctx->sqo_mm);
			if (!mm_fault) {
				use_mm(ctx->sqo_mm);
				*mm = ctx->sqo_mm;
			}
J
Jens Axboe 已提交
3150 3151
		}

3152 3153 3154
		sqe_flags = req->submit.sqe->flags;

		if (link && (sqe_flags & IOSQE_IO_DRAIN)) {
3155 3156
			if (!shadow_req) {
				shadow_req = io_get_req(ctx, NULL);
3157 3158
				if (unlikely(!shadow_req))
					goto out;
3159 3160 3161
				shadow_req->flags |= (REQ_F_IO_DRAIN | REQ_F_SHADOW_DRAIN);
				refcount_dec(&shadow_req->refs);
			}
3162
			shadow_req->sequence = req->submit.sequence;
3163 3164
		}

3165
out:
3166 3167 3168 3169 3170 3171 3172
		req->submit.ring_file = ring_file;
		req->submit.ring_fd = ring_fd;
		req->submit.has_user = *mm != NULL;
		req->submit.in_async = async;
		req->submit.needs_fixed_file = async;
		trace_io_uring_submit_sqe(ctx, req->submit.sqe->user_data,
					  true, async);
3173
		io_submit_sqe(req, statep, &link);
3174
		submitted++;
3175 3176 3177 3178 3179

		/*
		 * If previous wasn't linked and we have a linked command,
		 * that's the end of the chain. Submit the previous link.
		 */
3180
		if (!(sqe_flags & IOSQE_IO_LINK) && link) {
3181
			io_queue_link_head(link, shadow_req);
3182 3183
			link = NULL;
			shadow_req = NULL;
J
Jens Axboe 已提交
3184 3185 3186
		}
	}

J
Jens Axboe 已提交
3187
	if (link)
3188
		io_queue_link_head(link, shadow_req);
J
Jens Axboe 已提交
3189 3190 3191
	if (statep)
		io_submit_state_end(&state);

3192 3193 3194
	 /* Commit SQ ring head once we've consumed and submitted all SQEs */
	io_commit_sqring(ctx);

J
Jens Axboe 已提交
3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
	return submitted;
}

static int io_sq_thread(void *data)
{
	struct io_ring_ctx *ctx = data;
	struct mm_struct *cur_mm = NULL;
	mm_segment_t old_fs;
	DEFINE_WAIT(wait);
	unsigned inflight;
	unsigned long timeout;
3206
	int ret;
J
Jens Axboe 已提交
3207

3208
	complete(&ctx->completions[1]);
3209

J
Jens Axboe 已提交
3210 3211 3212
	old_fs = get_fs();
	set_fs(USER_DS);

3213
	ret = timeout = inflight = 0;
3214
	while (!kthread_should_park()) {
3215
		unsigned int to_submit;
J
Jens Axboe 已提交
3216 3217 3218 3219 3220

		if (inflight) {
			unsigned nr_events = 0;

			if (ctx->flags & IORING_SETUP_IOPOLL) {
3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234
				/*
				 * inflight is the count of the maximum possible
				 * entries we submitted, but it can be smaller
				 * if we dropped some of them. If we don't have
				 * poll entries available, then we know that we
				 * have nothing left to poll for. Reset the
				 * inflight count to zero in that case.
				 */
				mutex_lock(&ctx->uring_lock);
				if (!list_empty(&ctx->poll_list))
					__io_iopoll_check(ctx, &nr_events, 0);
				else
					inflight = 0;
				mutex_unlock(&ctx->uring_lock);
J
Jens Axboe 已提交
3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247
			} else {
				/*
				 * Normal IO, just pretend everything completed.
				 * We don't have to poll completions for that.
				 */
				nr_events = inflight;
			}

			inflight -= nr_events;
			if (!inflight)
				timeout = jiffies + ctx->sq_thread_idle;
		}

3248
		to_submit = io_sqring_entries(ctx);
3249 3250 3251 3252 3253 3254

		/*
		 * If submit got -EBUSY, flag us as needing the application
		 * to enter the kernel to reap and flush events.
		 */
		if (!to_submit || ret == -EBUSY) {
J
Jens Axboe 已提交
3255 3256 3257
			/*
			 * We're polling. If we're within the defined idle
			 * period, then let us spin without work before going
3258 3259 3260
			 * to sleep. The exception is if we got EBUSY doing
			 * more IO, we should wait for the application to
			 * reap events and wake us up.
J
Jens Axboe 已提交
3261
			 */
3262 3263
			if (inflight ||
			    (!time_after(jiffies, timeout) && ret != -EBUSY)) {
3264
				cond_resched();
J
Jens Axboe 已提交
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283
				continue;
			}

			/*
			 * Drop cur_mm before scheduling, we can't hold it for
			 * long periods (or over schedule()). Do this before
			 * adding ourselves to the waitqueue, as the unuse/drop
			 * may sleep.
			 */
			if (cur_mm) {
				unuse_mm(cur_mm);
				mmput(cur_mm);
				cur_mm = NULL;
			}

			prepare_to_wait(&ctx->sqo_wait, &wait,
						TASK_INTERRUPTIBLE);

			/* Tell userspace we may need a wakeup call */
3284
			ctx->rings->sq_flags |= IORING_SQ_NEED_WAKEUP;
3285 3286
			/* make sure to read SQ tail after writing flags */
			smp_mb();
J
Jens Axboe 已提交
3287

3288
			to_submit = io_sqring_entries(ctx);
3289
			if (!to_submit || ret == -EBUSY) {
3290
				if (kthread_should_park()) {
J
Jens Axboe 已提交
3291 3292 3293 3294 3295 3296 3297 3298
					finish_wait(&ctx->sqo_wait, &wait);
					break;
				}
				if (signal_pending(current))
					flush_signals(current);
				schedule();
				finish_wait(&ctx->sqo_wait, &wait);

3299
				ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
J
Jens Axboe 已提交
3300 3301 3302 3303
				continue;
			}
			finish_wait(&ctx->sqo_wait, &wait);

3304
			ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
J
Jens Axboe 已提交
3305 3306
		}

3307
		to_submit = min(to_submit, ctx->sq_entries);
3308 3309 3310
		ret = io_submit_sqes(ctx, to_submit, NULL, -1, &cur_mm, true);
		if (ret > 0)
			inflight += ret;
J
Jens Axboe 已提交
3311 3312 3313 3314 3315 3316 3317
	}

	set_fs(old_fs);
	if (cur_mm) {
		unuse_mm(cur_mm);
		mmput(cur_mm);
	}
3318

3319
	kthread_parkme();
3320

J
Jens Axboe 已提交
3321 3322 3323
	return 0;
}

3324 3325 3326 3327 3328 3329 3330
struct io_wait_queue {
	struct wait_queue_entry wq;
	struct io_ring_ctx *ctx;
	unsigned to_wait;
	unsigned nr_timeouts;
};

3331
static inline bool io_should_wake(struct io_wait_queue *iowq, bool noflush)
3332 3333 3334 3335 3336 3337 3338 3339
{
	struct io_ring_ctx *ctx = iowq->ctx;

	/*
	 * Wake up if we have enough events, or if a timeout occured since we
	 * started waiting. For timeouts, we always want to return to userspace,
	 * regardless of event count.
	 */
3340
	return io_cqring_events(ctx, noflush) >= iowq->to_wait ||
3341 3342 3343 3344 3345 3346 3347 3348 3349
			atomic_read(&ctx->cq_timeouts) != iowq->nr_timeouts;
}

static int io_wake_function(struct wait_queue_entry *curr, unsigned int mode,
			    int wake_flags, void *key)
{
	struct io_wait_queue *iowq = container_of(curr, struct io_wait_queue,
							wq);

3350 3351
	/* use noflush == true, as we can't safely rely on locking context */
	if (!io_should_wake(iowq, true))
3352 3353 3354 3355 3356
		return -1;

	return autoremove_wake_function(curr, mode, wake_flags, key);
}

J
Jens Axboe 已提交
3357 3358 3359 3360 3361 3362 3363
/*
 * Wait until events become available, if we don't already have some. The
 * application must reap them itself, as they reside on the shared cq ring.
 */
static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
			  const sigset_t __user *sig, size_t sigsz)
{
3364 3365 3366 3367 3368 3369 3370 3371 3372
	struct io_wait_queue iowq = {
		.wq = {
			.private	= current,
			.func		= io_wake_function,
			.entry		= LIST_HEAD_INIT(iowq.wq.entry),
		},
		.ctx		= ctx,
		.to_wait	= min_events,
	};
3373
	struct io_rings *rings = ctx->rings;
3374
	int ret = 0;
J
Jens Axboe 已提交
3375

3376
	if (io_cqring_events(ctx, false) >= min_events)
J
Jens Axboe 已提交
3377 3378 3379
		return 0;

	if (sig) {
3380 3381 3382
#ifdef CONFIG_COMPAT
		if (in_compat_syscall())
			ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
3383
						      sigsz);
3384 3385
		else
#endif
3386
			ret = set_user_sigmask(sig, sigsz);
3387

J
Jens Axboe 已提交
3388 3389 3390 3391
		if (ret)
			return ret;
	}

3392
	iowq.nr_timeouts = atomic_read(&ctx->cq_timeouts);
3393
	trace_io_uring_cqring_wait(ctx, min_events);
3394 3395 3396
	do {
		prepare_to_wait_exclusive(&ctx->wait, &iowq.wq,
						TASK_INTERRUPTIBLE);
3397
		if (io_should_wake(&iowq, false))
3398 3399 3400
			break;
		schedule();
		if (signal_pending(current)) {
3401
			ret = -EINTR;
3402 3403 3404 3405 3406
			break;
		}
	} while (1);
	finish_wait(&ctx->wait, &iowq.wq);

3407
	restore_saved_sigmask_unless(ret == -EINTR);
J
Jens Axboe 已提交
3408

3409
	return READ_ONCE(rings->cq.head) == READ_ONCE(rings->cq.tail) ? ret : 0;
J
Jens Axboe 已提交
3410 3411
}

J
Jens Axboe 已提交
3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424
static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
{
#if defined(CONFIG_UNIX)
	if (ctx->ring_sock) {
		struct sock *sock = ctx->ring_sock->sk;
		struct sk_buff *skb;

		while ((skb = skb_dequeue(&sock->sk_receive_queue)) != NULL)
			kfree_skb(skb);
	}
#else
	int i;

3425 3426 3427 3428 3429 3430 3431
	for (i = 0; i < ctx->nr_user_files; i++) {
		struct file *file;

		file = io_file_from_index(ctx, i);
		if (file)
			fput(file);
	}
J
Jens Axboe 已提交
3432 3433 3434 3435 3436
#endif
}

static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
{
3437 3438 3439
	unsigned nr_tables, i;

	if (!ctx->file_table)
J
Jens Axboe 已提交
3440 3441 3442
		return -ENXIO;

	__io_sqe_files_unregister(ctx);
3443 3444 3445 3446 3447
	nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE);
	for (i = 0; i < nr_tables; i++)
		kfree(ctx->file_table[i].files);
	kfree(ctx->file_table);
	ctx->file_table = NULL;
J
Jens Axboe 已提交
3448 3449 3450 3451
	ctx->nr_user_files = 0;
	return 0;
}

J
Jens Axboe 已提交
3452 3453 3454
static void io_sq_thread_stop(struct io_ring_ctx *ctx)
{
	if (ctx->sqo_thread) {
3455
		wait_for_completion(&ctx->completions[1]);
3456 3457 3458 3459 3460
		/*
		 * The park is a bit of a work-around, without it we get
		 * warning spews on shutdown with SQPOLL set and affinity
		 * set to a single CPU.
		 */
3461
		kthread_park(ctx->sqo_thread);
J
Jens Axboe 已提交
3462 3463 3464 3465 3466
		kthread_stop(ctx->sqo_thread);
		ctx->sqo_thread = NULL;
	}
}

J
Jens Axboe 已提交
3467 3468
static void io_finish_async(struct io_ring_ctx *ctx)
{
J
Jens Axboe 已提交
3469 3470
	io_sq_thread_stop(ctx);

3471 3472 3473
	if (ctx->io_wq) {
		io_wq_destroy(ctx->io_wq);
		ctx->io_wq = NULL;
J
Jens Axboe 已提交
3474 3475 3476 3477 3478 3479 3480
	}
}

#if defined(CONFIG_UNIX)
static void io_destruct_skb(struct sk_buff *skb)
{
	struct io_ring_ctx *ctx = skb->sk->sk_user_data;
3481

3482 3483
	if (ctx->io_wq)
		io_wq_flush(ctx->io_wq);
J
Jens Axboe 已提交
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497

	unix_destruct_scm(skb);
}

/*
 * Ensure the UNIX gc is aware of our file set, so we are certain that
 * the io_uring can be safely unregistered on process exit, even if we have
 * loops in the file referencing.
 */
static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset)
{
	struct sock *sk = ctx->ring_sock->sk;
	struct scm_fp_list *fpl;
	struct sk_buff *skb;
3498
	int i, nr_files;
J
Jens Axboe 已提交
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518

	if (!capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) {
		unsigned long inflight = ctx->user->unix_inflight + nr;

		if (inflight > task_rlimit(current, RLIMIT_NOFILE))
			return -EMFILE;
	}

	fpl = kzalloc(sizeof(*fpl), GFP_KERNEL);
	if (!fpl)
		return -ENOMEM;

	skb = alloc_skb(0, GFP_KERNEL);
	if (!skb) {
		kfree(fpl);
		return -ENOMEM;
	}

	skb->sk = sk;

3519
	nr_files = 0;
J
Jens Axboe 已提交
3520 3521
	fpl->user = get_uid(ctx->user);
	for (i = 0; i < nr; i++) {
3522 3523 3524
		struct file *file = io_file_from_index(ctx, i + offset);

		if (!file)
3525
			continue;
3526
		fpl->fp[nr_files] = get_file(file);
3527 3528
		unix_inflight(fpl->user, fpl->fp[nr_files]);
		nr_files++;
J
Jens Axboe 已提交
3529 3530
	}

3531 3532 3533 3534 3535 3536 3537
	if (nr_files) {
		fpl->max = SCM_MAX_FD;
		fpl->count = nr_files;
		UNIXCB(skb).fp = fpl;
		skb->destructor = io_destruct_skb;
		refcount_add(skb->truesize, &sk->sk_wmem_alloc);
		skb_queue_head(&sk->sk_receive_queue, skb);
J
Jens Axboe 已提交
3538

3539 3540 3541 3542 3543 3544
		for (i = 0; i < nr_files; i++)
			fput(fpl->fp[i]);
	} else {
		kfree_skb(skb);
		kfree(fpl);
	}
J
Jens Axboe 已提交
3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574

	return 0;
}

/*
 * If UNIX sockets are enabled, fd passing can cause a reference cycle which
 * causes regular reference counting to break down. We rely on the UNIX
 * garbage collection to take care of this problem for us.
 */
static int io_sqe_files_scm(struct io_ring_ctx *ctx)
{
	unsigned left, total;
	int ret = 0;

	total = 0;
	left = ctx->nr_user_files;
	while (left) {
		unsigned this_files = min_t(unsigned, left, SCM_MAX_FD);

		ret = __io_sqe_files_scm(ctx, this_files, total);
		if (ret)
			break;
		left -= this_files;
		total += this_files;
	}

	if (!ret)
		return 0;

	while (total < ctx->nr_user_files) {
3575 3576 3577 3578
		struct file *file = io_file_from_index(ctx, total);

		if (file)
			fput(file);
J
Jens Axboe 已提交
3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
		total++;
	}

	return ret;
}
#else
static int io_sqe_files_scm(struct io_ring_ctx *ctx)
{
	return 0;
}
#endif

3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617
static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
				    unsigned nr_files)
{
	int i;

	for (i = 0; i < nr_tables; i++) {
		struct fixed_file_table *table = &ctx->file_table[i];
		unsigned this_files;

		this_files = min(nr_files, IORING_MAX_FILES_TABLE);
		table->files = kcalloc(this_files, sizeof(struct file *),
					GFP_KERNEL);
		if (!table->files)
			break;
		nr_files -= this_files;
	}

	if (i == nr_tables)
		return 0;

	for (i = 0; i < nr_tables; i++) {
		struct fixed_file_table *table = &ctx->file_table[i];
		kfree(table->files);
	}
	return 1;
}

J
Jens Axboe 已提交
3618 3619 3620 3621
static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
				 unsigned nr_args)
{
	__s32 __user *fds = (__s32 __user *) arg;
3622
	unsigned nr_tables;
J
Jens Axboe 已提交
3623 3624 3625
	int fd, ret = 0;
	unsigned i;

3626
	if (ctx->file_table)
J
Jens Axboe 已提交
3627 3628 3629 3630 3631 3632
		return -EBUSY;
	if (!nr_args)
		return -EINVAL;
	if (nr_args > IORING_MAX_FIXED_FILES)
		return -EMFILE;

3633 3634 3635 3636
	nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE);
	ctx->file_table = kcalloc(nr_tables, sizeof(struct fixed_file_table),
					GFP_KERNEL);
	if (!ctx->file_table)
J
Jens Axboe 已提交
3637 3638
		return -ENOMEM;

3639 3640
	if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) {
		kfree(ctx->file_table);
3641
		ctx->file_table = NULL;
3642 3643 3644
		return -ENOMEM;
	}

3645
	for (i = 0; i < nr_args; i++, ctx->nr_user_files++) {
3646 3647 3648
		struct fixed_file_table *table;
		unsigned index;

J
Jens Axboe 已提交
3649 3650 3651
		ret = -EFAULT;
		if (copy_from_user(&fd, &fds[i], sizeof(fd)))
			break;
3652 3653 3654 3655 3656
		/* allow sparse sets */
		if (fd == -1) {
			ret = 0;
			continue;
		}
J
Jens Axboe 已提交
3657

3658 3659 3660
		table = &ctx->file_table[i >> IORING_FILE_TABLE_SHIFT];
		index = i & IORING_FILE_TABLE_MASK;
		table->files[index] = fget(fd);
J
Jens Axboe 已提交
3661 3662

		ret = -EBADF;
3663
		if (!table->files[index])
J
Jens Axboe 已提交
3664 3665 3666 3667 3668 3669 3670 3671
			break;
		/*
		 * Don't allow io_uring instances to be registered. If UNIX
		 * isn't enabled, then this causes a reference cycle and this
		 * instance can never get freed. If UNIX is enabled we'll
		 * handle it just fine, but there's still no point in allowing
		 * a ring fd as it doesn't support regular read/write anyway.
		 */
3672 3673
		if (table->files[index]->f_op == &io_uring_fops) {
			fput(table->files[index]);
J
Jens Axboe 已提交
3674 3675 3676 3677 3678 3679
			break;
		}
		ret = 0;
	}

	if (ret) {
3680 3681
		for (i = 0; i < ctx->nr_user_files; i++) {
			struct file *file;
J
Jens Axboe 已提交
3682

3683 3684 3685 3686 3687 3688
			file = io_file_from_index(ctx, i);
			if (file)
				fput(file);
		}
		for (i = 0; i < nr_tables; i++)
			kfree(ctx->file_table[i].files);
J
Jens Axboe 已提交
3689

3690 3691
		kfree(ctx->file_table);
		ctx->file_table = NULL;
J
Jens Axboe 已提交
3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
		ctx->nr_user_files = 0;
		return ret;
	}

	ret = io_sqe_files_scm(ctx);
	if (ret)
		io_sqe_files_unregister(ctx);

	return ret;
}

3703 3704 3705
static void io_sqe_file_unregister(struct io_ring_ctx *ctx, int index)
{
#if defined(CONFIG_UNIX)
3706
	struct file *file = io_file_from_index(ctx, index);
3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761
	struct sock *sock = ctx->ring_sock->sk;
	struct sk_buff_head list, *head = &sock->sk_receive_queue;
	struct sk_buff *skb;
	int i;

	__skb_queue_head_init(&list);

	/*
	 * Find the skb that holds this file in its SCM_RIGHTS. When found,
	 * remove this entry and rearrange the file array.
	 */
	skb = skb_dequeue(head);
	while (skb) {
		struct scm_fp_list *fp;

		fp = UNIXCB(skb).fp;
		for (i = 0; i < fp->count; i++) {
			int left;

			if (fp->fp[i] != file)
				continue;

			unix_notinflight(fp->user, fp->fp[i]);
			left = fp->count - 1 - i;
			if (left) {
				memmove(&fp->fp[i], &fp->fp[i + 1],
						left * sizeof(struct file *));
			}
			fp->count--;
			if (!fp->count) {
				kfree_skb(skb);
				skb = NULL;
			} else {
				__skb_queue_tail(&list, skb);
			}
			fput(file);
			file = NULL;
			break;
		}

		if (!file)
			break;

		__skb_queue_tail(&list, skb);

		skb = skb_dequeue(head);
	}

	if (skb_peek(&list)) {
		spin_lock_irq(&head->lock);
		while ((skb = __skb_dequeue(&list)) != NULL)
			__skb_queue_tail(head, skb);
		spin_unlock_irq(&head->lock);
	}
#else
3762
	fput(io_file_from_index(ctx, index));
3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816
#endif
}

static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
				int index)
{
#if defined(CONFIG_UNIX)
	struct sock *sock = ctx->ring_sock->sk;
	struct sk_buff_head *head = &sock->sk_receive_queue;
	struct sk_buff *skb;

	/*
	 * See if we can merge this file into an existing skb SCM_RIGHTS
	 * file set. If there's no room, fall back to allocating a new skb
	 * and filling it in.
	 */
	spin_lock_irq(&head->lock);
	skb = skb_peek(head);
	if (skb) {
		struct scm_fp_list *fpl = UNIXCB(skb).fp;

		if (fpl->count < SCM_MAX_FD) {
			__skb_unlink(skb, head);
			spin_unlock_irq(&head->lock);
			fpl->fp[fpl->count] = get_file(file);
			unix_inflight(fpl->user, fpl->fp[fpl->count]);
			fpl->count++;
			spin_lock_irq(&head->lock);
			__skb_queue_head(head, skb);
		} else {
			skb = NULL;
		}
	}
	spin_unlock_irq(&head->lock);

	if (skb) {
		fput(file);
		return 0;
	}

	return __io_sqe_files_scm(ctx, 1, index);
#else
	return 0;
#endif
}

static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
			       unsigned nr_args)
{
	struct io_uring_files_update up;
	__s32 __user *fds;
	int fd, i, err;
	__u32 done;

3817
	if (!ctx->file_table)
3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830
		return -ENXIO;
	if (!nr_args)
		return -EINVAL;
	if (copy_from_user(&up, arg, sizeof(up)))
		return -EFAULT;
	if (check_add_overflow(up.offset, nr_args, &done))
		return -EOVERFLOW;
	if (done > ctx->nr_user_files)
		return -EINVAL;

	done = 0;
	fds = (__s32 __user *) up.fds;
	while (nr_args) {
3831 3832 3833
		struct fixed_file_table *table;
		unsigned index;

3834 3835 3836 3837 3838 3839
		err = 0;
		if (copy_from_user(&fd, &fds[done], sizeof(fd))) {
			err = -EFAULT;
			break;
		}
		i = array_index_nospec(up.offset, ctx->nr_user_files);
3840 3841 3842
		table = &ctx->file_table[i >> IORING_FILE_TABLE_SHIFT];
		index = i & IORING_FILE_TABLE_MASK;
		if (table->files[index]) {
3843
			io_sqe_file_unregister(ctx, i);
3844
			table->files[index] = NULL;
3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866
		}
		if (fd != -1) {
			struct file *file;

			file = fget(fd);
			if (!file) {
				err = -EBADF;
				break;
			}
			/*
			 * Don't allow io_uring instances to be registered. If
			 * UNIX isn't enabled, then this causes a reference
			 * cycle and this instance can never get freed. If UNIX
			 * is enabled we'll handle it just fine, but there's
			 * still no point in allowing a ring fd as it doesn't
			 * support regular read/write anyway.
			 */
			if (file->f_op == &io_uring_fops) {
				fput(file);
				err = -EBADF;
				break;
			}
3867
			table->files[index] = file;
3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879
			err = io_sqe_file_register(ctx, file, i);
			if (err)
				break;
		}
		nr_args--;
		done++;
		up.offset++;
	}

	return done ? done : err;
}

3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
static void io_put_work(struct io_wq_work *work)
{
	struct io_kiocb *req = container_of(work, struct io_kiocb, work);

	io_put_req(req);
}

static void io_get_work(struct io_wq_work *work)
{
	struct io_kiocb *req = container_of(work, struct io_kiocb, work);

	refcount_inc(&req->refs);
}

J
Jens Axboe 已提交
3894 3895
static int io_sq_offload_start(struct io_ring_ctx *ctx,
			       struct io_uring_params *p)
J
Jens Axboe 已提交
3896
{
3897
	unsigned concurrency;
J
Jens Axboe 已提交
3898 3899
	int ret;

J
Jens Axboe 已提交
3900
	init_waitqueue_head(&ctx->sqo_wait);
J
Jens Axboe 已提交
3901 3902 3903
	mmgrab(current->mm);
	ctx->sqo_mm = current->mm;

J
Jens Axboe 已提交
3904
	if (ctx->flags & IORING_SETUP_SQPOLL) {
3905 3906 3907 3908
		ret = -EPERM;
		if (!capable(CAP_SYS_ADMIN))
			goto err;

3909 3910 3911 3912
		ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
		if (!ctx->sq_thread_idle)
			ctx->sq_thread_idle = HZ;

J
Jens Axboe 已提交
3913
		if (p->flags & IORING_SETUP_SQ_AFF) {
3914
			int cpu = p->sq_thread_cpu;
J
Jens Axboe 已提交
3915

3916
			ret = -EINVAL;
3917 3918
			if (cpu >= nr_cpu_ids)
				goto err;
3919
			if (!cpu_online(cpu))
3920 3921
				goto err;

J
Jens Axboe 已提交
3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940
			ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
							ctx, cpu,
							"io_uring-sq");
		} else {
			ctx->sqo_thread = kthread_create(io_sq_thread, ctx,
							"io_uring-sq");
		}
		if (IS_ERR(ctx->sqo_thread)) {
			ret = PTR_ERR(ctx->sqo_thread);
			ctx->sqo_thread = NULL;
			goto err;
		}
		wake_up_process(ctx->sqo_thread);
	} else if (p->flags & IORING_SETUP_SQ_AFF) {
		/* Can't have SQ_AFF without SQPOLL */
		ret = -EINVAL;
		goto err;
	}

3941 3942
	/* Do QD, or 4 * CPUS, whatever is smallest */
	concurrency = min(ctx->sq_entries, 4 * num_online_cpus());
3943 3944
	ctx->io_wq = io_wq_create(concurrency, ctx->sqo_mm, ctx->user,
					io_get_work, io_put_work);
3945 3946 3947
	if (IS_ERR(ctx->io_wq)) {
		ret = PTR_ERR(ctx->io_wq);
		ctx->io_wq = NULL;
J
Jens Axboe 已提交
3948 3949 3950 3951 3952
		goto err;
	}

	return 0;
err:
3953
	io_finish_async(ctx);
J
Jens Axboe 已提交
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983
	mmdrop(ctx->sqo_mm);
	ctx->sqo_mm = NULL;
	return ret;
}

static void io_unaccount_mem(struct user_struct *user, unsigned long nr_pages)
{
	atomic_long_sub(nr_pages, &user->locked_vm);
}

static int io_account_mem(struct user_struct *user, unsigned long nr_pages)
{
	unsigned long page_limit, cur_pages, new_pages;

	/* Don't allow more pages than we can safely lock */
	page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;

	do {
		cur_pages = atomic_long_read(&user->locked_vm);
		new_pages = cur_pages + nr_pages;
		if (new_pages > page_limit)
			return -ENOMEM;
	} while (atomic_long_cmpxchg(&user->locked_vm, cur_pages,
					new_pages) != cur_pages);

	return 0;
}

static void io_mem_free(void *ptr)
{
3984 3985 3986 3987
	struct page *page;

	if (!ptr)
		return;
J
Jens Axboe 已提交
3988

3989
	page = virt_to_head_page(ptr);
J
Jens Axboe 已提交
3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001
	if (put_page_testzero(page))
		free_compound_page(page);
}

static void *io_mem_alloc(size_t size)
{
	gfp_t gfp_flags = GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN | __GFP_COMP |
				__GFP_NORETRY;

	return (void *) __get_free_pages(gfp_flags, get_order(size));
}

4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030
static unsigned long rings_size(unsigned sq_entries, unsigned cq_entries,
				size_t *sq_offset)
{
	struct io_rings *rings;
	size_t off, sq_array_size;

	off = struct_size(rings, cqes, cq_entries);
	if (off == SIZE_MAX)
		return SIZE_MAX;

#ifdef CONFIG_SMP
	off = ALIGN(off, SMP_CACHE_BYTES);
	if (off == 0)
		return SIZE_MAX;
#endif

	sq_array_size = array_size(sizeof(u32), sq_entries);
	if (sq_array_size == SIZE_MAX)
		return SIZE_MAX;

	if (check_add_overflow(off, sq_array_size, &off))
		return SIZE_MAX;

	if (sq_offset)
		*sq_offset = off;

	return off;
}

J
Jens Axboe 已提交
4031 4032
static unsigned long ring_pages(unsigned sq_entries, unsigned cq_entries)
{
4033
	size_t pages;
J
Jens Axboe 已提交
4034

4035 4036 4037 4038
	pages = (size_t)1 << get_order(
		rings_size(sq_entries, cq_entries, NULL));
	pages += (size_t)1 << get_order(
		array_size(sizeof(struct io_uring_sqe), sq_entries));
J
Jens Axboe 已提交
4039

4040
	return pages;
J
Jens Axboe 已提交
4041 4042
}

4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053
static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx)
{
	int i, j;

	if (!ctx->user_bufs)
		return -ENXIO;

	for (i = 0; i < ctx->nr_user_bufs; i++) {
		struct io_mapped_ubuf *imu = &ctx->user_bufs[i];

		for (j = 0; j < imu->nr_bvecs; j++)
4054
			put_user_page(imu->bvec[j].bv_page);
4055 4056 4057

		if (ctx->account_mem)
			io_unaccount_mem(ctx->user, imu->nr_bvecs);
4058
		kvfree(imu->bvec);
4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119
		imu->nr_bvecs = 0;
	}

	kfree(ctx->user_bufs);
	ctx->user_bufs = NULL;
	ctx->nr_user_bufs = 0;
	return 0;
}

static int io_copy_iov(struct io_ring_ctx *ctx, struct iovec *dst,
		       void __user *arg, unsigned index)
{
	struct iovec __user *src;

#ifdef CONFIG_COMPAT
	if (ctx->compat) {
		struct compat_iovec __user *ciovs;
		struct compat_iovec ciov;

		ciovs = (struct compat_iovec __user *) arg;
		if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
			return -EFAULT;

		dst->iov_base = (void __user *) (unsigned long) ciov.iov_base;
		dst->iov_len = ciov.iov_len;
		return 0;
	}
#endif
	src = (struct iovec __user *) arg;
	if (copy_from_user(dst, &src[index], sizeof(*dst)))
		return -EFAULT;
	return 0;
}

static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
				  unsigned nr_args)
{
	struct vm_area_struct **vmas = NULL;
	struct page **pages = NULL;
	int i, j, got_pages = 0;
	int ret = -EINVAL;

	if (ctx->user_bufs)
		return -EBUSY;
	if (!nr_args || nr_args > UIO_MAXIOV)
		return -EINVAL;

	ctx->user_bufs = kcalloc(nr_args, sizeof(struct io_mapped_ubuf),
					GFP_KERNEL);
	if (!ctx->user_bufs)
		return -ENOMEM;

	for (i = 0; i < nr_args; i++) {
		struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
		unsigned long off, start, end, ubuf;
		int pret, nr_pages;
		struct iovec iov;
		size_t size;

		ret = io_copy_iov(ctx, &iov, arg, i);
		if (ret)
4120
			goto err;
4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149

		/*
		 * Don't impose further limits on the size and buffer
		 * constraints here, we'll -EINVAL later when IO is
		 * submitted if they are wrong.
		 */
		ret = -EFAULT;
		if (!iov.iov_base || !iov.iov_len)
			goto err;

		/* arbitrary limit, but we need something */
		if (iov.iov_len > SZ_1G)
			goto err;

		ubuf = (unsigned long) iov.iov_base;
		end = (ubuf + iov.iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
		start = ubuf >> PAGE_SHIFT;
		nr_pages = end - start;

		if (ctx->account_mem) {
			ret = io_account_mem(ctx->user, nr_pages);
			if (ret)
				goto err;
		}

		ret = 0;
		if (!pages || nr_pages > got_pages) {
			kfree(vmas);
			kfree(pages);
4150
			pages = kvmalloc_array(nr_pages, sizeof(struct page *),
4151
						GFP_KERNEL);
4152
			vmas = kvmalloc_array(nr_pages,
4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163
					sizeof(struct vm_area_struct *),
					GFP_KERNEL);
			if (!pages || !vmas) {
				ret = -ENOMEM;
				if (ctx->account_mem)
					io_unaccount_mem(ctx->user, nr_pages);
				goto err;
			}
			got_pages = nr_pages;
		}

4164
		imu->bvec = kvmalloc_array(nr_pages, sizeof(struct bio_vec),
4165 4166 4167 4168 4169 4170 4171 4172 4173 4174
						GFP_KERNEL);
		ret = -ENOMEM;
		if (!imu->bvec) {
			if (ctx->account_mem)
				io_unaccount_mem(ctx->user, nr_pages);
			goto err;
		}

		ret = 0;
		down_read(&current->mm->mmap_sem);
4175 4176 4177
		pret = get_user_pages(ubuf, nr_pages,
				      FOLL_WRITE | FOLL_LONGTERM,
				      pages, vmas);
4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
		if (pret == nr_pages) {
			/* don't support file backed memory */
			for (j = 0; j < nr_pages; j++) {
				struct vm_area_struct *vma = vmas[j];

				if (vma->vm_file &&
				    !is_file_hugepages(vma->vm_file)) {
					ret = -EOPNOTSUPP;
					break;
				}
			}
		} else {
			ret = pret < 0 ? pret : -EFAULT;
		}
		up_read(&current->mm->mmap_sem);
		if (ret) {
			/*
			 * if we did partial map, or found file backed vmas,
			 * release any pages we did get
			 */
4198 4199
			if (pret > 0)
				put_user_pages(pages, pret);
4200 4201
			if (ctx->account_mem)
				io_unaccount_mem(ctx->user, nr_pages);
4202
			kvfree(imu->bvec);
4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224
			goto err;
		}

		off = ubuf & ~PAGE_MASK;
		size = iov.iov_len;
		for (j = 0; j < nr_pages; j++) {
			size_t vec_len;

			vec_len = min_t(size_t, size, PAGE_SIZE - off);
			imu->bvec[j].bv_page = pages[j];
			imu->bvec[j].bv_len = vec_len;
			imu->bvec[j].bv_offset = off;
			off = 0;
			size -= vec_len;
		}
		/* store original address for later verification */
		imu->ubuf = ubuf;
		imu->len = iov.iov_len;
		imu->nr_bvecs = nr_pages;

		ctx->nr_user_bufs++;
	}
4225 4226
	kvfree(pages);
	kvfree(vmas);
4227 4228
	return 0;
err:
4229 4230
	kvfree(pages);
	kvfree(vmas);
4231 4232 4233 4234
	io_sqe_buffer_unregister(ctx);
	return ret;
}

4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
static int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg)
{
	__s32 __user *fds = arg;
	int fd;

	if (ctx->cq_ev_fd)
		return -EBUSY;

	if (copy_from_user(&fd, fds, sizeof(*fds)))
		return -EFAULT;

	ctx->cq_ev_fd = eventfd_ctx_fdget(fd);
	if (IS_ERR(ctx->cq_ev_fd)) {
		int ret = PTR_ERR(ctx->cq_ev_fd);
		ctx->cq_ev_fd = NULL;
		return ret;
	}

	return 0;
}

static int io_eventfd_unregister(struct io_ring_ctx *ctx)
{
	if (ctx->cq_ev_fd) {
		eventfd_ctx_put(ctx->cq_ev_fd);
		ctx->cq_ev_fd = NULL;
		return 0;
	}

	return -ENXIO;
}

J
Jens Axboe 已提交
4267 4268
static void io_ring_ctx_free(struct io_ring_ctx *ctx)
{
J
Jens Axboe 已提交
4269
	io_finish_async(ctx);
J
Jens Axboe 已提交
4270 4271
	if (ctx->sqo_mm)
		mmdrop(ctx->sqo_mm);
J
Jens Axboe 已提交
4272 4273

	io_iopoll_reap_events(ctx);
4274
	io_sqe_buffer_unregister(ctx);
J
Jens Axboe 已提交
4275
	io_sqe_files_unregister(ctx);
4276
	io_eventfd_unregister(ctx);
J
Jens Axboe 已提交
4277

J
Jens Axboe 已提交
4278
#if defined(CONFIG_UNIX)
4279 4280
	if (ctx->ring_sock) {
		ctx->ring_sock->file = NULL; /* so that iput() is called */
J
Jens Axboe 已提交
4281
		sock_release(ctx->ring_sock);
4282
	}
J
Jens Axboe 已提交
4283 4284
#endif

4285
	io_mem_free(ctx->rings);
J
Jens Axboe 已提交
4286 4287 4288 4289 4290 4291 4292
	io_mem_free(ctx->sq_sqes);

	percpu_ref_exit(&ctx->refs);
	if (ctx->account_mem)
		io_unaccount_mem(ctx->user,
				ring_pages(ctx->sq_entries, ctx->cq_entries));
	free_uid(ctx->user);
4293
	kfree(ctx->completions);
4294
	kmem_cache_free(req_cachep, ctx->fallback_req);
J
Jens Axboe 已提交
4295 4296 4297 4298 4299 4300 4301 4302 4303
	kfree(ctx);
}

static __poll_t io_uring_poll(struct file *file, poll_table *wait)
{
	struct io_ring_ctx *ctx = file->private_data;
	__poll_t mask = 0;

	poll_wait(file, &ctx->cq_wait, wait);
4304 4305 4306 4307
	/*
	 * synchronizes with barrier from wq_has_sleeper call in
	 * io_commit_cqring
	 */
J
Jens Axboe 已提交
4308
	smp_rmb();
4309 4310
	if (READ_ONCE(ctx->rings->sq.tail) - ctx->cached_sq_head !=
	    ctx->rings->sq_ring_entries)
J
Jens Axboe 已提交
4311
		mask |= EPOLLOUT | EPOLLWRNORM;
4312
	if (READ_ONCE(ctx->rings->cq.head) != ctx->cached_cq_tail)
J
Jens Axboe 已提交
4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
		mask |= EPOLLIN | EPOLLRDNORM;

	return mask;
}

static int io_uring_fasync(int fd, struct file *file, int on)
{
	struct io_ring_ctx *ctx = file->private_data;

	return fasync_helper(fd, file, on, &ctx->cq_fasync);
}

static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
{
	mutex_lock(&ctx->uring_lock);
	percpu_ref_kill(&ctx->refs);
	mutex_unlock(&ctx->uring_lock);

J
Jens Axboe 已提交
4331
	io_kill_timeouts(ctx);
4332
	io_poll_remove_all(ctx);
4333 4334 4335 4336

	if (ctx->io_wq)
		io_wq_cancel_all(ctx->io_wq);

J
Jens Axboe 已提交
4337
	io_iopoll_reap_events(ctx);
4338 4339 4340
	/* if we failed setting up the ctx, we might not have any rings */
	if (ctx->rings)
		io_cqring_overflow_flush(ctx, true);
4341
	wait_for_completion(&ctx->completions[0]);
J
Jens Axboe 已提交
4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353
	io_ring_ctx_free(ctx);
}

static int io_uring_release(struct inode *inode, struct file *file)
{
	struct io_ring_ctx *ctx = file->private_data;

	file->private_data = NULL;
	io_ring_ctx_wait_and_kill(ctx);
	return 0;
}

4354 4355 4356 4357 4358 4359 4360
static void io_uring_cancel_files(struct io_ring_ctx *ctx,
				  struct files_struct *files)
{
	struct io_kiocb *req;
	DEFINE_WAIT(wait);

	while (!list_empty_careful(&ctx->inflight_list)) {
4361
		struct io_kiocb *cancel_req = NULL;
4362 4363 4364

		spin_lock_irq(&ctx->inflight_lock);
		list_for_each_entry(req, &ctx->inflight_list, inflight_entry) {
4365 4366 4367 4368 4369 4370 4371
			if (req->work.files != files)
				continue;
			/* req is being completed, ignore */
			if (!refcount_inc_not_zero(&req->refs))
				continue;
			cancel_req = req;
			break;
4372
		}
4373
		if (cancel_req)
4374
			prepare_to_wait(&ctx->inflight_wait, &wait,
4375
						TASK_UNINTERRUPTIBLE);
4376 4377
		spin_unlock_irq(&ctx->inflight_lock);

4378 4379
		/* We need to keep going until we don't find a matching req */
		if (!cancel_req)
4380
			break;
4381 4382 4383

		io_wq_cancel_work(ctx->io_wq, &cancel_req->work);
		io_put_req(cancel_req);
4384 4385
		schedule();
	}
4386
	finish_wait(&ctx->inflight_wait, &wait);
4387 4388 4389 4390 4391 4392 4393
}

static int io_uring_flush(struct file *file, void *data)
{
	struct io_ring_ctx *ctx = file->private_data;

	io_uring_cancel_files(ctx, data);
4394 4395
	if (fatal_signal_pending(current) || (current->flags & PF_EXITING)) {
		io_cqring_overflow_flush(ctx, true);
4396
		io_wq_cancel_all(ctx->io_wq);
4397
	}
4398 4399 4400
	return 0;
}

J
Jens Axboe 已提交
4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
{
	loff_t offset = (loff_t) vma->vm_pgoff << PAGE_SHIFT;
	unsigned long sz = vma->vm_end - vma->vm_start;
	struct io_ring_ctx *ctx = file->private_data;
	unsigned long pfn;
	struct page *page;
	void *ptr;

	switch (offset) {
	case IORING_OFF_SQ_RING:
4412 4413
	case IORING_OFF_CQ_RING:
		ptr = ctx->rings;
J
Jens Axboe 已提交
4414 4415 4416 4417 4418 4419 4420 4421 4422
		break;
	case IORING_OFF_SQES:
		ptr = ctx->sq_sqes;
		break;
	default:
		return -EINVAL;
	}

	page = virt_to_head_page(ptr);
4423
	if (sz > page_size(page))
J
Jens Axboe 已提交
4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438
		return -EINVAL;

	pfn = virt_to_phys(ptr) >> PAGE_SHIFT;
	return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
}

SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
		u32, min_complete, u32, flags, const sigset_t __user *, sig,
		size_t, sigsz)
{
	struct io_ring_ctx *ctx;
	long ret = -EBADF;
	int submitted = 0;
	struct fd f;

J
Jens Axboe 已提交
4439
	if (flags & ~(IORING_ENTER_GETEVENTS | IORING_ENTER_SQ_WAKEUP))
J
Jens Axboe 已提交
4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454
		return -EINVAL;

	f = fdget(fd);
	if (!f.file)
		return -EBADF;

	ret = -EOPNOTSUPP;
	if (f.file->f_op != &io_uring_fops)
		goto out_fput;

	ret = -ENXIO;
	ctx = f.file->private_data;
	if (!percpu_ref_tryget(&ctx->refs))
		goto out_fput;

J
Jens Axboe 已提交
4455 4456 4457 4458 4459
	/*
	 * For SQ polling, the thread will do all submissions and completions.
	 * Just return the requested submit count, and wake the thread if
	 * we were asked to.
	 */
4460
	ret = 0;
J
Jens Axboe 已提交
4461
	if (ctx->flags & IORING_SETUP_SQPOLL) {
4462 4463
		if (!list_empty_careful(&ctx->cq_overflow_list))
			io_cqring_overflow_flush(ctx, false);
J
Jens Axboe 已提交
4464 4465 4466
		if (flags & IORING_ENTER_SQ_WAKEUP)
			wake_up(&ctx->sqo_wait);
		submitted = to_submit;
4467
	} else if (to_submit) {
4468
		struct mm_struct *cur_mm;
J
Jens Axboe 已提交
4469

4470
		to_submit = min(to_submit, ctx->sq_entries);
J
Jens Axboe 已提交
4471
		mutex_lock(&ctx->uring_lock);
4472 4473 4474 4475
		/* already have mm, so io_submit_sqes() won't try to grab it */
		cur_mm = ctx->sqo_mm;
		submitted = io_submit_sqes(ctx, to_submit, f.file, fd,
					   &cur_mm, false);
J
Jens Axboe 已提交
4476 4477 4478
		mutex_unlock(&ctx->uring_lock);
	}
	if (flags & IORING_ENTER_GETEVENTS) {
J
Jens Axboe 已提交
4479 4480
		unsigned nr_events = 0;

J
Jens Axboe 已提交
4481 4482
		min_complete = min(min_complete, ctx->cq_entries);

J
Jens Axboe 已提交
4483 4484 4485 4486 4487
		if (ctx->flags & IORING_SETUP_IOPOLL) {
			ret = io_iopoll_check(ctx, &nr_events, min_complete);
		} else {
			ret = io_cqring_wait(ctx, min_complete, sig, sigsz);
		}
J
Jens Axboe 已提交
4488 4489
	}

4490
	percpu_ref_put(&ctx->refs);
J
Jens Axboe 已提交
4491 4492 4493 4494 4495 4496 4497
out_fput:
	fdput(f);
	return submitted ? submitted : ret;
}

static const struct file_operations io_uring_fops = {
	.release	= io_uring_release,
4498
	.flush		= io_uring_flush,
J
Jens Axboe 已提交
4499 4500 4501 4502 4503 4504 4505 4506
	.mmap		= io_uring_mmap,
	.poll		= io_uring_poll,
	.fasync		= io_uring_fasync,
};

static int io_allocate_scq_urings(struct io_ring_ctx *ctx,
				  struct io_uring_params *p)
{
4507 4508
	struct io_rings *rings;
	size_t size, sq_array_offset;
J
Jens Axboe 已提交
4509

4510 4511 4512 4513 4514 4515
	size = rings_size(p->sq_entries, p->cq_entries, &sq_array_offset);
	if (size == SIZE_MAX)
		return -EOVERFLOW;

	rings = io_mem_alloc(size);
	if (!rings)
J
Jens Axboe 已提交
4516 4517
		return -ENOMEM;

4518 4519 4520 4521 4522 4523 4524 4525 4526 4527
	ctx->rings = rings;
	ctx->sq_array = (u32 *)((char *)rings + sq_array_offset);
	rings->sq_ring_mask = p->sq_entries - 1;
	rings->cq_ring_mask = p->cq_entries - 1;
	rings->sq_ring_entries = p->sq_entries;
	rings->cq_ring_entries = p->cq_entries;
	ctx->sq_mask = rings->sq_ring_mask;
	ctx->cq_mask = rings->cq_ring_mask;
	ctx->sq_entries = rings->sq_ring_entries;
	ctx->cq_entries = rings->cq_ring_entries;
J
Jens Axboe 已提交
4528 4529 4530 4531 4532 4533

	size = array_size(sizeof(struct io_uring_sqe), p->sq_entries);
	if (size == SIZE_MAX)
		return -EOVERFLOW;

	ctx->sq_sqes = io_mem_alloc(size);
4534
	if (!ctx->sq_sqes)
J
Jens Axboe 已提交
4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571
		return -ENOMEM;

	return 0;
}

/*
 * Allocate an anonymous fd, this is what constitutes the application
 * visible backing of an io_uring instance. The application mmaps this
 * fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
 * we have to tie this fd to a socket for file garbage collection purposes.
 */
static int io_uring_get_fd(struct io_ring_ctx *ctx)
{
	struct file *file;
	int ret;

#if defined(CONFIG_UNIX)
	ret = sock_create_kern(&init_net, PF_UNIX, SOCK_RAW, IPPROTO_IP,
				&ctx->ring_sock);
	if (ret)
		return ret;
#endif

	ret = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
	if (ret < 0)
		goto err;

	file = anon_inode_getfile("[io_uring]", &io_uring_fops, ctx,
					O_RDWR | O_CLOEXEC);
	if (IS_ERR(file)) {
		put_unused_fd(ret);
		ret = PTR_ERR(file);
		goto err;
	}

#if defined(CONFIG_UNIX)
	ctx->ring_sock->file = file;
J
Jens Axboe 已提交
4572
	ctx->ring_sock->sk->sk_user_data = ctx;
J
Jens Axboe 已提交
4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597
#endif
	fd_install(ret, file);
	return ret;
err:
#if defined(CONFIG_UNIX)
	sock_release(ctx->ring_sock);
	ctx->ring_sock = NULL;
#endif
	return ret;
}

static int io_uring_create(unsigned entries, struct io_uring_params *p)
{
	struct user_struct *user = NULL;
	struct io_ring_ctx *ctx;
	bool account_mem;
	int ret;

	if (!entries || entries > IORING_MAX_ENTRIES)
		return -EINVAL;

	/*
	 * Use twice as many entries for the CQ ring. It's possible for the
	 * application to drive a higher depth than the size of the SQ ring,
	 * since the sqes are only used at submission time. This allows for
4598 4599 4600
	 * some flexibility in overcommitting a bit. If the application has
	 * set IORING_SETUP_CQSIZE, it will have passed in the desired number
	 * of CQ ring entries manually.
J
Jens Axboe 已提交
4601 4602
	 */
	p->sq_entries = roundup_pow_of_two(entries);
4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614
	if (p->flags & IORING_SETUP_CQSIZE) {
		/*
		 * If IORING_SETUP_CQSIZE is set, we do the same roundup
		 * to a power-of-two, if it isn't already. We do NOT impose
		 * any cq vs sq ring sizing.
		 */
		if (p->cq_entries < p->sq_entries || p->cq_entries > IORING_MAX_CQ_ENTRIES)
			return -EINVAL;
		p->cq_entries = roundup_pow_of_two(p->cq_entries);
	} else {
		p->cq_entries = 2 * p->sq_entries;
	}
J
Jens Axboe 已提交
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643

	user = get_uid(current_user());
	account_mem = !capable(CAP_IPC_LOCK);

	if (account_mem) {
		ret = io_account_mem(user,
				ring_pages(p->sq_entries, p->cq_entries));
		if (ret) {
			free_uid(user);
			return ret;
		}
	}

	ctx = io_ring_ctx_alloc(p);
	if (!ctx) {
		if (account_mem)
			io_unaccount_mem(user, ring_pages(p->sq_entries,
								p->cq_entries));
		free_uid(user);
		return -ENOMEM;
	}
	ctx->compat = in_compat_syscall();
	ctx->account_mem = account_mem;
	ctx->user = user;

	ret = io_allocate_scq_urings(ctx, p);
	if (ret)
		goto err;

J
Jens Axboe 已提交
4644
	ret = io_sq_offload_start(ctx, p);
J
Jens Axboe 已提交
4645 4646 4647 4648
	if (ret)
		goto err;

	memset(&p->sq_off, 0, sizeof(p->sq_off));
4649 4650 4651 4652 4653 4654 4655
	p->sq_off.head = offsetof(struct io_rings, sq.head);
	p->sq_off.tail = offsetof(struct io_rings, sq.tail);
	p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask);
	p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries);
	p->sq_off.flags = offsetof(struct io_rings, sq_flags);
	p->sq_off.dropped = offsetof(struct io_rings, sq_dropped);
	p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings;
J
Jens Axboe 已提交
4656 4657

	memset(&p->cq_off, 0, sizeof(p->cq_off));
4658 4659 4660 4661 4662 4663
	p->cq_off.head = offsetof(struct io_rings, cq.head);
	p->cq_off.tail = offsetof(struct io_rings, cq.tail);
	p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask);
	p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries);
	p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
	p->cq_off.cqes = offsetof(struct io_rings, cqes);
4664

4665 4666 4667 4668 4669 4670 4671 4672
	/*
	 * Install ring fd as the very last thing, so we don't risk someone
	 * having closed it before we finish setup
	 */
	ret = io_uring_get_fd(ctx);
	if (ret < 0)
		goto err;

4673
	p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP;
4674
	trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
J
Jens Axboe 已提交
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698
	return ret;
err:
	io_ring_ctx_wait_and_kill(ctx);
	return ret;
}

/*
 * Sets up an aio uring context, and returns the fd. Applications asks for a
 * ring size, we return the actual sq/cq ring sizes (among other things) in the
 * params structure passed in.
 */
static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
{
	struct io_uring_params p;
	long ret;
	int i;

	if (copy_from_user(&p, params, sizeof(p)))
		return -EFAULT;
	for (i = 0; i < ARRAY_SIZE(p.resv); i++) {
		if (p.resv[i])
			return -EINVAL;
	}

J
Jens Axboe 已提交
4699
	if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
4700
			IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE))
J
Jens Axboe 已提交
4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718
		return -EINVAL;

	ret = io_uring_create(entries, &p);
	if (ret < 0)
		return ret;

	if (copy_to_user(params, &p, sizeof(p)))
		return -EFAULT;

	return ret;
}

SYSCALL_DEFINE2(io_uring_setup, u32, entries,
		struct io_uring_params __user *, params)
{
	return io_uring_setup(entries, params);
}

4719 4720
static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
			       void __user *arg, unsigned nr_args)
4721 4722
	__releases(ctx->uring_lock)
	__acquires(ctx->uring_lock)
4723 4724 4725
{
	int ret;

4726 4727 4728 4729 4730 4731 4732 4733
	/*
	 * We're inside the ring mutex, if the ref is already dying, then
	 * someone else killed the ctx or is already going through
	 * io_uring_register().
	 */
	if (percpu_ref_is_dying(&ctx->refs))
		return -ENXIO;

4734
	percpu_ref_kill(&ctx->refs);
4735 4736 4737 4738 4739 4740 4741 4742 4743

	/*
	 * Drop uring mutex before waiting for references to exit. If another
	 * thread is currently inside io_uring_enter() it might need to grab
	 * the uring_lock to make progress. If we hold it here across the drain
	 * wait, then we can deadlock. It's safe to drop the mutex here, since
	 * no new references will come in after we've killed the percpu ref.
	 */
	mutex_unlock(&ctx->uring_lock);
4744
	wait_for_completion(&ctx->completions[0]);
4745
	mutex_lock(&ctx->uring_lock);
4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756

	switch (opcode) {
	case IORING_REGISTER_BUFFERS:
		ret = io_sqe_buffer_register(ctx, arg, nr_args);
		break;
	case IORING_UNREGISTER_BUFFERS:
		ret = -EINVAL;
		if (arg || nr_args)
			break;
		ret = io_sqe_buffer_unregister(ctx);
		break;
J
Jens Axboe 已提交
4757 4758 4759 4760 4761 4762 4763 4764 4765
	case IORING_REGISTER_FILES:
		ret = io_sqe_files_register(ctx, arg, nr_args);
		break;
	case IORING_UNREGISTER_FILES:
		ret = -EINVAL;
		if (arg || nr_args)
			break;
		ret = io_sqe_files_unregister(ctx);
		break;
4766 4767 4768
	case IORING_REGISTER_FILES_UPDATE:
		ret = io_sqe_files_update(ctx, arg, nr_args);
		break;
4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780
	case IORING_REGISTER_EVENTFD:
		ret = -EINVAL;
		if (nr_args != 1)
			break;
		ret = io_eventfd_register(ctx, arg);
		break;
	case IORING_UNREGISTER_EVENTFD:
		ret = -EINVAL;
		if (arg || nr_args)
			break;
		ret = io_eventfd_unregister(ctx);
		break;
4781 4782 4783 4784 4785 4786
	default:
		ret = -EINVAL;
		break;
	}

	/* bring the ctx back to life */
4787
	reinit_completion(&ctx->completions[0]);
4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811
	percpu_ref_reinit(&ctx->refs);
	return ret;
}

SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
		void __user *, arg, unsigned int, nr_args)
{
	struct io_ring_ctx *ctx;
	long ret = -EBADF;
	struct fd f;

	f = fdget(fd);
	if (!f.file)
		return -EBADF;

	ret = -EOPNOTSUPP;
	if (f.file->f_op != &io_uring_fops)
		goto out_fput;

	ctx = f.file->private_data;

	mutex_lock(&ctx->uring_lock);
	ret = __io_uring_register(ctx, opcode, arg, nr_args);
	mutex_unlock(&ctx->uring_lock);
4812 4813
	trace_io_uring_register(ctx, opcode, ctx->nr_user_files, ctx->nr_user_bufs,
							ctx->cq_ev_fd != NULL, ret);
4814 4815 4816 4817 4818
out_fput:
	fdput(f);
	return ret;
}

J
Jens Axboe 已提交
4819 4820 4821 4822 4823 4824
static int __init io_uring_init(void)
{
	req_cachep = KMEM_CACHE(io_kiocb, SLAB_HWCACHE_ALIGN | SLAB_PANIC);
	return 0;
};
__initcall(io_uring_init);