Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Shared application/kernel submission and completion ring pairs, for
4 : : * supporting fast/efficient IO.
5 : : *
6 : : * A note on the read/write ordering memory barriers that are matched between
7 : : * the application and kernel side.
8 : : *
9 : : * After the application reads the CQ ring tail, it must use an
10 : : * appropriate smp_rmb() to pair with the smp_wmb() the kernel uses
11 : : * before writing the tail (using smp_load_acquire to read the tail will
12 : : * do). It also needs a smp_mb() before updating CQ head (ordering the
13 : : * entry load(s) with the head store), pairing with an implicit barrier
14 : : * through a control-dependency in io_get_cqring (smp_store_release to
15 : : * store head will do). Failure to do so could lead to reading invalid
16 : : * CQ entries.
17 : : *
18 : : * Likewise, the application must use an appropriate smp_wmb() before
19 : : * writing the SQ tail (ordering SQ entry stores with the tail store),
20 : : * which pairs with smp_load_acquire in io_get_sqring (smp_store_release
21 : : * to store the tail will do). And it needs a barrier ordering the SQ
22 : : * head load before writing new SQ entries (smp_load_acquire to read
23 : : * head will do).
24 : : *
25 : : * When using the SQ poll thread (IORING_SETUP_SQPOLL), the application
26 : : * needs to check the SQ flags for IORING_SQ_NEED_WAKEUP *after*
27 : : * updating the SQ tail; a full memory barrier smp_mb() is needed
28 : : * between.
29 : : *
30 : : * Also see the examples in the liburing library:
31 : : *
32 : : * git://git.kernel.dk/liburing
33 : : *
34 : : * io_uring also uses READ/WRITE_ONCE() for _any_ store or load that happens
35 : : * from data shared between the kernel and application. This is done both
36 : : * for ordering purposes, but also to ensure that once a value is loaded from
37 : : * data that the application could potentially modify, it remains stable.
38 : : *
39 : : * Copyright (C) 2018-2019 Jens Axboe
40 : : * Copyright (c) 2018-2019 Christoph Hellwig
41 : : */
42 : : #include <linux/kernel.h>
43 : : #include <linux/init.h>
44 : : #include <linux/errno.h>
45 : : #include <linux/syscalls.h>
46 : : #include <linux/compat.h>
47 : : #include <linux/refcount.h>
48 : : #include <linux/uio.h>
49 : : #include <linux/bits.h>
50 : :
51 : : #include <linux/sched/signal.h>
52 : : #include <linux/fs.h>
53 : : #include <linux/file.h>
54 : : #include <linux/fdtable.h>
55 : : #include <linux/mm.h>
56 : : #include <linux/mman.h>
57 : : #include <linux/mmu_context.h>
58 : : #include <linux/percpu.h>
59 : : #include <linux/slab.h>
60 : : #include <linux/kthread.h>
61 : : #include <linux/blkdev.h>
62 : : #include <linux/bvec.h>
63 : : #include <linux/net.h>
64 : : #include <net/sock.h>
65 : : #include <net/af_unix.h>
66 : : #include <net/scm.h>
67 : : #include <linux/anon_inodes.h>
68 : : #include <linux/sched/mm.h>
69 : : #include <linux/uaccess.h>
70 : : #include <linux/nospec.h>
71 : : #include <linux/sizes.h>
72 : : #include <linux/hugetlb.h>
73 : : #include <linux/highmem.h>
74 : : #include <linux/namei.h>
75 : : #include <linux/fsnotify.h>
76 : : #include <linux/fadvise.h>
77 : : #include <linux/eventpoll.h>
78 : : #include <linux/fs_struct.h>
79 : :
80 : : #define CREATE_TRACE_POINTS
81 : : #include <trace/events/io_uring.h>
82 : :
83 : : #include <uapi/linux/io_uring.h>
84 : :
85 : : #include "internal.h"
86 : : #include "io-wq.h"
87 : :
88 : : #define IORING_MAX_ENTRIES 32768
89 : : #define IORING_MAX_CQ_ENTRIES (2 * IORING_MAX_ENTRIES)
90 : :
91 : : /*
92 : : * Shift of 9 is 512 entries, or exactly one page on 64-bit archs
93 : : */
94 : : #define IORING_FILE_TABLE_SHIFT 9
95 : : #define IORING_MAX_FILES_TABLE (1U << IORING_FILE_TABLE_SHIFT)
96 : : #define IORING_FILE_TABLE_MASK (IORING_MAX_FILES_TABLE - 1)
97 : : #define IORING_MAX_FIXED_FILES (64 * IORING_MAX_FILES_TABLE)
98 : :
99 : : struct io_uring {
100 : : u32 head ____cacheline_aligned_in_smp;
101 : : u32 tail ____cacheline_aligned_in_smp;
102 : : };
103 : :
104 : : /*
105 : : * This data is shared with the application through the mmap at offsets
106 : : * IORING_OFF_SQ_RING and IORING_OFF_CQ_RING.
107 : : *
108 : : * The offsets to the member fields are published through struct
109 : : * io_sqring_offsets when calling io_uring_setup.
110 : : */
111 : : struct io_rings {
112 : : /*
113 : : * Head and tail offsets into the ring; the offsets need to be
114 : : * masked to get valid indices.
115 : : *
116 : : * The kernel controls head of the sq ring and the tail of the cq ring,
117 : : * and the application controls tail of the sq ring and the head of the
118 : : * cq ring.
119 : : */
120 : : struct io_uring sq, cq;
121 : : /*
122 : : * Bitmasks to apply to head and tail offsets (constant, equals
123 : : * ring_entries - 1)
124 : : */
125 : : u32 sq_ring_mask, cq_ring_mask;
126 : : /* Ring sizes (constant, power of 2) */
127 : : u32 sq_ring_entries, cq_ring_entries;
128 : : /*
129 : : * Number of invalid entries dropped by the kernel due to
130 : : * invalid index stored in array
131 : : *
132 : : * Written by the kernel, shouldn't be modified by the
133 : : * application (i.e. get number of "new events" by comparing to
134 : : * cached value).
135 : : *
136 : : * After a new SQ head value was read by the application this
137 : : * counter includes all submissions that were dropped reaching
138 : : * the new SQ head (and possibly more).
139 : : */
140 : : u32 sq_dropped;
141 : : /*
142 : : * Runtime flags
143 : : *
144 : : * Written by the kernel, shouldn't be modified by the
145 : : * application.
146 : : *
147 : : * The application needs a full memory barrier before checking
148 : : * for IORING_SQ_NEED_WAKEUP after updating the sq tail.
149 : : */
150 : : u32 sq_flags;
151 : : /*
152 : : * Number of completion events lost because the queue was full;
153 : : * this should be avoided by the application by making sure
154 : : * there are not more requests pending than there is space in
155 : : * the completion queue.
156 : : *
157 : : * Written by the kernel, shouldn't be modified by the
158 : : * application (i.e. get number of "new events" by comparing to
159 : : * cached value).
160 : : *
161 : : * As completion events come in out of order this counter is not
162 : : * ordered with any other data.
163 : : */
164 : : u32 cq_overflow;
165 : : /*
166 : : * Ring buffer of completion events.
167 : : *
168 : : * The kernel writes completion events fresh every time they are
169 : : * produced, so the application is allowed to modify pending
170 : : * entries.
171 : : */
172 : : struct io_uring_cqe cqes[] ____cacheline_aligned_in_smp;
173 : : };
174 : :
175 : : struct io_mapped_ubuf {
176 : : u64 ubuf;
177 : : size_t len;
178 : : struct bio_vec *bvec;
179 : : unsigned int nr_bvecs;
180 : : };
181 : :
182 : : struct fixed_file_table {
183 : : struct file **files;
184 : : };
185 : :
186 : : struct fixed_file_data {
187 : : struct fixed_file_table *table;
188 : : struct io_ring_ctx *ctx;
189 : :
190 : : struct percpu_ref refs;
191 : : struct llist_head put_llist;
192 : : struct work_struct ref_work;
193 : : struct completion done;
194 : : };
195 : :
196 : : struct io_ring_ctx {
197 : : struct {
198 : : struct percpu_ref refs;
199 : : } ____cacheline_aligned_in_smp;
200 : :
201 : : struct {
202 : : unsigned int flags;
203 : : unsigned int compat: 1;
204 : : unsigned int account_mem: 1;
205 : : unsigned int cq_overflow_flushed: 1;
206 : : unsigned int drain_next: 1;
207 : : unsigned int eventfd_async: 1;
208 : :
209 : : /*
210 : : * Ring buffer of indices into array of io_uring_sqe, which is
211 : : * mmapped by the application using the IORING_OFF_SQES offset.
212 : : *
213 : : * This indirection could e.g. be used to assign fixed
214 : : * io_uring_sqe entries to operations and only submit them to
215 : : * the queue when needed.
216 : : *
217 : : * The kernel modifies neither the indices array nor the entries
218 : : * array.
219 : : */
220 : : u32 *sq_array;
221 : : unsigned cached_sq_head;
222 : : unsigned sq_entries;
223 : : unsigned sq_mask;
224 : : unsigned sq_thread_idle;
225 : : unsigned cached_sq_dropped;
226 : : atomic_t cached_cq_overflow;
227 : : unsigned long sq_check_overflow;
228 : :
229 : : struct list_head defer_list;
230 : : struct list_head timeout_list;
231 : : struct list_head cq_overflow_list;
232 : :
233 : : wait_queue_head_t inflight_wait;
234 : : struct io_uring_sqe *sq_sqes;
235 : : } ____cacheline_aligned_in_smp;
236 : :
237 : : struct io_rings *rings;
238 : :
239 : : /* IO offload */
240 : : struct io_wq *io_wq;
241 : : struct task_struct *sqo_thread; /* if using sq thread polling */
242 : : struct mm_struct *sqo_mm;
243 : : wait_queue_head_t sqo_wait;
244 : :
245 : : /*
246 : : * If used, fixed file set. Writers must ensure that ->refs is dead,
247 : : * readers must ensure that ->refs is alive as long as the file* is
248 : : * used. Only updated through io_uring_register(2).
249 : : */
250 : : struct fixed_file_data *file_data;
251 : : unsigned nr_user_files;
252 : : int ring_fd;
253 : : struct file *ring_file;
254 : :
255 : : /* if used, fixed mapped user buffers */
256 : : unsigned nr_user_bufs;
257 : : struct io_mapped_ubuf *user_bufs;
258 : :
259 : : struct user_struct *user;
260 : :
261 : : const struct cred *creds;
262 : :
263 : : /* 0 is for ctx quiesce/reinit/free, 1 is for sqo_thread started */
264 : : struct completion *completions;
265 : :
266 : : /* if all else fails... */
267 : : struct io_kiocb *fallback_req;
268 : :
269 : : #if defined(CONFIG_UNIX)
270 : : struct socket *ring_sock;
271 : : #endif
272 : :
273 : : struct idr personality_idr;
274 : :
275 : : struct {
276 : : unsigned cached_cq_tail;
277 : : unsigned cq_entries;
278 : : unsigned cq_mask;
279 : : atomic_t cq_timeouts;
280 : : unsigned long cq_check_overflow;
281 : : struct wait_queue_head cq_wait;
282 : : struct fasync_struct *cq_fasync;
283 : : struct eventfd_ctx *cq_ev_fd;
284 : : } ____cacheline_aligned_in_smp;
285 : :
286 : : struct {
287 : : struct mutex uring_lock;
288 : : wait_queue_head_t wait;
289 : : } ____cacheline_aligned_in_smp;
290 : :
291 : : struct {
292 : : spinlock_t completion_lock;
293 : : struct llist_head poll_llist;
294 : :
295 : : /*
296 : : * ->poll_list is protected by the ctx->uring_lock for
297 : : * io_uring instances that don't use IORING_SETUP_SQPOLL.
298 : : * For SQPOLL, only the single threaded io_sq_thread() will
299 : : * manipulate the list, hence no extra locking is needed there.
300 : : */
301 : : struct list_head poll_list;
302 : : struct hlist_head *cancel_hash;
303 : : unsigned cancel_hash_bits;
304 : : bool poll_multi_file;
305 : :
306 : : spinlock_t inflight_lock;
307 : : struct list_head inflight_list;
308 : : } ____cacheline_aligned_in_smp;
309 : : };
310 : :
311 : : /*
312 : : * First field must be the file pointer in all the
313 : : * iocb unions! See also 'struct kiocb' in <linux/fs.h>
314 : : */
315 : : struct io_poll_iocb {
316 : : struct file *file;
317 : : union {
318 : : struct wait_queue_head *head;
319 : : u64 addr;
320 : : };
321 : : __poll_t events;
322 : : bool done;
323 : : bool canceled;
324 : : struct wait_queue_entry wait;
325 : : };
326 : :
327 : : struct io_close {
328 : : struct file *file;
329 : : struct file *put_file;
330 : : int fd;
331 : : };
332 : :
333 : : struct io_timeout_data {
334 : : struct io_kiocb *req;
335 : : struct hrtimer timer;
336 : : struct timespec64 ts;
337 : : enum hrtimer_mode mode;
338 : : u32 seq_offset;
339 : : };
340 : :
341 : : struct io_accept {
342 : : struct file *file;
343 : : struct sockaddr __user *addr;
344 : : int __user *addr_len;
345 : : int flags;
346 : : unsigned long nofile;
347 : : };
348 : :
349 : : struct io_sync {
350 : : struct file *file;
351 : : loff_t len;
352 : : loff_t off;
353 : : int flags;
354 : : int mode;
355 : : };
356 : :
357 : : struct io_cancel {
358 : : struct file *file;
359 : : u64 addr;
360 : : };
361 : :
362 : : struct io_timeout {
363 : : struct file *file;
364 : : u64 addr;
365 : : int flags;
366 : : unsigned count;
367 : : };
368 : :
369 : : struct io_rw {
370 : : /* NOTE: kiocb has the file as the first member, so don't do it here */
371 : : struct kiocb kiocb;
372 : : u64 addr;
373 : : u64 len;
374 : : };
375 : :
376 : : struct io_connect {
377 : : struct file *file;
378 : : struct sockaddr __user *addr;
379 : : int addr_len;
380 : : };
381 : :
382 : : struct io_sr_msg {
383 : : struct file *file;
384 : : union {
385 : : struct user_msghdr __user *msg;
386 : : void __user *buf;
387 : : };
388 : : int msg_flags;
389 : : size_t len;
390 : : };
391 : :
392 : : struct io_open {
393 : : struct file *file;
394 : : int dfd;
395 : : union {
396 : : unsigned mask;
397 : : };
398 : : struct filename *filename;
399 : : struct statx __user *buffer;
400 : : struct open_how how;
401 : : unsigned long nofile;
402 : : };
403 : :
404 : : struct io_files_update {
405 : : struct file *file;
406 : : u64 arg;
407 : : u32 nr_args;
408 : : u32 offset;
409 : : };
410 : :
411 : : struct io_fadvise {
412 : : struct file *file;
413 : : u64 offset;
414 : : u32 len;
415 : : u32 advice;
416 : : };
417 : :
418 : : struct io_madvise {
419 : : struct file *file;
420 : : u64 addr;
421 : : u32 len;
422 : : u32 advice;
423 : : };
424 : :
425 : : struct io_epoll {
426 : : struct file *file;
427 : : int epfd;
428 : : int op;
429 : : int fd;
430 : : struct epoll_event event;
431 : : };
432 : :
433 : : struct io_async_connect {
434 : : struct sockaddr_storage address;
435 : : };
436 : :
437 : : struct io_async_msghdr {
438 : : struct iovec fast_iov[UIO_FASTIOV];
439 : : struct iovec *iov;
440 : : struct sockaddr __user *uaddr;
441 : : struct msghdr msg;
442 : : struct sockaddr_storage addr;
443 : : };
444 : :
445 : : struct io_async_rw {
446 : : struct iovec fast_iov[UIO_FASTIOV];
447 : : struct iovec *iov;
448 : : ssize_t nr_segs;
449 : : ssize_t size;
450 : : };
451 : :
452 : : struct io_async_ctx {
453 : : union {
454 : : struct io_async_rw rw;
455 : : struct io_async_msghdr msg;
456 : : struct io_async_connect connect;
457 : : struct io_timeout_data timeout;
458 : : };
459 : : };
460 : :
461 : : enum {
462 : : REQ_F_FIXED_FILE_BIT = IOSQE_FIXED_FILE_BIT,
463 : : REQ_F_IO_DRAIN_BIT = IOSQE_IO_DRAIN_BIT,
464 : : REQ_F_LINK_BIT = IOSQE_IO_LINK_BIT,
465 : : REQ_F_HARDLINK_BIT = IOSQE_IO_HARDLINK_BIT,
466 : : REQ_F_FORCE_ASYNC_BIT = IOSQE_ASYNC_BIT,
467 : :
468 : : REQ_F_LINK_NEXT_BIT,
469 : : REQ_F_FAIL_LINK_BIT,
470 : : REQ_F_INFLIGHT_BIT,
471 : : REQ_F_CUR_POS_BIT,
472 : : REQ_F_NOWAIT_BIT,
473 : : REQ_F_IOPOLL_COMPLETED_BIT,
474 : : REQ_F_LINK_TIMEOUT_BIT,
475 : : REQ_F_TIMEOUT_BIT,
476 : : REQ_F_ISREG_BIT,
477 : : REQ_F_MUST_PUNT_BIT,
478 : : REQ_F_TIMEOUT_NOSEQ_BIT,
479 : : REQ_F_COMP_LOCKED_BIT,
480 : : REQ_F_NEED_CLEANUP_BIT,
481 : : REQ_F_OVERFLOW_BIT,
482 : : };
483 : :
484 : : enum {
485 : : /* ctx owns file */
486 : : REQ_F_FIXED_FILE = BIT(REQ_F_FIXED_FILE_BIT),
487 : : /* drain existing IO first */
488 : : REQ_F_IO_DRAIN = BIT(REQ_F_IO_DRAIN_BIT),
489 : : /* linked sqes */
490 : : REQ_F_LINK = BIT(REQ_F_LINK_BIT),
491 : : /* doesn't sever on completion < 0 */
492 : : REQ_F_HARDLINK = BIT(REQ_F_HARDLINK_BIT),
493 : : /* IOSQE_ASYNC */
494 : : REQ_F_FORCE_ASYNC = BIT(REQ_F_FORCE_ASYNC_BIT),
495 : :
496 : : /* already grabbed next link */
497 : : REQ_F_LINK_NEXT = BIT(REQ_F_LINK_NEXT_BIT),
498 : : /* fail rest of links */
499 : : REQ_F_FAIL_LINK = BIT(REQ_F_FAIL_LINK_BIT),
500 : : /* on inflight list */
501 : : REQ_F_INFLIGHT = BIT(REQ_F_INFLIGHT_BIT),
502 : : /* read/write uses file position */
503 : : REQ_F_CUR_POS = BIT(REQ_F_CUR_POS_BIT),
504 : : /* must not punt to workers */
505 : : REQ_F_NOWAIT = BIT(REQ_F_NOWAIT_BIT),
506 : : /* polled IO has completed */
507 : : REQ_F_IOPOLL_COMPLETED = BIT(REQ_F_IOPOLL_COMPLETED_BIT),
508 : : /* has linked timeout */
509 : : REQ_F_LINK_TIMEOUT = BIT(REQ_F_LINK_TIMEOUT_BIT),
510 : : /* timeout request */
511 : : REQ_F_TIMEOUT = BIT(REQ_F_TIMEOUT_BIT),
512 : : /* regular file */
513 : : REQ_F_ISREG = BIT(REQ_F_ISREG_BIT),
514 : : /* must be punted even for NONBLOCK */
515 : : REQ_F_MUST_PUNT = BIT(REQ_F_MUST_PUNT_BIT),
516 : : /* no timeout sequence */
517 : : REQ_F_TIMEOUT_NOSEQ = BIT(REQ_F_TIMEOUT_NOSEQ_BIT),
518 : : /* completion under lock */
519 : : REQ_F_COMP_LOCKED = BIT(REQ_F_COMP_LOCKED_BIT),
520 : : /* needs cleanup */
521 : : REQ_F_NEED_CLEANUP = BIT(REQ_F_NEED_CLEANUP_BIT),
522 : : /* in overflow list */
523 : : REQ_F_OVERFLOW = BIT(REQ_F_OVERFLOW_BIT),
524 : : };
525 : :
526 : : /*
527 : : * NOTE! Each of the iocb union members has the file pointer
528 : : * as the first entry in their struct definition. So you can
529 : : * access the file pointer through any of the sub-structs,
530 : : * or directly as just 'ki_filp' in this struct.
531 : : */
532 : : struct io_kiocb {
533 : : union {
534 : : struct file *file;
535 : : struct io_rw rw;
536 : : struct io_poll_iocb poll;
537 : : struct io_accept accept;
538 : : struct io_sync sync;
539 : : struct io_cancel cancel;
540 : : struct io_timeout timeout;
541 : : struct io_connect connect;
542 : : struct io_sr_msg sr_msg;
543 : : struct io_open open;
544 : : struct io_close close;
545 : : struct io_files_update files_update;
546 : : struct io_fadvise fadvise;
547 : : struct io_madvise madvise;
548 : : struct io_epoll epoll;
549 : : };
550 : :
551 : : struct io_async_ctx *io;
552 : : /*
553 : : * llist_node is only used for poll deferred completions
554 : : */
555 : : struct llist_node llist_node;
556 : : bool in_async;
557 : : bool needs_fixed_file;
558 : : u8 opcode;
559 : :
560 : : struct io_ring_ctx *ctx;
561 : : union {
562 : : struct list_head list;
563 : : struct hlist_node hash_node;
564 : : };
565 : : struct list_head link_list;
566 : : unsigned int flags;
567 : : refcount_t refs;
568 : : u64 user_data;
569 : : u32 result;
570 : : u32 sequence;
571 : :
572 : : struct list_head inflight_entry;
573 : :
574 : : struct io_wq_work work;
575 : : };
576 : :
577 : : #define IO_PLUG_THRESHOLD 2
578 : : #define IO_IOPOLL_BATCH 8
579 : :
580 : : struct io_submit_state {
581 : : struct blk_plug plug;
582 : :
583 : : /*
584 : : * io_kiocb alloc cache
585 : : */
586 : : void *reqs[IO_IOPOLL_BATCH];
587 : : unsigned int free_reqs;
588 : :
589 : : /*
590 : : * File reference cache
591 : : */
592 : : struct file *file;
593 : : unsigned int fd;
594 : : unsigned int has_refs;
595 : : unsigned int used_refs;
596 : : unsigned int ios_left;
597 : : };
598 : :
599 : : struct io_op_def {
600 : : /* needs req->io allocated for deferral/async */
601 : : unsigned async_ctx : 1;
602 : : /* needs current->mm setup, does mm access */
603 : : unsigned needs_mm : 1;
604 : : /* needs req->file assigned */
605 : : unsigned needs_file : 1;
606 : : /* needs req->file assigned IFF fd is >= 0 */
607 : : unsigned fd_non_neg : 1;
608 : : /* hash wq insertion if file is a regular file */
609 : : unsigned hash_reg_file : 1;
610 : : /* unbound wq insertion if file is a non-regular file */
611 : : unsigned unbound_nonreg_file : 1;
612 : : /* opcode is not supported by this kernel */
613 : : unsigned not_supported : 1;
614 : : /* needs file table */
615 : : unsigned file_table : 1;
616 : : /* needs ->fs */
617 : : unsigned needs_fs : 1;
618 : : };
619 : :
620 : : static const struct io_op_def io_op_defs[] = {
621 : : [IORING_OP_NOP] = {},
622 : : [IORING_OP_READV] = {
623 : : .async_ctx = 1,
624 : : .needs_mm = 1,
625 : : .needs_file = 1,
626 : : .unbound_nonreg_file = 1,
627 : : },
628 : : [IORING_OP_WRITEV] = {
629 : : .async_ctx = 1,
630 : : .needs_mm = 1,
631 : : .needs_file = 1,
632 : : .hash_reg_file = 1,
633 : : .unbound_nonreg_file = 1,
634 : : },
635 : : [IORING_OP_FSYNC] = {
636 : : .needs_file = 1,
637 : : },
638 : : [IORING_OP_READ_FIXED] = {
639 : : .needs_file = 1,
640 : : .unbound_nonreg_file = 1,
641 : : },
642 : : [IORING_OP_WRITE_FIXED] = {
643 : : .needs_file = 1,
644 : : .hash_reg_file = 1,
645 : : .unbound_nonreg_file = 1,
646 : : },
647 : : [IORING_OP_POLL_ADD] = {
648 : : .needs_file = 1,
649 : : .unbound_nonreg_file = 1,
650 : : },
651 : : [IORING_OP_POLL_REMOVE] = {},
652 : : [IORING_OP_SYNC_FILE_RANGE] = {
653 : : .needs_file = 1,
654 : : },
655 : : [IORING_OP_SENDMSG] = {
656 : : .async_ctx = 1,
657 : : .needs_mm = 1,
658 : : .needs_file = 1,
659 : : .unbound_nonreg_file = 1,
660 : : .needs_fs = 1,
661 : : },
662 : : [IORING_OP_RECVMSG] = {
663 : : .async_ctx = 1,
664 : : .needs_mm = 1,
665 : : .needs_file = 1,
666 : : .unbound_nonreg_file = 1,
667 : : .needs_fs = 1,
668 : : },
669 : : [IORING_OP_TIMEOUT] = {
670 : : .async_ctx = 1,
671 : : .needs_mm = 1,
672 : : },
673 : : [IORING_OP_TIMEOUT_REMOVE] = {},
674 : : [IORING_OP_ACCEPT] = {
675 : : .needs_mm = 1,
676 : : .needs_file = 1,
677 : : .unbound_nonreg_file = 1,
678 : : .file_table = 1,
679 : : },
680 : : [IORING_OP_ASYNC_CANCEL] = {},
681 : : [IORING_OP_LINK_TIMEOUT] = {
682 : : .async_ctx = 1,
683 : : .needs_mm = 1,
684 : : },
685 : : [IORING_OP_CONNECT] = {
686 : : .async_ctx = 1,
687 : : .needs_mm = 1,
688 : : .needs_file = 1,
689 : : .unbound_nonreg_file = 1,
690 : : },
691 : : [IORING_OP_FALLOCATE] = {
692 : : .needs_file = 1,
693 : : },
694 : : [IORING_OP_OPENAT] = {
695 : : .needs_file = 1,
696 : : .fd_non_neg = 1,
697 : : .file_table = 1,
698 : : .needs_fs = 1,
699 : : },
700 : : [IORING_OP_CLOSE] = {
701 : : .needs_file = 1,
702 : : .file_table = 1,
703 : : },
704 : : [IORING_OP_FILES_UPDATE] = {
705 : : .needs_mm = 1,
706 : : .file_table = 1,
707 : : },
708 : : [IORING_OP_STATX] = {
709 : : .needs_mm = 1,
710 : : .needs_file = 1,
711 : : .fd_non_neg = 1,
712 : : .needs_fs = 1,
713 : : },
714 : : [IORING_OP_READ] = {
715 : : .needs_mm = 1,
716 : : .needs_file = 1,
717 : : .unbound_nonreg_file = 1,
718 : : },
719 : : [IORING_OP_WRITE] = {
720 : : .needs_mm = 1,
721 : : .needs_file = 1,
722 : : .unbound_nonreg_file = 1,
723 : : },
724 : : [IORING_OP_FADVISE] = {
725 : : .needs_file = 1,
726 : : },
727 : : [IORING_OP_MADVISE] = {
728 : : .needs_mm = 1,
729 : : },
730 : : [IORING_OP_SEND] = {
731 : : .needs_mm = 1,
732 : : .needs_file = 1,
733 : : .unbound_nonreg_file = 1,
734 : : },
735 : : [IORING_OP_RECV] = {
736 : : .needs_mm = 1,
737 : : .needs_file = 1,
738 : : .unbound_nonreg_file = 1,
739 : : },
740 : : [IORING_OP_OPENAT2] = {
741 : : .needs_file = 1,
742 : : .fd_non_neg = 1,
743 : : .file_table = 1,
744 : : .needs_fs = 1,
745 : : },
746 : : [IORING_OP_EPOLL_CTL] = {
747 : : .unbound_nonreg_file = 1,
748 : : .file_table = 1,
749 : : },
750 : : };
751 : :
752 : : static void io_wq_submit_work(struct io_wq_work **workptr);
753 : : static void io_cqring_fill_event(struct io_kiocb *req, long res);
754 : : static void io_put_req(struct io_kiocb *req);
755 : : static void __io_double_put_req(struct io_kiocb *req);
756 : : static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req);
757 : : static void io_queue_linked_timeout(struct io_kiocb *req);
758 : : static int __io_sqe_files_update(struct io_ring_ctx *ctx,
759 : : struct io_uring_files_update *ip,
760 : : unsigned nr_args);
761 : : static int io_grab_files(struct io_kiocb *req);
762 : : static void io_ring_file_ref_flush(struct fixed_file_data *data);
763 : : static void io_cleanup_req(struct io_kiocb *req);
764 : :
765 : : static struct kmem_cache *req_cachep;
766 : :
767 : : static const struct file_operations io_uring_fops;
768 : :
769 : 0 : struct sock *io_uring_get_socket(struct file *file)
770 : : {
771 : : #if defined(CONFIG_UNIX)
772 [ # # ]: 0 : if (file->f_op == &io_uring_fops) {
773 : 0 : struct io_ring_ctx *ctx = file->private_data;
774 : :
775 : 0 : return ctx->ring_sock->sk;
776 : : }
777 : : #endif
778 : : return NULL;
779 : : }
780 : : EXPORT_SYMBOL(io_uring_get_socket);
781 : :
782 : 0 : static void io_ring_ctx_ref_free(struct percpu_ref *ref)
783 : : {
784 : 0 : struct io_ring_ctx *ctx = container_of(ref, struct io_ring_ctx, refs);
785 : :
786 : 0 : complete(&ctx->completions[0]);
787 : 0 : }
788 : :
789 : : static struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
790 : : {
791 : : struct io_ring_ctx *ctx;
792 : : int hash_bits;
793 : :
794 : : ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
795 : : if (!ctx)
796 : : return NULL;
797 : :
798 : : ctx->fallback_req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
799 : : if (!ctx->fallback_req)
800 : : goto err;
801 : :
802 : : ctx->completions = kmalloc(2 * sizeof(struct completion), GFP_KERNEL);
803 : : if (!ctx->completions)
804 : : goto err;
805 : :
806 : : /*
807 : : * Use 5 bits less than the max cq entries, that should give us around
808 : : * 32 entries per hash list if totally full and uniformly spread.
809 : : */
810 : : hash_bits = ilog2(p->cq_entries);
811 : : hash_bits -= 5;
812 : : if (hash_bits <= 0)
813 : : hash_bits = 1;
814 : : ctx->cancel_hash_bits = hash_bits;
815 : : ctx->cancel_hash = kmalloc((1U << hash_bits) * sizeof(struct hlist_head),
816 : : GFP_KERNEL);
817 : : if (!ctx->cancel_hash)
818 : : goto err;
819 : : __hash_init(ctx->cancel_hash, 1U << hash_bits);
820 : :
821 : : if (percpu_ref_init(&ctx->refs, io_ring_ctx_ref_free,
822 : : PERCPU_REF_ALLOW_REINIT, GFP_KERNEL))
823 : : goto err;
824 : :
825 : : ctx->flags = p->flags;
826 : : init_waitqueue_head(&ctx->cq_wait);
827 : : INIT_LIST_HEAD(&ctx->cq_overflow_list);
828 : : init_completion(&ctx->completions[0]);
829 : : init_completion(&ctx->completions[1]);
830 : : idr_init(&ctx->personality_idr);
831 : : mutex_init(&ctx->uring_lock);
832 : : init_waitqueue_head(&ctx->wait);
833 : : spin_lock_init(&ctx->completion_lock);
834 : : init_llist_head(&ctx->poll_llist);
835 : : INIT_LIST_HEAD(&ctx->poll_list);
836 : : INIT_LIST_HEAD(&ctx->defer_list);
837 : : INIT_LIST_HEAD(&ctx->timeout_list);
838 : : init_waitqueue_head(&ctx->inflight_wait);
839 : : spin_lock_init(&ctx->inflight_lock);
840 : : INIT_LIST_HEAD(&ctx->inflight_list);
841 : : return ctx;
842 : : err:
843 : : if (ctx->fallback_req)
844 : : kmem_cache_free(req_cachep, ctx->fallback_req);
845 : : kfree(ctx->completions);
846 : : kfree(ctx->cancel_hash);
847 : : kfree(ctx);
848 : : return NULL;
849 : : }
850 : :
851 : 0 : static inline bool __req_need_defer(struct io_kiocb *req)
852 : : {
853 : 0 : struct io_ring_ctx *ctx = req->ctx;
854 : :
855 : 0 : return req->sequence != ctx->cached_cq_tail + ctx->cached_sq_dropped
856 : 0 : + atomic_read(&ctx->cached_cq_overflow);
857 : : }
858 : :
859 : 0 : static inline bool req_need_defer(struct io_kiocb *req)
860 : : {
861 [ # # ]: 0 : if (unlikely(req->flags & REQ_F_IO_DRAIN))
862 : 0 : return __req_need_defer(req);
863 : :
864 : : return false;
865 : : }
866 : :
867 : 0 : static struct io_kiocb *io_get_deferred_req(struct io_ring_ctx *ctx)
868 : : {
869 : 0 : struct io_kiocb *req;
870 : :
871 [ # # ]: 0 : req = list_first_entry_or_null(&ctx->defer_list, struct io_kiocb, list);
872 [ # # # # ]: 0 : if (req && !req_need_defer(req)) {
873 : 0 : list_del_init(&req->list);
874 : 0 : return req;
875 : : }
876 : :
877 : : return NULL;
878 : : }
879 : :
880 : 0 : static struct io_kiocb *io_get_timeout_req(struct io_ring_ctx *ctx)
881 : : {
882 : 0 : struct io_kiocb *req;
883 : :
884 [ # # ]: 0 : req = list_first_entry_or_null(&ctx->timeout_list, struct io_kiocb, list);
885 [ # # ]: 0 : if (req) {
886 [ # # ]: 0 : if (req->flags & REQ_F_TIMEOUT_NOSEQ)
887 : : return NULL;
888 [ # # ]: 0 : if (!__req_need_defer(req)) {
889 : 0 : list_del_init(&req->list);
890 : 0 : return req;
891 : : }
892 : : }
893 : :
894 : : return NULL;
895 : : }
896 : :
897 : 0 : static void __io_commit_cqring(struct io_ring_ctx *ctx)
898 : : {
899 : 0 : struct io_rings *rings = ctx->rings;
900 : :
901 : : /* order cqe stores with ring update */
902 : 0 : smp_store_release(&rings->cq.tail, ctx->cached_cq_tail);
903 : :
904 [ # # ]: 0 : if (wq_has_sleeper(&ctx->cq_wait)) {
905 : 0 : wake_up_interruptible(&ctx->cq_wait);
906 : 0 : kill_fasync(&ctx->cq_fasync, SIGIO, POLL_IN);
907 : : }
908 : 0 : }
909 : :
910 : : static inline void io_req_work_grab_env(struct io_kiocb *req,
911 : : const struct io_op_def *def)
912 : : {
913 : : if (!req->work.mm && def->needs_mm) {
914 : : mmgrab(current->mm);
915 : : req->work.mm = current->mm;
916 : : }
917 : : if (!req->work.creds)
918 : : req->work.creds = get_current_cred();
919 : : if (!req->work.fs && def->needs_fs) {
920 : : spin_lock(¤t->fs->lock);
921 : : if (!current->fs->in_exec) {
922 : : req->work.fs = current->fs;
923 : : req->work.fs->users++;
924 : : } else {
925 : : req->work.flags |= IO_WQ_WORK_CANCEL;
926 : : }
927 : : spin_unlock(¤t->fs->lock);
928 : : }
929 : : if (!req->work.task_pid)
930 : : req->work.task_pid = task_pid_vnr(current);
931 : : }
932 : :
933 : 0 : static inline void io_req_work_drop_env(struct io_kiocb *req)
934 : : {
935 [ # # ]: 0 : if (req->work.mm) {
936 : 0 : mmdrop(req->work.mm);
937 : 0 : req->work.mm = NULL;
938 : : }
939 [ # # ]: 0 : if (req->work.creds) {
940 : 0 : put_cred(req->work.creds);
941 : 0 : req->work.creds = NULL;
942 : : }
943 [ # # ]: 0 : if (req->work.fs) {
944 : 0 : struct fs_struct *fs = req->work.fs;
945 : :
946 : 0 : spin_lock(&req->work.fs->lock);
947 [ # # ]: 0 : if (--fs->users)
948 : 0 : fs = NULL;
949 : 0 : spin_unlock(&req->work.fs->lock);
950 [ # # ]: 0 : if (fs)
951 : 0 : free_fs_struct(fs);
952 : : }
953 : 0 : }
954 : :
955 : 0 : static inline bool io_prep_async_work(struct io_kiocb *req,
956 : : struct io_kiocb **link)
957 : : {
958 : 0 : const struct io_op_def *def = &io_op_defs[req->opcode];
959 : 0 : bool do_hashed = false;
960 : :
961 [ # # ]: 0 : if (req->flags & REQ_F_ISREG) {
962 [ # # ]: 0 : if (def->hash_reg_file)
963 : 0 : do_hashed = true;
964 : : } else {
965 [ # # ]: 0 : if (def->unbound_nonreg_file)
966 : 0 : req->work.flags |= IO_WQ_WORK_UNBOUND;
967 : : }
968 : :
969 : 0 : io_req_work_grab_env(req, def);
970 : :
971 : 0 : *link = io_prep_linked_timeout(req);
972 : 0 : return do_hashed;
973 : : }
974 : :
975 : 0 : static inline void io_queue_async_work(struct io_kiocb *req)
976 : : {
977 : 0 : struct io_ring_ctx *ctx = req->ctx;
978 : 0 : struct io_kiocb *link;
979 : 0 : bool do_hashed;
980 : :
981 : 0 : do_hashed = io_prep_async_work(req, &link);
982 : :
983 : 0 : trace_io_uring_queue_async_work(ctx, do_hashed, req, &req->work,
984 : : req->flags);
985 [ # # ]: 0 : if (!do_hashed) {
986 : 0 : io_wq_enqueue(ctx->io_wq, &req->work);
987 : : } else {
988 : 0 : io_wq_enqueue_hashed(ctx->io_wq, &req->work,
989 : 0 : file_inode(req->file));
990 : : }
991 : :
992 [ # # ]: 0 : if (link)
993 : 0 : io_queue_linked_timeout(link);
994 : 0 : }
995 : :
996 : 0 : static void io_kill_timeout(struct io_kiocb *req)
997 : : {
998 : 0 : int ret;
999 : :
1000 : 0 : ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
1001 [ # # ]: 0 : if (ret != -1) {
1002 : 0 : atomic_inc(&req->ctx->cq_timeouts);
1003 : 0 : list_del_init(&req->list);
1004 : 0 : req->flags |= REQ_F_COMP_LOCKED;
1005 : 0 : io_cqring_fill_event(req, 0);
1006 : 0 : io_put_req(req);
1007 : : }
1008 : 0 : }
1009 : :
1010 : 0 : static void io_kill_timeouts(struct io_ring_ctx *ctx)
1011 : : {
1012 : 0 : struct io_kiocb *req, *tmp;
1013 : :
1014 : 0 : spin_lock_irq(&ctx->completion_lock);
1015 [ # # ]: 0 : list_for_each_entry_safe(req, tmp, &ctx->timeout_list, list)
1016 : 0 : io_kill_timeout(req);
1017 : 0 : spin_unlock_irq(&ctx->completion_lock);
1018 : 0 : }
1019 : :
1020 : 0 : static void io_commit_cqring(struct io_ring_ctx *ctx)
1021 : : {
1022 : 0 : struct io_kiocb *req;
1023 : :
1024 [ # # ]: 0 : while ((req = io_get_timeout_req(ctx)) != NULL)
1025 : 0 : io_kill_timeout(req);
1026 : :
1027 : 0 : __io_commit_cqring(ctx);
1028 : :
1029 [ # # ]: 0 : while ((req = io_get_deferred_req(ctx)) != NULL)
1030 : 0 : io_queue_async_work(req);
1031 : 0 : }
1032 : :
1033 : 0 : static struct io_uring_cqe *io_get_cqring(struct io_ring_ctx *ctx)
1034 : : {
1035 : 0 : struct io_rings *rings = ctx->rings;
1036 : 0 : unsigned tail;
1037 : :
1038 : 0 : tail = ctx->cached_cq_tail;
1039 : : /*
1040 : : * writes to the cq entry need to come after reading head; the
1041 : : * control dependency is enough as we're using WRITE_ONCE to
1042 : : * fill the cq entry
1043 : : */
1044 : 0 : if (tail - READ_ONCE(rings->cq.head) == rings->cq_ring_entries)
1045 : : return NULL;
1046 : :
1047 : 0 : ctx->cached_cq_tail++;
1048 : 0 : return &rings->cqes[tail & ctx->cq_mask];
1049 : : }
1050 : :
1051 : 0 : static inline bool io_should_trigger_evfd(struct io_ring_ctx *ctx)
1052 : : {
1053 [ # # ]: 0 : if (!ctx->cq_ev_fd)
1054 : : return false;
1055 [ # # ]: 0 : if (!ctx->eventfd_async)
1056 : : return true;
1057 [ # # # # : 0 : return io_wq_current_is_worker() || in_interrupt();
# # ]
1058 : : }
1059 : :
1060 : 0 : static void __io_cqring_ev_posted(struct io_ring_ctx *ctx, bool trigger_ev)
1061 : : {
1062 [ # # ]: 0 : if (waitqueue_active(&ctx->wait))
1063 : 0 : wake_up(&ctx->wait);
1064 [ # # ]: 0 : if (waitqueue_active(&ctx->sqo_wait))
1065 : 0 : wake_up(&ctx->sqo_wait);
1066 [ # # ]: 0 : if (trigger_ev)
1067 : 0 : eventfd_signal(ctx->cq_ev_fd, 1);
1068 : 0 : }
1069 : :
1070 : 0 : static void io_cqring_ev_posted(struct io_ring_ctx *ctx)
1071 : : {
1072 : 0 : __io_cqring_ev_posted(ctx, io_should_trigger_evfd(ctx));
1073 : 0 : }
1074 : :
1075 : : /* Returns true if there are no backlogged entries after the flush */
1076 : 0 : static bool io_cqring_overflow_flush(struct io_ring_ctx *ctx, bool force)
1077 : : {
1078 : 0 : struct io_rings *rings = ctx->rings;
1079 : 0 : struct io_uring_cqe *cqe;
1080 : 0 : struct io_kiocb *req;
1081 : 0 : unsigned long flags;
1082 : 0 : LIST_HEAD(list);
1083 : :
1084 [ # # ]: 0 : if (!force) {
1085 [ # # ]: 0 : if (list_empty_careful(&ctx->cq_overflow_list))
1086 : : return true;
1087 [ # # ]: 0 : if ((ctx->cached_cq_tail - READ_ONCE(rings->cq.head) ==
1088 [ # # ]: 0 : rings->cq_ring_entries))
1089 : : return false;
1090 : : }
1091 : :
1092 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
1093 : :
1094 : : /* if force is set, the ring is going away. always drop after that */
1095 [ # # ]: 0 : if (force)
1096 : 0 : ctx->cq_overflow_flushed = 1;
1097 : :
1098 : : cqe = NULL;
1099 [ # # ]: 0 : while (!list_empty(&ctx->cq_overflow_list)) {
1100 [ # # ]: 0 : cqe = io_get_cqring(ctx);
1101 [ # # ]: 0 : if (!cqe && !force)
1102 : : break;
1103 : :
1104 : 0 : req = list_first_entry(&ctx->cq_overflow_list, struct io_kiocb,
1105 : : list);
1106 [ # # ]: 0 : list_move(&req->list, &list);
1107 : 0 : req->flags &= ~REQ_F_OVERFLOW;
1108 [ # # ]: 0 : if (cqe) {
1109 : 0 : WRITE_ONCE(cqe->user_data, req->user_data);
1110 : 0 : WRITE_ONCE(cqe->res, req->result);
1111 : 0 : WRITE_ONCE(cqe->flags, 0);
1112 : : } else {
1113 : 0 : WRITE_ONCE(ctx->rings->cq_overflow,
1114 : : atomic_inc_return(&ctx->cached_cq_overflow));
1115 : : }
1116 : : }
1117 : :
1118 : 0 : io_commit_cqring(ctx);
1119 [ # # ]: 0 : if (cqe) {
1120 : 0 : clear_bit(0, &ctx->sq_check_overflow);
1121 : 0 : clear_bit(0, &ctx->cq_check_overflow);
1122 : : }
1123 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
1124 : 0 : io_cqring_ev_posted(ctx);
1125 : :
1126 [ # # ]: 0 : while (!list_empty(&list)) {
1127 : 0 : req = list_first_entry(&list, struct io_kiocb, list);
1128 : 0 : list_del(&req->list);
1129 : 0 : io_put_req(req);
1130 : : }
1131 : :
1132 : 0 : return cqe != NULL;
1133 : : }
1134 : :
1135 : 0 : static void io_cqring_fill_event(struct io_kiocb *req, long res)
1136 : : {
1137 : 0 : struct io_ring_ctx *ctx = req->ctx;
1138 : 0 : struct io_uring_cqe *cqe;
1139 : :
1140 : 0 : trace_io_uring_complete(ctx, req->user_data, res);
1141 : :
1142 : : /*
1143 : : * If we can't get a cq entry, userspace overflowed the
1144 : : * submission (by quite a lot). Increment the overflow count in
1145 : : * the ring.
1146 : : */
1147 [ # # ]: 0 : cqe = io_get_cqring(ctx);
1148 [ # # ]: 0 : if (likely(cqe)) {
1149 : 0 : WRITE_ONCE(cqe->user_data, req->user_data);
1150 : 0 : WRITE_ONCE(cqe->res, res);
1151 : 0 : WRITE_ONCE(cqe->flags, 0);
1152 [ # # ]: 0 : } else if (ctx->cq_overflow_flushed) {
1153 : 0 : WRITE_ONCE(ctx->rings->cq_overflow,
1154 : : atomic_inc_return(&ctx->cached_cq_overflow));
1155 : : } else {
1156 [ # # ]: 0 : if (list_empty(&ctx->cq_overflow_list)) {
1157 : 0 : set_bit(0, &ctx->sq_check_overflow);
1158 : 0 : set_bit(0, &ctx->cq_check_overflow);
1159 : : }
1160 : 0 : req->flags |= REQ_F_OVERFLOW;
1161 : 0 : refcount_inc(&req->refs);
1162 : 0 : req->result = res;
1163 : 0 : list_add_tail(&req->list, &ctx->cq_overflow_list);
1164 : : }
1165 : 0 : }
1166 : :
1167 : 0 : static void io_cqring_add_event(struct io_kiocb *req, long res)
1168 : : {
1169 : 0 : struct io_ring_ctx *ctx = req->ctx;
1170 : 0 : unsigned long flags;
1171 : :
1172 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
1173 : 0 : io_cqring_fill_event(req, res);
1174 : 0 : io_commit_cqring(ctx);
1175 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
1176 : :
1177 : 0 : io_cqring_ev_posted(ctx);
1178 : 0 : }
1179 : :
1180 : 0 : static inline bool io_is_fallback_req(struct io_kiocb *req)
1181 : : {
1182 : 0 : return req == (struct io_kiocb *)
1183 : 0 : ((unsigned long) req->ctx->fallback_req & ~1UL);
1184 : : }
1185 : :
1186 : 0 : static struct io_kiocb *io_get_fallback_req(struct io_ring_ctx *ctx)
1187 : : {
1188 : 0 : struct io_kiocb *req;
1189 : :
1190 : 0 : req = ctx->fallback_req;
1191 [ # # ]: 0 : if (!test_and_set_bit_lock(0, (unsigned long *) ctx->fallback_req))
1192 : 0 : return req;
1193 : :
1194 : : return NULL;
1195 : : }
1196 : :
1197 : 0 : static struct io_kiocb *io_get_req(struct io_ring_ctx *ctx,
1198 : : struct io_submit_state *state)
1199 : : {
1200 : 0 : gfp_t gfp = GFP_KERNEL | __GFP_NOWARN;
1201 : 0 : struct io_kiocb *req;
1202 : :
1203 [ # # ]: 0 : if (!state) {
1204 : 0 : req = kmem_cache_alloc(req_cachep, gfp);
1205 [ # # ]: 0 : if (unlikely(!req))
1206 : 0 : goto fallback;
1207 [ # # ]: 0 : } else if (!state->free_reqs) {
1208 : 0 : size_t sz;
1209 : 0 : int ret;
1210 : :
1211 : 0 : sz = min_t(size_t, state->ios_left, ARRAY_SIZE(state->reqs));
1212 : 0 : ret = kmem_cache_alloc_bulk(req_cachep, gfp, sz, state->reqs);
1213 : :
1214 : : /*
1215 : : * Bulk alloc is all-or-nothing. If we fail to get a batch,
1216 : : * retry single alloc to be on the safe side.
1217 : : */
1218 [ # # ]: 0 : if (unlikely(ret <= 0)) {
1219 : 0 : state->reqs[0] = kmem_cache_alloc(req_cachep, gfp);
1220 [ # # ]: 0 : if (!state->reqs[0])
1221 : 0 : goto fallback;
1222 : : ret = 1;
1223 : : }
1224 : 0 : state->free_reqs = ret - 1;
1225 : 0 : req = state->reqs[ret - 1];
1226 : : } else {
1227 : 0 : state->free_reqs--;
1228 : 0 : req = state->reqs[state->free_reqs];
1229 : : }
1230 : :
1231 : 0 : got_it:
1232 : 0 : req->io = NULL;
1233 : 0 : req->file = NULL;
1234 : 0 : req->ctx = ctx;
1235 : 0 : req->flags = 0;
1236 : : /* one is dropped after submission, the other at completion */
1237 : 0 : refcount_set(&req->refs, 2);
1238 : 0 : req->result = 0;
1239 : 0 : INIT_IO_WORK(&req->work, io_wq_submit_work);
1240 : 0 : return req;
1241 : 0 : fallback:
1242 : 0 : req = io_get_fallback_req(ctx);
1243 [ # # ]: 0 : if (req)
1244 : 0 : goto got_it;
1245 : 0 : percpu_ref_put(&ctx->refs);
1246 : 0 : return NULL;
1247 : : }
1248 : :
1249 : 0 : static void __io_req_do_free(struct io_kiocb *req)
1250 : : {
1251 [ # # ]: 0 : if (likely(!io_is_fallback_req(req)))
1252 : 0 : kmem_cache_free(req_cachep, req);
1253 : : else
1254 : 0 : clear_bit_unlock(0, (unsigned long *) req->ctx->fallback_req);
1255 : 0 : }
1256 : :
1257 : 0 : static void __io_req_aux_free(struct io_kiocb *req)
1258 : : {
1259 : 0 : struct io_ring_ctx *ctx = req->ctx;
1260 : :
1261 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
1262 : 0 : io_cleanup_req(req);
1263 : :
1264 : 0 : kfree(req->io);
1265 [ # # ]: 0 : if (req->file) {
1266 [ # # ]: 0 : if (req->flags & REQ_F_FIXED_FILE)
1267 : 0 : percpu_ref_put(&ctx->file_data->refs);
1268 : : else
1269 : 0 : fput(req->file);
1270 : : }
1271 : :
1272 : 0 : io_req_work_drop_env(req);
1273 : 0 : }
1274 : :
1275 : 0 : static void __io_free_req(struct io_kiocb *req)
1276 : : {
1277 : 0 : __io_req_aux_free(req);
1278 : :
1279 [ # # ]: 0 : if (req->flags & REQ_F_INFLIGHT) {
1280 : 0 : struct io_ring_ctx *ctx = req->ctx;
1281 : 0 : unsigned long flags;
1282 : :
1283 : 0 : spin_lock_irqsave(&ctx->inflight_lock, flags);
1284 [ # # ]: 0 : list_del(&req->inflight_entry);
1285 [ # # ]: 0 : if (waitqueue_active(&ctx->inflight_wait))
1286 : 0 : wake_up(&ctx->inflight_wait);
1287 : 0 : spin_unlock_irqrestore(&ctx->inflight_lock, flags);
1288 : : }
1289 : :
1290 : 0 : percpu_ref_put(&req->ctx->refs);
1291 : 0 : __io_req_do_free(req);
1292 : 0 : }
1293 : :
1294 : : struct req_batch {
1295 : : void *reqs[IO_IOPOLL_BATCH];
1296 : : int to_free;
1297 : : int need_iter;
1298 : : };
1299 : :
1300 : 0 : static void io_free_req_many(struct io_ring_ctx *ctx, struct req_batch *rb)
1301 : : {
1302 : 0 : int fixed_refs = rb->to_free;
1303 : :
1304 [ # # ]: 0 : if (!rb->to_free)
1305 : : return;
1306 [ # # ]: 0 : if (rb->need_iter) {
1307 : : int i, inflight = 0;
1308 : : unsigned long flags;
1309 : :
1310 : : fixed_refs = 0;
1311 [ # # ]: 0 : for (i = 0; i < rb->to_free; i++) {
1312 : 0 : struct io_kiocb *req = rb->reqs[i];
1313 : :
1314 [ # # ]: 0 : if (req->flags & REQ_F_FIXED_FILE) {
1315 : 0 : req->file = NULL;
1316 : 0 : fixed_refs++;
1317 : : }
1318 [ # # ]: 0 : if (req->flags & REQ_F_INFLIGHT)
1319 : 0 : inflight++;
1320 : 0 : __io_req_aux_free(req);
1321 : : }
1322 [ # # ]: 0 : if (!inflight)
1323 : 0 : goto do_free;
1324 : :
1325 : 0 : spin_lock_irqsave(&ctx->inflight_lock, flags);
1326 [ # # ]: 0 : for (i = 0; i < rb->to_free; i++) {
1327 : 0 : struct io_kiocb *req = rb->reqs[i];
1328 : :
1329 [ # # ]: 0 : if (req->flags & REQ_F_INFLIGHT) {
1330 [ # # ]: 0 : list_del(&req->inflight_entry);
1331 [ # # ]: 0 : if (!--inflight)
1332 : : break;
1333 : : }
1334 : : }
1335 : 0 : spin_unlock_irqrestore(&ctx->inflight_lock, flags);
1336 : :
1337 [ # # ]: 0 : if (waitqueue_active(&ctx->inflight_wait))
1338 : 0 : wake_up(&ctx->inflight_wait);
1339 : : }
1340 : 0 : do_free:
1341 : 0 : kmem_cache_free_bulk(req_cachep, rb->to_free, rb->reqs);
1342 [ # # ]: 0 : if (fixed_refs)
1343 : 0 : percpu_ref_put_many(&ctx->file_data->refs, fixed_refs);
1344 : 0 : percpu_ref_put_many(&ctx->refs, rb->to_free);
1345 : 0 : rb->to_free = rb->need_iter = 0;
1346 : : }
1347 : :
1348 : 0 : static bool io_link_cancel_timeout(struct io_kiocb *req)
1349 : : {
1350 : 0 : struct io_ring_ctx *ctx = req->ctx;
1351 : 0 : int ret;
1352 : :
1353 : 0 : ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
1354 [ # # ]: 0 : if (ret != -1) {
1355 : 0 : io_cqring_fill_event(req, -ECANCELED);
1356 : 0 : io_commit_cqring(ctx);
1357 : 0 : req->flags &= ~REQ_F_LINK;
1358 : 0 : io_put_req(req);
1359 : 0 : return true;
1360 : : }
1361 : :
1362 : : return false;
1363 : : }
1364 : :
1365 : 0 : static void io_req_link_next(struct io_kiocb *req, struct io_kiocb **nxtptr)
1366 : : {
1367 : 0 : struct io_ring_ctx *ctx = req->ctx;
1368 : 0 : bool wake_ev = false;
1369 : :
1370 : : /* Already got next link */
1371 [ # # ]: 0 : if (req->flags & REQ_F_LINK_NEXT)
1372 : : return;
1373 : :
1374 : : /*
1375 : : * The list should never be empty when we are called here. But could
1376 : : * potentially happen if the chain is messed up, check to be on the
1377 : : * safe side.
1378 : : */
1379 [ # # ]: 0 : while (!list_empty(&req->link_list)) {
1380 : 0 : struct io_kiocb *nxt = list_first_entry(&req->link_list,
1381 : : struct io_kiocb, link_list);
1382 : :
1383 [ # # # # ]: 0 : if (unlikely((req->flags & REQ_F_LINK_TIMEOUT) &&
1384 : : (nxt->flags & REQ_F_TIMEOUT))) {
1385 : 0 : list_del_init(&nxt->link_list);
1386 : 0 : wake_ev |= io_link_cancel_timeout(nxt);
1387 : 0 : req->flags &= ~REQ_F_LINK_TIMEOUT;
1388 : 0 : continue;
1389 : : }
1390 : :
1391 [ # # ]: 0 : list_del_init(&req->link_list);
1392 [ # # ]: 0 : if (!list_empty(&nxt->link_list))
1393 : 0 : nxt->flags |= REQ_F_LINK;
1394 : 0 : *nxtptr = nxt;
1395 : 0 : break;
1396 : : }
1397 : :
1398 : 0 : req->flags |= REQ_F_LINK_NEXT;
1399 [ # # ]: 0 : if (wake_ev)
1400 : 0 : io_cqring_ev_posted(ctx);
1401 : : }
1402 : :
1403 : : /*
1404 : : * Called if REQ_F_LINK is set, and we fail the head request
1405 : : */
1406 : 0 : static void io_fail_links(struct io_kiocb *req)
1407 : : {
1408 : 0 : struct io_ring_ctx *ctx = req->ctx;
1409 : 0 : unsigned long flags;
1410 : :
1411 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
1412 : :
1413 [ # # ]: 0 : while (!list_empty(&req->link_list)) {
1414 : 0 : struct io_kiocb *link = list_first_entry(&req->link_list,
1415 : : struct io_kiocb, link_list);
1416 : :
1417 : 0 : list_del_init(&link->link_list);
1418 : 0 : trace_io_uring_fail_link(req, link);
1419 : :
1420 [ # # ]: 0 : if ((req->flags & REQ_F_LINK_TIMEOUT) &&
1421 [ # # ]: 0 : link->opcode == IORING_OP_LINK_TIMEOUT) {
1422 : 0 : io_link_cancel_timeout(link);
1423 : : } else {
1424 : 0 : io_cqring_fill_event(link, -ECANCELED);
1425 : 0 : __io_double_put_req(link);
1426 : : }
1427 : 0 : req->flags &= ~REQ_F_LINK_TIMEOUT;
1428 : : }
1429 : :
1430 : 0 : io_commit_cqring(ctx);
1431 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
1432 : 0 : io_cqring_ev_posted(ctx);
1433 : 0 : }
1434 : :
1435 : 0 : static void io_req_find_next(struct io_kiocb *req, struct io_kiocb **nxt)
1436 : : {
1437 [ # # ]: 0 : if (likely(!(req->flags & REQ_F_LINK)))
1438 : : return;
1439 : :
1440 : : /*
1441 : : * If LINK is set, we have dependent requests in this chain. If we
1442 : : * didn't fail this request, queue the first one up, moving any other
1443 : : * dependencies to the next request. In case of failure, fail the rest
1444 : : * of the chain.
1445 : : */
1446 [ # # ]: 0 : if (req->flags & REQ_F_FAIL_LINK) {
1447 : 0 : io_fail_links(req);
1448 [ # # ]: 0 : } else if ((req->flags & (REQ_F_LINK_TIMEOUT | REQ_F_COMP_LOCKED)) ==
1449 : : REQ_F_LINK_TIMEOUT) {
1450 : 0 : struct io_ring_ctx *ctx = req->ctx;
1451 : 0 : unsigned long flags;
1452 : :
1453 : : /*
1454 : : * If this is a timeout link, we could be racing with the
1455 : : * timeout timer. Grab the completion lock for this case to
1456 : : * protect against that.
1457 : : */
1458 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
1459 : 0 : io_req_link_next(req, nxt);
1460 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
1461 : : } else {
1462 : 0 : io_req_link_next(req, nxt);
1463 : : }
1464 : : }
1465 : :
1466 : 0 : static void io_free_req(struct io_kiocb *req)
1467 : : {
1468 : 0 : struct io_kiocb *nxt = NULL;
1469 : :
1470 : 0 : io_req_find_next(req, &nxt);
1471 : 0 : __io_free_req(req);
1472 : :
1473 [ # # ]: 0 : if (nxt)
1474 : 0 : io_queue_async_work(nxt);
1475 : 0 : }
1476 : :
1477 : : /*
1478 : : * Drop reference to request, return next in chain (if there is one) if this
1479 : : * was the last reference to this request.
1480 : : */
1481 : : __attribute__((nonnull))
1482 : 0 : static void io_put_req_find_next(struct io_kiocb *req, struct io_kiocb **nxtptr)
1483 : : {
1484 [ # # ]: 0 : if (refcount_dec_and_test(&req->refs)) {
1485 : 0 : io_req_find_next(req, nxtptr);
1486 : 0 : __io_free_req(req);
1487 : : }
1488 : 0 : }
1489 : :
1490 : 0 : static void io_put_req(struct io_kiocb *req)
1491 : : {
1492 [ # # ]: 0 : if (refcount_dec_and_test(&req->refs))
1493 : 0 : io_free_req(req);
1494 : 0 : }
1495 : :
1496 : : /*
1497 : : * Must only be used if we don't need to care about links, usually from
1498 : : * within the completion handling itself.
1499 : : */
1500 : 0 : static void __io_double_put_req(struct io_kiocb *req)
1501 : : {
1502 : : /* drop both submit and complete references */
1503 [ # # ]: 0 : if (refcount_sub_and_test(2, &req->refs))
1504 : 0 : __io_free_req(req);
1505 : 0 : }
1506 : :
1507 : 0 : static void io_double_put_req(struct io_kiocb *req)
1508 : : {
1509 : : /* drop both submit and complete references */
1510 [ # # ]: 0 : if (refcount_sub_and_test(2, &req->refs))
1511 : 0 : io_free_req(req);
1512 : 0 : }
1513 : :
1514 : 0 : static unsigned io_cqring_events(struct io_ring_ctx *ctx, bool noflush)
1515 : : {
1516 : 0 : struct io_rings *rings = ctx->rings;
1517 : :
1518 [ # # ]: 0 : if (test_bit(0, &ctx->cq_check_overflow)) {
1519 : : /*
1520 : : * noflush == true is from the waitqueue handler, just ensure
1521 : : * we wake up the task, and the next invocation will flush the
1522 : : * entries. We cannot safely to it from here.
1523 : : */
1524 [ # # # # ]: 0 : if (noflush && !list_empty(&ctx->cq_overflow_list))
1525 : : return -1U;
1526 : :
1527 : 0 : io_cqring_overflow_flush(ctx, false);
1528 : : }
1529 : :
1530 : : /* See comment at the top of this file */
1531 : 0 : smp_rmb();
1532 : 0 : return ctx->cached_cq_tail - READ_ONCE(rings->cq.head);
1533 : : }
1534 : :
1535 : 0 : static inline unsigned int io_sqring_entries(struct io_ring_ctx *ctx)
1536 : : {
1537 : 0 : struct io_rings *rings = ctx->rings;
1538 : :
1539 : : /* make sure SQ entry isn't read before tail */
1540 : 0 : return smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;
1541 : : }
1542 : :
1543 : 0 : static inline bool io_req_multi_free(struct req_batch *rb, struct io_kiocb *req)
1544 : : {
1545 [ # # # # ]: 0 : if ((req->flags & REQ_F_LINK) || io_is_fallback_req(req))
1546 : : return false;
1547 : :
1548 [ # # # # ]: 0 : if (!(req->flags & REQ_F_FIXED_FILE) || req->io)
1549 : 0 : rb->need_iter++;
1550 : :
1551 : 0 : rb->reqs[rb->to_free++] = req;
1552 [ # # ]: 0 : if (unlikely(rb->to_free == ARRAY_SIZE(rb->reqs)))
1553 : 0 : io_free_req_many(req->ctx, rb);
1554 : : return true;
1555 : : }
1556 : :
1557 : : /*
1558 : : * Find and free completed poll iocbs
1559 : : */
1560 : 0 : static void io_iopoll_complete(struct io_ring_ctx *ctx, unsigned int *nr_events,
1561 : : struct list_head *done)
1562 : : {
1563 : 0 : struct req_batch rb;
1564 : 0 : struct io_kiocb *req;
1565 : :
1566 : 0 : rb.to_free = rb.need_iter = 0;
1567 [ # # ]: 0 : while (!list_empty(done)) {
1568 : 0 : req = list_first_entry(done, struct io_kiocb, list);
1569 : 0 : list_del(&req->list);
1570 : :
1571 : 0 : io_cqring_fill_event(req, req->result);
1572 : 0 : (*nr_events)++;
1573 : :
1574 [ # # # # ]: 0 : if (refcount_dec_and_test(&req->refs) &&
1575 : 0 : !io_req_multi_free(&rb, req))
1576 : 0 : io_free_req(req);
1577 : : }
1578 : :
1579 : 0 : io_commit_cqring(ctx);
1580 : 0 : io_free_req_many(ctx, &rb);
1581 : 0 : }
1582 : :
1583 : 0 : static int io_do_iopoll(struct io_ring_ctx *ctx, unsigned int *nr_events,
1584 : : long min)
1585 : : {
1586 : 0 : struct io_kiocb *req, *tmp;
1587 : 0 : LIST_HEAD(done);
1588 : 0 : bool spin;
1589 : 0 : int ret;
1590 : :
1591 : : /*
1592 : : * Only spin for completions if we don't have multiple devices hanging
1593 : : * off our complete list, and we're under the requested amount.
1594 : : */
1595 [ # # # # ]: 0 : spin = !ctx->poll_multi_file && *nr_events < min;
1596 : :
1597 : 0 : ret = 0;
1598 [ # # ]: 0 : list_for_each_entry_safe(req, tmp, &ctx->poll_list, list) {
1599 : 0 : struct kiocb *kiocb = &req->rw.kiocb;
1600 : :
1601 : : /*
1602 : : * Move completed entries to our local list. If we find a
1603 : : * request that requires polling, break out and complete
1604 : : * the done list first, if we have entries there.
1605 : : */
1606 [ # # ]: 0 : if (req->flags & REQ_F_IOPOLL_COMPLETED) {
1607 : 0 : list_move_tail(&req->list, &done);
1608 : 0 : continue;
1609 : : }
1610 [ # # ]: 0 : if (!list_empty(&done))
1611 : : break;
1612 : :
1613 : 0 : ret = kiocb->ki_filp->f_op->iopoll(kiocb, spin);
1614 [ # # ]: 0 : if (ret < 0)
1615 : : break;
1616 : :
1617 [ # # ]: 0 : if (ret && spin)
1618 : 0 : spin = false;
1619 : : ret = 0;
1620 : : }
1621 : :
1622 [ # # ]: 0 : if (!list_empty(&done))
1623 : 0 : io_iopoll_complete(ctx, nr_events, &done);
1624 : :
1625 : 0 : return ret;
1626 : : }
1627 : :
1628 : : /*
1629 : : * Poll for a minimum of 'min' events. Note that if min == 0 we consider that a
1630 : : * non-spinning poll check - we'll still enter the driver poll loop, but only
1631 : : * as a non-spinning completion check.
1632 : : */
1633 : 0 : static int io_iopoll_getevents(struct io_ring_ctx *ctx, unsigned int *nr_events,
1634 : : long min)
1635 : : {
1636 [ # # # # ]: 0 : while (!list_empty(&ctx->poll_list) && !need_resched()) {
1637 : 0 : int ret;
1638 : :
1639 : 0 : ret = io_do_iopoll(ctx, nr_events, min);
1640 [ # # ]: 0 : if (ret < 0)
1641 : 0 : return ret;
1642 [ # # # # ]: 0 : if (!min || *nr_events >= min)
1643 : : return 0;
1644 : : }
1645 : :
1646 : : return 1;
1647 : : }
1648 : :
1649 : : /*
1650 : : * We can't just wait for polled events to come to us, we have to actively
1651 : : * find and complete them.
1652 : : */
1653 : 0 : static void io_iopoll_reap_events(struct io_ring_ctx *ctx)
1654 : : {
1655 [ # # ]: 0 : if (!(ctx->flags & IORING_SETUP_IOPOLL))
1656 : : return;
1657 : :
1658 : 0 : mutex_lock(&ctx->uring_lock);
1659 [ # # ]: 0 : while (!list_empty(&ctx->poll_list)) {
1660 : 0 : unsigned int nr_events = 0;
1661 : :
1662 : 0 : io_iopoll_getevents(ctx, &nr_events, 1);
1663 : :
1664 : : /*
1665 : : * Ensure we allow local-to-the-cpu processing to take place,
1666 : : * in this case we need to ensure that we reap all events.
1667 : : */
1668 : 0 : cond_resched();
1669 : : }
1670 : 0 : mutex_unlock(&ctx->uring_lock);
1671 : : }
1672 : :
1673 : 0 : static int io_iopoll_check(struct io_ring_ctx *ctx, unsigned *nr_events,
1674 : : long min)
1675 : : {
1676 : 0 : int iters = 0, ret = 0;
1677 : :
1678 : : /*
1679 : : * We disallow the app entering submit/complete with polling, but we
1680 : : * still need to lock the ring to prevent racing with polled issue
1681 : : * that got punted to a workqueue.
1682 : : */
1683 : 0 : mutex_lock(&ctx->uring_lock);
1684 : 0 : do {
1685 : 0 : int tmin = 0;
1686 : :
1687 : : /*
1688 : : * Don't enter poll loop if we already have events pending.
1689 : : * If we do, we can potentially be spinning for commands that
1690 : : * already triggered a CQE (eg in error).
1691 : : */
1692 [ # # ]: 0 : if (io_cqring_events(ctx, false))
1693 : : break;
1694 : :
1695 : : /*
1696 : : * If a submit got punted to a workqueue, we can have the
1697 : : * application entering polling for a command before it gets
1698 : : * issued. That app will hold the uring_lock for the duration
1699 : : * of the poll right here, so we need to take a breather every
1700 : : * now and then to ensure that the issue has a chance to add
1701 : : * the poll to the issued list. Otherwise we can spin here
1702 : : * forever, while the workqueue is stuck trying to acquire the
1703 : : * very same mutex.
1704 : : */
1705 [ # # ]: 0 : if (!(++iters & 7)) {
1706 : 0 : mutex_unlock(&ctx->uring_lock);
1707 : 0 : mutex_lock(&ctx->uring_lock);
1708 : : }
1709 : :
1710 [ # # ]: 0 : if (*nr_events < min)
1711 : 0 : tmin = min - *nr_events;
1712 : :
1713 : 0 : ret = io_iopoll_getevents(ctx, nr_events, tmin);
1714 [ # # ]: 0 : if (ret <= 0)
1715 : : break;
1716 : 0 : ret = 0;
1717 [ # # # # : 0 : } while (min && !*nr_events && !need_resched());
# # ]
1718 : :
1719 : 0 : mutex_unlock(&ctx->uring_lock);
1720 : 0 : return ret;
1721 : : }
1722 : :
1723 : 0 : static void kiocb_end_write(struct io_kiocb *req)
1724 : : {
1725 : : /*
1726 : : * Tell lockdep we inherited freeze protection from submission
1727 : : * thread.
1728 : : */
1729 : 0 : if (req->flags & REQ_F_ISREG) {
1730 : : struct inode *inode = file_inode(req->file);
1731 : :
1732 : 0 : __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
1733 : : }
1734 [ # # # # ]: 0 : file_end_write(req->file);
1735 : : }
1736 : :
1737 : 0 : static inline void req_set_fail_links(struct io_kiocb *req)
1738 : : {
1739 : 0 : if ((req->flags & (REQ_F_LINK | REQ_F_HARDLINK)) == REQ_F_LINK)
1740 : 0 : req->flags |= REQ_F_FAIL_LINK;
1741 : : }
1742 : :
1743 : 0 : static void io_complete_rw_common(struct kiocb *kiocb, long res)
1744 : : {
1745 : 0 : struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1746 : :
1747 [ # # ]: 0 : if (kiocb->ki_flags & IOCB_WRITE)
1748 : 0 : kiocb_end_write(req);
1749 : :
1750 [ # # ]: 0 : if (res != req->result)
1751 [ # # ]: 0 : req_set_fail_links(req);
1752 : 0 : io_cqring_add_event(req, res);
1753 : 0 : }
1754 : :
1755 : 0 : static void io_complete_rw(struct kiocb *kiocb, long res, long res2)
1756 : : {
1757 : 0 : struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1758 : :
1759 : 0 : io_complete_rw_common(kiocb, res);
1760 : 0 : io_put_req(req);
1761 : 0 : }
1762 : :
1763 : 0 : static struct io_kiocb *__io_complete_rw(struct kiocb *kiocb, long res)
1764 : : {
1765 : 0 : struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1766 : 0 : struct io_kiocb *nxt = NULL;
1767 : :
1768 : 0 : io_complete_rw_common(kiocb, res);
1769 : 0 : io_put_req_find_next(req, &nxt);
1770 : :
1771 : 0 : return nxt;
1772 : : }
1773 : :
1774 : 0 : static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2)
1775 : : {
1776 : 0 : struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1777 : :
1778 [ # # ]: 0 : if (kiocb->ki_flags & IOCB_WRITE)
1779 : 0 : kiocb_end_write(req);
1780 : :
1781 [ # # ]: 0 : if (res != req->result)
1782 [ # # ]: 0 : req_set_fail_links(req);
1783 : 0 : req->result = res;
1784 [ # # ]: 0 : if (res != -EAGAIN)
1785 : 0 : req->flags |= REQ_F_IOPOLL_COMPLETED;
1786 : 0 : }
1787 : :
1788 : : /*
1789 : : * After the iocb has been issued, it's safe to be found on the poll list.
1790 : : * Adding the kiocb to the list AFTER submission ensures that we don't
1791 : : * find it from a io_iopoll_getevents() thread before the issuer is done
1792 : : * accessing the kiocb cookie.
1793 : : */
1794 : 0 : static void io_iopoll_req_issued(struct io_kiocb *req)
1795 : : {
1796 : 0 : struct io_ring_ctx *ctx = req->ctx;
1797 : :
1798 : : /*
1799 : : * Track whether we have multiple files in our lists. This will impact
1800 : : * how we do polling eventually, not spinning if we're on potentially
1801 : : * different devices.
1802 : : */
1803 [ # # ]: 0 : if (list_empty(&ctx->poll_list)) {
1804 : 0 : ctx->poll_multi_file = false;
1805 [ # # ]: 0 : } else if (!ctx->poll_multi_file) {
1806 : 0 : struct io_kiocb *list_req;
1807 : :
1808 : 0 : list_req = list_first_entry(&ctx->poll_list, struct io_kiocb,
1809 : : list);
1810 [ # # ]: 0 : if (list_req->file != req->file)
1811 : 0 : ctx->poll_multi_file = true;
1812 : : }
1813 : :
1814 : : /*
1815 : : * For fast devices, IO may have already completed. If it has, add
1816 : : * it to the front so we find it first.
1817 : : */
1818 [ # # ]: 0 : if (req->flags & REQ_F_IOPOLL_COMPLETED)
1819 : 0 : list_add(&req->list, &ctx->poll_list);
1820 : : else
1821 : 0 : list_add_tail(&req->list, &ctx->poll_list);
1822 : :
1823 [ # # # # ]: 0 : if ((ctx->flags & IORING_SETUP_SQPOLL) &&
1824 : : wq_has_sleeper(&ctx->sqo_wait))
1825 : 0 : wake_up(&ctx->sqo_wait);
1826 : 0 : }
1827 : :
1828 : 0 : static void io_file_put(struct io_submit_state *state)
1829 : : {
1830 [ # # ]: 0 : if (state->file) {
1831 : 0 : int diff = state->has_refs - state->used_refs;
1832 : :
1833 [ # # ]: 0 : if (diff)
1834 : 0 : fput_many(state->file, diff);
1835 : 0 : state->file = NULL;
1836 : : }
1837 : 0 : }
1838 : :
1839 : : /*
1840 : : * Get as many references to a file as we have IOs left in this submission,
1841 : : * assuming most submissions are for one file, or at least that each file
1842 : : * has more than one submission.
1843 : : */
1844 : 0 : static struct file *io_file_get(struct io_submit_state *state, int fd)
1845 : : {
1846 [ # # ]: 0 : if (!state)
1847 : 0 : return fget(fd);
1848 : :
1849 [ # # ]: 0 : if (state->file) {
1850 [ # # ]: 0 : if (state->fd == fd) {
1851 : 0 : state->used_refs++;
1852 : 0 : state->ios_left--;
1853 : 0 : return state->file;
1854 : : }
1855 : 0 : io_file_put(state);
1856 : : }
1857 : 0 : state->file = fget_many(fd, state->ios_left);
1858 [ # # ]: 0 : if (!state->file)
1859 : : return NULL;
1860 : :
1861 : 0 : state->fd = fd;
1862 : 0 : state->has_refs = state->ios_left;
1863 : 0 : state->used_refs = 1;
1864 : 0 : state->ios_left--;
1865 : 0 : return state->file;
1866 : : }
1867 : :
1868 : : /*
1869 : : * If we tracked the file through the SCM inflight mechanism, we could support
1870 : : * any file. For now, just ensure that anything potentially problematic is done
1871 : : * inline.
1872 : : */
1873 : 0 : static bool io_file_supports_async(struct file *file)
1874 : : {
1875 : 0 : umode_t mode = file_inode(file)->i_mode;
1876 : :
1877 [ # # # # : 0 : if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISSOCK(mode))
# # # # ]
1878 : : return true;
1879 [ # # # # : 0 : if (S_ISREG(mode) && file->f_op != &io_uring_fops)
# # # # ]
1880 : : return true;
1881 : :
1882 : : return false;
1883 : : }
1884 : :
1885 : 0 : static int io_prep_rw(struct io_kiocb *req, const struct io_uring_sqe *sqe,
1886 : : bool force_nonblock)
1887 : : {
1888 : 0 : struct io_ring_ctx *ctx = req->ctx;
1889 : 0 : struct kiocb *kiocb = &req->rw.kiocb;
1890 : 0 : unsigned ioprio;
1891 : 0 : int ret;
1892 : :
1893 [ # # ]: 0 : if (S_ISREG(file_inode(req->file)->i_mode))
1894 : 0 : req->flags |= REQ_F_ISREG;
1895 : :
1896 [ # # ]: 0 : kiocb->ki_pos = READ_ONCE(sqe->off);
1897 [ # # # # ]: 0 : if (kiocb->ki_pos == -1 && !(req->file->f_mode & FMODE_STREAM)) {
1898 : 0 : req->flags |= REQ_F_CUR_POS;
1899 : 0 : kiocb->ki_pos = req->file->f_pos;
1900 : : }
1901 [ # # ]: 0 : kiocb->ki_hint = ki_hint_validate(file_write_hint(kiocb->ki_filp));
1902 : 0 : kiocb->ki_flags = iocb_flags(kiocb->ki_filp);
1903 : 0 : ret = kiocb_set_rw_flags(kiocb, READ_ONCE(sqe->rw_flags));
1904 [ # # ]: 0 : if (unlikely(ret))
1905 : : return ret;
1906 : :
1907 [ # # ]: 0 : ioprio = READ_ONCE(sqe->ioprio);
1908 [ # # ]: 0 : if (ioprio) {
1909 : 0 : ret = ioprio_check_cap(ioprio);
1910 [ # # ]: 0 : if (ret)
1911 : : return ret;
1912 : :
1913 : 0 : kiocb->ki_ioprio = ioprio;
1914 : : } else
1915 [ # # ]: 0 : kiocb->ki_ioprio = get_current_ioprio();
1916 : :
1917 : : /* don't allow async punt if RWF_NOWAIT was requested */
1918 [ # # ]: 0 : if ((kiocb->ki_flags & IOCB_NOWAIT) ||
1919 [ # # ]: 0 : (req->file->f_flags & O_NONBLOCK))
1920 : 0 : req->flags |= REQ_F_NOWAIT;
1921 : :
1922 [ # # ]: 0 : if (force_nonblock)
1923 : 0 : kiocb->ki_flags |= IOCB_NOWAIT;
1924 : :
1925 [ # # ]: 0 : if (ctx->flags & IORING_SETUP_IOPOLL) {
1926 [ # # ]: 0 : if (!(kiocb->ki_flags & IOCB_DIRECT) ||
1927 [ # # ]: 0 : !kiocb->ki_filp->f_op->iopoll)
1928 : : return -EOPNOTSUPP;
1929 : :
1930 : 0 : kiocb->ki_flags |= IOCB_HIPRI;
1931 : 0 : kiocb->ki_complete = io_complete_rw_iopoll;
1932 : 0 : req->result = 0;
1933 : : } else {
1934 [ # # ]: 0 : if (kiocb->ki_flags & IOCB_HIPRI)
1935 : : return -EINVAL;
1936 : 0 : kiocb->ki_complete = io_complete_rw;
1937 : : }
1938 : :
1939 : 0 : req->rw.addr = READ_ONCE(sqe->addr);
1940 : 0 : req->rw.len = READ_ONCE(sqe->len);
1941 : : /* we own ->private, reuse it for the buffer index */
1942 : 0 : req->rw.kiocb.private = (void *) (unsigned long)
1943 : 0 : READ_ONCE(sqe->buf_index);
1944 : 0 : return 0;
1945 : : }
1946 : :
1947 : 0 : static inline void io_rw_done(struct kiocb *kiocb, ssize_t ret)
1948 : : {
1949 : 0 : switch (ret) {
1950 : : case -EIOCBQUEUED:
1951 : : break;
1952 : 0 : case -ERESTARTSYS:
1953 : : case -ERESTARTNOINTR:
1954 : : case -ERESTARTNOHAND:
1955 : : case -ERESTART_RESTARTBLOCK:
1956 : : /*
1957 : : * We can't just restart the syscall, since previously
1958 : : * submitted sqes may already be in progress. Just fail this
1959 : : * IO with EINTR.
1960 : : */
1961 : 0 : ret = -EINTR;
1962 : : /* fall through */
1963 : 0 : default:
1964 : 0 : kiocb->ki_complete(kiocb, ret, 0);
1965 : : }
1966 : : }
1967 : :
1968 : 0 : static void kiocb_done(struct kiocb *kiocb, ssize_t ret, struct io_kiocb **nxt,
1969 : : bool in_async)
1970 : : {
1971 : 0 : struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw.kiocb);
1972 : :
1973 [ # # ]: 0 : if (req->flags & REQ_F_CUR_POS)
1974 : 0 : req->file->f_pos = kiocb->ki_pos;
1975 [ # # # # ]: 0 : if (in_async && ret >= 0 && kiocb->ki_complete == io_complete_rw)
1976 : 0 : *nxt = __io_complete_rw(kiocb, ret);
1977 : : else
1978 [ # # # ]: 0 : io_rw_done(kiocb, ret);
1979 : 0 : }
1980 : :
1981 : 0 : static ssize_t io_import_fixed(struct io_kiocb *req, int rw,
1982 : : struct iov_iter *iter)
1983 : : {
1984 : 0 : struct io_ring_ctx *ctx = req->ctx;
1985 : 0 : size_t len = req->rw.len;
1986 : 0 : struct io_mapped_ubuf *imu;
1987 : 0 : unsigned index, buf_index;
1988 : 0 : size_t offset;
1989 : 0 : u64 buf_addr;
1990 : :
1991 : : /* attempt to use fixed buffers without having provided iovecs */
1992 [ # # ]: 0 : if (unlikely(!ctx->user_bufs))
1993 : : return -EFAULT;
1994 : :
1995 : 0 : buf_index = (unsigned long) req->rw.kiocb.private;
1996 [ # # ]: 0 : if (unlikely(buf_index >= ctx->nr_user_bufs))
1997 : : return -EFAULT;
1998 : :
1999 : 0 : index = array_index_nospec(buf_index, ctx->nr_user_bufs);
2000 : 0 : imu = &ctx->user_bufs[index];
2001 : 0 : buf_addr = req->rw.addr;
2002 : :
2003 : : /* overflow */
2004 [ # # ]: 0 : if (buf_addr + len < buf_addr)
2005 : : return -EFAULT;
2006 : : /* not inside the mapped region */
2007 [ # # # # ]: 0 : if (buf_addr < imu->ubuf || buf_addr + len > imu->ubuf + imu->len)
2008 : : return -EFAULT;
2009 : :
2010 : : /*
2011 : : * May not be a start of buffer, set size appropriately
2012 : : * and advance us to the beginning.
2013 : : */
2014 : 0 : offset = buf_addr - imu->ubuf;
2015 : 0 : iov_iter_bvec(iter, rw, imu->bvec, imu->nr_bvecs, offset + len);
2016 : :
2017 [ # # ]: 0 : if (offset) {
2018 : : /*
2019 : : * Don't use iov_iter_advance() here, as it's really slow for
2020 : : * using the latter parts of a big fixed buffer - it iterates
2021 : : * over each segment manually. We can cheat a bit here, because
2022 : : * we know that:
2023 : : *
2024 : : * 1) it's a BVEC iter, we set it up
2025 : : * 2) all bvecs are PAGE_SIZE in size, except potentially the
2026 : : * first and last bvec
2027 : : *
2028 : : * So just find our index, and adjust the iterator afterwards.
2029 : : * If the offset is within the first bvec (or the whole first
2030 : : * bvec, just use iov_iter_advance(). This makes it easier
2031 : : * since we can just skip the first segment, which may not
2032 : : * be PAGE_SIZE aligned.
2033 : : */
2034 : 0 : const struct bio_vec *bvec = imu->bvec;
2035 : :
2036 [ # # ]: 0 : if (offset <= bvec->bv_len) {
2037 : 0 : iov_iter_advance(iter, offset);
2038 : : } else {
2039 : 0 : unsigned long seg_skip;
2040 : :
2041 : : /* skip first vec */
2042 : 0 : offset -= bvec->bv_len;
2043 : 0 : seg_skip = 1 + (offset >> PAGE_SHIFT);
2044 : :
2045 : 0 : iter->bvec = bvec + seg_skip;
2046 : 0 : iter->nr_segs -= seg_skip;
2047 : 0 : iter->count -= bvec->bv_len + offset;
2048 : 0 : iter->iov_offset = offset & ~PAGE_MASK;
2049 : : }
2050 : : }
2051 : :
2052 : 0 : return len;
2053 : : }
2054 : :
2055 : 0 : static ssize_t io_import_iovec(int rw, struct io_kiocb *req,
2056 : : struct iovec **iovec, struct iov_iter *iter)
2057 : : {
2058 : 0 : void __user *buf = u64_to_user_ptr(req->rw.addr);
2059 : 0 : size_t sqe_len = req->rw.len;
2060 : 0 : u8 opcode;
2061 : :
2062 : 0 : opcode = req->opcode;
2063 [ # # ]: 0 : if (opcode == IORING_OP_READ_FIXED || opcode == IORING_OP_WRITE_FIXED) {
2064 : 0 : *iovec = NULL;
2065 : 0 : return io_import_fixed(req, rw, iter);
2066 : : }
2067 : :
2068 : : /* buffer index only valid with fixed read/write */
2069 [ # # ]: 0 : if (req->rw.kiocb.private)
2070 : : return -EINVAL;
2071 : :
2072 [ # # ]: 0 : if (opcode == IORING_OP_READ || opcode == IORING_OP_WRITE) {
2073 : 0 : ssize_t ret;
2074 : 0 : ret = import_single_range(rw, buf, sqe_len, *iovec, iter);
2075 : 0 : *iovec = NULL;
2076 [ # # ]: 0 : return ret < 0 ? ret : sqe_len;
2077 : : }
2078 : :
2079 [ # # ]: 0 : if (req->io) {
2080 : 0 : struct io_async_rw *iorw = &req->io->rw;
2081 : :
2082 : 0 : *iovec = iorw->iov;
2083 : 0 : iov_iter_init(iter, rw, *iovec, iorw->nr_segs, iorw->size);
2084 [ # # ]: 0 : if (iorw->iov == iorw->fast_iov)
2085 : 0 : *iovec = NULL;
2086 : 0 : return iorw->size;
2087 : : }
2088 : :
2089 : : #ifdef CONFIG_COMPAT
2090 [ # # ]: 0 : if (req->ctx->compat)
2091 : 0 : return compat_import_iovec(rw, buf, sqe_len, UIO_FASTIOV,
2092 : : iovec, iter);
2093 : : #endif
2094 : :
2095 : 0 : return import_iovec(rw, buf, sqe_len, UIO_FASTIOV, iovec, iter);
2096 : : }
2097 : :
2098 : : /*
2099 : : * For files that don't have ->read_iter() and ->write_iter(), handle them
2100 : : * by looping over ->read() or ->write() manually.
2101 : : */
2102 : 0 : static ssize_t loop_rw_iter(int rw, struct file *file, struct kiocb *kiocb,
2103 : : struct iov_iter *iter)
2104 : : {
2105 : 0 : ssize_t ret = 0;
2106 : :
2107 : : /*
2108 : : * Don't support polled IO through this interface, and we can't
2109 : : * support non-blocking either. For the latter, this just causes
2110 : : * the kiocb to be handled from an async context.
2111 : : */
2112 [ # # ]: 0 : if (kiocb->ki_flags & IOCB_HIPRI)
2113 : : return -EOPNOTSUPP;
2114 [ # # ]: 0 : if (kiocb->ki_flags & IOCB_NOWAIT)
2115 : : return -EAGAIN;
2116 : :
2117 [ # # ]: 0 : while (iov_iter_count(iter)) {
2118 : 0 : struct iovec iovec;
2119 : 0 : ssize_t nr;
2120 : :
2121 [ # # ]: 0 : if (!iov_iter_is_bvec(iter)) {
2122 : 0 : iovec = iov_iter_iovec(iter);
2123 : : } else {
2124 : : /* fixed buffers import bvec */
2125 : 0 : iovec.iov_base = kmap(iter->bvec->bv_page)
2126 : 0 : + iter->iov_offset;
2127 : 0 : iovec.iov_len = min(iter->count,
2128 : : iter->bvec->bv_len - iter->iov_offset);
2129 : : }
2130 : :
2131 [ # # ]: 0 : if (rw == READ) {
2132 : 0 : nr = file->f_op->read(file, iovec.iov_base,
2133 : : iovec.iov_len, &kiocb->ki_pos);
2134 : : } else {
2135 : 0 : nr = file->f_op->write(file, iovec.iov_base,
2136 : : iovec.iov_len, &kiocb->ki_pos);
2137 : : }
2138 : :
2139 [ # # ]: 0 : if (iov_iter_is_bvec(iter))
2140 : : kunmap(iter->bvec->bv_page);
2141 : :
2142 [ # # ]: 0 : if (nr < 0) {
2143 [ # # ]: 0 : if (!ret)
2144 : 0 : ret = nr;
2145 : : break;
2146 : : }
2147 : 0 : ret += nr;
2148 [ # # ]: 0 : if (nr != iovec.iov_len)
2149 : : break;
2150 : 0 : iov_iter_advance(iter, nr);
2151 : : }
2152 : :
2153 : : return ret;
2154 : : }
2155 : :
2156 : : static void io_req_map_rw(struct io_kiocb *req, ssize_t io_size,
2157 : : struct iovec *iovec, struct iovec *fast_iov,
2158 : : struct iov_iter *iter)
2159 : : {
2160 : : req->io->rw.nr_segs = iter->nr_segs;
2161 : : req->io->rw.size = io_size;
2162 : : req->io->rw.iov = iovec;
2163 : : if (!req->io->rw.iov) {
2164 : : req->io->rw.iov = req->io->rw.fast_iov;
2165 : : memcpy(req->io->rw.iov, fast_iov,
2166 : : sizeof(struct iovec) * iter->nr_segs);
2167 : : } else {
2168 : : req->flags |= REQ_F_NEED_CLEANUP;
2169 : : }
2170 : : }
2171 : :
2172 : 0 : static int io_alloc_async_ctx(struct io_kiocb *req)
2173 : : {
2174 : 0 : if (!io_op_defs[req->opcode].async_ctx)
2175 : : return 0;
2176 : 0 : req->io = kmalloc(sizeof(*req->io), GFP_KERNEL);
2177 : 0 : return req->io == NULL;
2178 : : }
2179 : :
2180 : 0 : static int io_setup_async_rw(struct io_kiocb *req, ssize_t io_size,
2181 : : struct iovec *iovec, struct iovec *fast_iov,
2182 : : struct iov_iter *iter)
2183 : : {
2184 [ # # ]: 0 : if (!io_op_defs[req->opcode].async_ctx)
2185 : : return 0;
2186 [ # # ]: 0 : if (!req->io) {
2187 [ # # ]: 0 : if (io_alloc_async_ctx(req))
2188 : : return -ENOMEM;
2189 : :
2190 : 0 : io_req_map_rw(req, io_size, iovec, fast_iov, iter);
2191 : : }
2192 : : return 0;
2193 : : }
2194 : :
2195 : 0 : static int io_read_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
2196 : : bool force_nonblock)
2197 : : {
2198 : 0 : struct io_async_ctx *io;
2199 : 0 : struct iov_iter iter;
2200 : 0 : ssize_t ret;
2201 : :
2202 : 0 : ret = io_prep_rw(req, sqe, force_nonblock);
2203 [ # # ]: 0 : if (ret)
2204 : : return ret;
2205 : :
2206 [ # # ]: 0 : if (unlikely(!(req->file->f_mode & FMODE_READ)))
2207 : : return -EBADF;
2208 : :
2209 : : /* either don't need iovec imported or already have it */
2210 [ # # # # ]: 0 : if (!req->io || req->flags & REQ_F_NEED_CLEANUP)
2211 : : return 0;
2212 : :
2213 : 0 : io = req->io;
2214 : 0 : io->rw.iov = io->rw.fast_iov;
2215 : 0 : req->io = NULL;
2216 : 0 : ret = io_import_iovec(READ, req, &io->rw.iov, &iter);
2217 : 0 : req->io = io;
2218 [ # # ]: 0 : if (ret < 0)
2219 : 0 : return ret;
2220 : :
2221 : 0 : io_req_map_rw(req, ret, io->rw.iov, io->rw.fast_iov, &iter);
2222 : 0 : return 0;
2223 : : }
2224 : :
2225 : 0 : static int io_read(struct io_kiocb *req, struct io_kiocb **nxt,
2226 : : bool force_nonblock)
2227 : : {
2228 : 0 : struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
2229 : 0 : struct kiocb *kiocb = &req->rw.kiocb;
2230 : 0 : struct iov_iter iter;
2231 : 0 : size_t iov_count;
2232 : 0 : ssize_t io_size, ret;
2233 : :
2234 : 0 : ret = io_import_iovec(READ, req, &iovec, &iter);
2235 [ # # ]: 0 : if (ret < 0)
2236 : 0 : return ret;
2237 : :
2238 : : /* Ensure we clear previously set non-block flag */
2239 [ # # ]: 0 : if (!force_nonblock)
2240 : 0 : req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
2241 : :
2242 : 0 : req->result = 0;
2243 : 0 : io_size = ret;
2244 [ # # ]: 0 : if (req->flags & REQ_F_LINK)
2245 : 0 : req->result = io_size;
2246 : :
2247 : : /*
2248 : : * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
2249 : : * we know to async punt it even if it was opened O_NONBLOCK
2250 : : */
2251 [ # # # # ]: 0 : if (force_nonblock && !io_file_supports_async(req->file)) {
2252 : 0 : req->flags |= REQ_F_MUST_PUNT;
2253 : 0 : goto copy_iov;
2254 : : }
2255 : :
2256 : 0 : iov_count = iov_iter_count(&iter);
2257 : 0 : ret = rw_verify_area(READ, req->file, &kiocb->ki_pos, iov_count);
2258 [ # # ]: 0 : if (!ret) {
2259 : 0 : ssize_t ret2;
2260 : :
2261 [ # # ]: 0 : if (req->file->f_op->read_iter)
2262 : 0 : ret2 = call_read_iter(req->file, kiocb, &iter);
2263 : : else
2264 : 0 : ret2 = loop_rw_iter(READ, req->file, kiocb, &iter);
2265 : :
2266 : : /* Catch -EAGAIN return for forced non-blocking submission */
2267 [ # # ]: 0 : if (!force_nonblock || ret2 != -EAGAIN) {
2268 : 0 : kiocb_done(kiocb, ret2, nxt, req->in_async);
2269 : : } else {
2270 : 0 : copy_iov:
2271 : 0 : ret = io_setup_async_rw(req, io_size, iovec,
2272 : : inline_vecs, &iter);
2273 [ # # ]: 0 : if (ret)
2274 : 0 : goto out_free;
2275 : : return -EAGAIN;
2276 : : }
2277 : : }
2278 : 0 : out_free:
2279 : 0 : kfree(iovec);
2280 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
2281 : 0 : return ret;
2282 : : }
2283 : :
2284 : 0 : static int io_write_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
2285 : : bool force_nonblock)
2286 : : {
2287 : 0 : struct io_async_ctx *io;
2288 : 0 : struct iov_iter iter;
2289 : 0 : ssize_t ret;
2290 : :
2291 : 0 : ret = io_prep_rw(req, sqe, force_nonblock);
2292 [ # # ]: 0 : if (ret)
2293 : : return ret;
2294 : :
2295 [ # # ]: 0 : if (unlikely(!(req->file->f_mode & FMODE_WRITE)))
2296 : : return -EBADF;
2297 : :
2298 : : /* either don't need iovec imported or already have it */
2299 [ # # # # ]: 0 : if (!req->io || req->flags & REQ_F_NEED_CLEANUP)
2300 : : return 0;
2301 : :
2302 : 0 : io = req->io;
2303 : 0 : io->rw.iov = io->rw.fast_iov;
2304 : 0 : req->io = NULL;
2305 : 0 : ret = io_import_iovec(WRITE, req, &io->rw.iov, &iter);
2306 : 0 : req->io = io;
2307 [ # # ]: 0 : if (ret < 0)
2308 : 0 : return ret;
2309 : :
2310 : 0 : io_req_map_rw(req, ret, io->rw.iov, io->rw.fast_iov, &iter);
2311 : 0 : return 0;
2312 : : }
2313 : :
2314 : 0 : static int io_write(struct io_kiocb *req, struct io_kiocb **nxt,
2315 : : bool force_nonblock)
2316 : : {
2317 : 0 : struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
2318 : 0 : struct kiocb *kiocb = &req->rw.kiocb;
2319 : 0 : struct iov_iter iter;
2320 : 0 : size_t iov_count;
2321 : 0 : ssize_t ret, io_size;
2322 : :
2323 : 0 : ret = io_import_iovec(WRITE, req, &iovec, &iter);
2324 [ # # ]: 0 : if (ret < 0)
2325 : 0 : return ret;
2326 : :
2327 : : /* Ensure we clear previously set non-block flag */
2328 [ # # ]: 0 : if (!force_nonblock)
2329 : 0 : req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
2330 : :
2331 : 0 : req->result = 0;
2332 : 0 : io_size = ret;
2333 [ # # ]: 0 : if (req->flags & REQ_F_LINK)
2334 : 0 : req->result = io_size;
2335 : :
2336 : : /*
2337 : : * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
2338 : : * we know to async punt it even if it was opened O_NONBLOCK
2339 : : */
2340 [ # # # # ]: 0 : if (force_nonblock && !io_file_supports_async(req->file)) {
2341 : 0 : req->flags |= REQ_F_MUST_PUNT;
2342 : 0 : goto copy_iov;
2343 : : }
2344 : :
2345 : : /* file path doesn't support NOWAIT for non-direct_IO */
2346 [ # # # # ]: 0 : if (force_nonblock && !(kiocb->ki_flags & IOCB_DIRECT) &&
2347 [ # # ]: 0 : (req->flags & REQ_F_ISREG))
2348 : 0 : goto copy_iov;
2349 : :
2350 : 0 : iov_count = iov_iter_count(&iter);
2351 : 0 : ret = rw_verify_area(WRITE, req->file, &kiocb->ki_pos, iov_count);
2352 [ # # ]: 0 : if (!ret) {
2353 : 0 : ssize_t ret2;
2354 : :
2355 : : /*
2356 : : * Open-code file_start_write here to grab freeze protection,
2357 : : * which will be released by another thread in
2358 : : * io_complete_rw(). Fool lockdep by telling it the lock got
2359 : : * released so that it doesn't complain about the held lock when
2360 : : * we return to userspace.
2361 : : */
2362 [ # # ]: 0 : if (req->flags & REQ_F_ISREG) {
2363 : 0 : __sb_start_write(file_inode(req->file)->i_sb,
2364 : : SB_FREEZE_WRITE, true);
2365 : 0 : __sb_writers_release(file_inode(req->file)->i_sb,
2366 : : SB_FREEZE_WRITE);
2367 : : }
2368 : 0 : kiocb->ki_flags |= IOCB_WRITE;
2369 : :
2370 [ # # ]: 0 : if (req->file->f_op->write_iter)
2371 : 0 : ret2 = call_write_iter(req->file, kiocb, &iter);
2372 : : else
2373 : 0 : ret2 = loop_rw_iter(WRITE, req->file, kiocb, &iter);
2374 : : /*
2375 : : * Raw bdev writes will -EOPNOTSUPP for IOCB_NOWAIT. Just
2376 : : * retry them without IOCB_NOWAIT.
2377 : : */
2378 [ # # # # ]: 0 : if (ret2 == -EOPNOTSUPP && (kiocb->ki_flags & IOCB_NOWAIT))
2379 : 0 : ret2 = -EAGAIN;
2380 [ # # ]: 0 : if (!force_nonblock || ret2 != -EAGAIN) {
2381 : 0 : kiocb_done(kiocb, ret2, nxt, req->in_async);
2382 : : } else {
2383 : 0 : copy_iov:
2384 : 0 : ret = io_setup_async_rw(req, io_size, iovec,
2385 : : inline_vecs, &iter);
2386 [ # # ]: 0 : if (ret)
2387 : 0 : goto out_free;
2388 : : return -EAGAIN;
2389 : : }
2390 : : }
2391 : 0 : out_free:
2392 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
2393 : 0 : kfree(iovec);
2394 : 0 : return ret;
2395 : : }
2396 : :
2397 : : /*
2398 : : * IORING_OP_NOP just posts a completion event, nothing else.
2399 : : */
2400 : 0 : static int io_nop(struct io_kiocb *req)
2401 : : {
2402 : 0 : struct io_ring_ctx *ctx = req->ctx;
2403 : :
2404 [ # # ]: 0 : if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
2405 : : return -EINVAL;
2406 : :
2407 : 0 : io_cqring_add_event(req, 0);
2408 : 0 : io_put_req(req);
2409 : 0 : return 0;
2410 : : }
2411 : :
2412 : 0 : static int io_prep_fsync(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2413 : : {
2414 : 0 : struct io_ring_ctx *ctx = req->ctx;
2415 : :
2416 [ # # ]: 0 : if (!req->file)
2417 : : return -EBADF;
2418 : :
2419 [ # # ]: 0 : if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
2420 : : return -EINVAL;
2421 [ # # # # : 0 : if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
# # ]
2422 : : return -EINVAL;
2423 : :
2424 [ # # ]: 0 : req->sync.flags = READ_ONCE(sqe->fsync_flags);
2425 [ # # ]: 0 : if (unlikely(req->sync.flags & ~IORING_FSYNC_DATASYNC))
2426 : : return -EINVAL;
2427 : :
2428 : 0 : req->sync.off = READ_ONCE(sqe->off);
2429 : 0 : req->sync.len = READ_ONCE(sqe->len);
2430 : 0 : return 0;
2431 : : }
2432 : :
2433 : 0 : static bool io_req_cancelled(struct io_kiocb *req)
2434 : : {
2435 [ # # ]: 0 : if (req->work.flags & IO_WQ_WORK_CANCEL) {
2436 [ # # ]: 0 : req_set_fail_links(req);
2437 : 0 : io_cqring_add_event(req, -ECANCELED);
2438 : 0 : io_put_req(req);
2439 : 0 : return true;
2440 : : }
2441 : :
2442 : : return false;
2443 : : }
2444 : :
2445 : 0 : static void io_link_work_cb(struct io_wq_work **workptr)
2446 : : {
2447 : 0 : struct io_wq_work *work = *workptr;
2448 : 0 : struct io_kiocb *link = work->data;
2449 : :
2450 : 0 : io_queue_linked_timeout(link);
2451 : 0 : work->func = io_wq_submit_work;
2452 : 0 : }
2453 : :
2454 : 0 : static void io_wq_assign_next(struct io_wq_work **workptr, struct io_kiocb *nxt)
2455 : : {
2456 : 0 : struct io_kiocb *link;
2457 : :
2458 : 0 : io_prep_async_work(nxt, &link);
2459 : 0 : *workptr = &nxt->work;
2460 [ # # # # : 0 : if (link) {
# # # # #
# # # #
# ]
2461 : 0 : nxt->work.flags |= IO_WQ_WORK_CB;
2462 : 0 : nxt->work.func = io_link_work_cb;
2463 : 0 : nxt->work.data = link;
2464 : : }
2465 : 0 : }
2466 : :
2467 : 0 : static void io_fsync_finish(struct io_wq_work **workptr)
2468 : : {
2469 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
2470 : 0 : loff_t end = req->sync.off + req->sync.len;
2471 : 0 : struct io_kiocb *nxt = NULL;
2472 : 0 : int ret;
2473 : :
2474 [ # # ]: 0 : if (io_req_cancelled(req))
2475 : 0 : return;
2476 : :
2477 : 0 : ret = vfs_fsync_range(req->file, req->sync.off,
2478 : : end > 0 ? end : LLONG_MAX,
2479 [ # # ]: 0 : req->sync.flags & IORING_FSYNC_DATASYNC);
2480 [ # # ]: 0 : if (ret < 0)
2481 [ # # ]: 0 : req_set_fail_links(req);
2482 : 0 : io_cqring_add_event(req, ret);
2483 : 0 : io_put_req_find_next(req, &nxt);
2484 [ # # ]: 0 : if (nxt)
2485 : 0 : io_wq_assign_next(workptr, nxt);
2486 : : }
2487 : :
2488 : 0 : static int io_fsync(struct io_kiocb *req, struct io_kiocb **nxt,
2489 : : bool force_nonblock)
2490 : : {
2491 : 0 : struct io_wq_work *work, *old_work;
2492 : :
2493 : : /* fsync always requires a blocking context */
2494 [ # # ]: 0 : if (force_nonblock) {
2495 : 0 : io_put_req(req);
2496 : 0 : req->work.func = io_fsync_finish;
2497 : 0 : return -EAGAIN;
2498 : : }
2499 : :
2500 : 0 : work = old_work = &req->work;
2501 : 0 : io_fsync_finish(&work);
2502 [ # # # # ]: 0 : if (work && work != old_work)
2503 : 0 : *nxt = container_of(work, struct io_kiocb, work);
2504 : : return 0;
2505 : : }
2506 : :
2507 : 0 : static void io_fallocate_finish(struct io_wq_work **workptr)
2508 : : {
2509 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
2510 : 0 : struct io_kiocb *nxt = NULL;
2511 : 0 : int ret;
2512 : :
2513 [ # # ]: 0 : if (io_req_cancelled(req))
2514 : 0 : return;
2515 : :
2516 : 0 : ret = vfs_fallocate(req->file, req->sync.mode, req->sync.off,
2517 : : req->sync.len);
2518 [ # # ]: 0 : if (ret < 0)
2519 [ # # ]: 0 : req_set_fail_links(req);
2520 : 0 : io_cqring_add_event(req, ret);
2521 : 0 : io_put_req_find_next(req, &nxt);
2522 [ # # ]: 0 : if (nxt)
2523 : 0 : io_wq_assign_next(workptr, nxt);
2524 : : }
2525 : :
2526 : 0 : static int io_fallocate_prep(struct io_kiocb *req,
2527 : : const struct io_uring_sqe *sqe)
2528 : : {
2529 [ # # # # : 0 : if (sqe->ioprio || sqe->buf_index || sqe->rw_flags)
# # # # ]
2530 : : return -EINVAL;
2531 : :
2532 : 0 : req->sync.off = READ_ONCE(sqe->off);
2533 : 0 : req->sync.len = READ_ONCE(sqe->addr);
2534 : 0 : req->sync.mode = READ_ONCE(sqe->len);
2535 : 0 : return 0;
2536 : : }
2537 : :
2538 : 0 : static int io_fallocate(struct io_kiocb *req, struct io_kiocb **nxt,
2539 : : bool force_nonblock)
2540 : : {
2541 : 0 : struct io_wq_work *work, *old_work;
2542 : :
2543 : : /* fallocate always requiring blocking context */
2544 [ # # ]: 0 : if (force_nonblock) {
2545 : 0 : io_put_req(req);
2546 : 0 : req->work.func = io_fallocate_finish;
2547 : 0 : return -EAGAIN;
2548 : : }
2549 : :
2550 : 0 : work = old_work = &req->work;
2551 : 0 : io_fallocate_finish(&work);
2552 [ # # # # ]: 0 : if (work && work != old_work)
2553 : 0 : *nxt = container_of(work, struct io_kiocb, work);
2554 : :
2555 : : return 0;
2556 : : }
2557 : :
2558 : 0 : static int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2559 : : {
2560 : 0 : const char __user *fname;
2561 : 0 : int ret;
2562 : :
2563 [ # # # # ]: 0 : if (sqe->ioprio || sqe->buf_index)
2564 : : return -EINVAL;
2565 [ # # ]: 0 : if (sqe->flags & IOSQE_FIXED_FILE)
2566 : : return -EBADF;
2567 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
2568 : : return 0;
2569 : :
2570 : 0 : req->open.dfd = READ_ONCE(sqe->fd);
2571 : 0 : req->open.how.mode = READ_ONCE(sqe->len);
2572 : 0 : fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
2573 : 0 : req->open.how.flags = READ_ONCE(sqe->open_flags);
2574 : :
2575 : 0 : req->open.filename = getname(fname);
2576 [ # # ]: 0 : if (IS_ERR(req->open.filename)) {
2577 : 0 : ret = PTR_ERR(req->open.filename);
2578 : 0 : req->open.filename = NULL;
2579 : 0 : return ret;
2580 : : }
2581 : :
2582 : 0 : req->open.nofile = rlimit(RLIMIT_NOFILE);
2583 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
2584 : 0 : return 0;
2585 : : }
2586 : :
2587 : 0 : static int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2588 : : {
2589 : 0 : struct open_how __user *how;
2590 : 0 : const char __user *fname;
2591 : 0 : size_t len;
2592 : 0 : int ret;
2593 : :
2594 [ # # # # ]: 0 : if (sqe->ioprio || sqe->buf_index)
2595 : : return -EINVAL;
2596 [ # # ]: 0 : if (sqe->flags & IOSQE_FIXED_FILE)
2597 : : return -EBADF;
2598 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
2599 : : return 0;
2600 : :
2601 [ # # ]: 0 : req->open.dfd = READ_ONCE(sqe->fd);
2602 : 0 : fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
2603 : 0 : how = u64_to_user_ptr(READ_ONCE(sqe->addr2));
2604 : 0 : len = READ_ONCE(sqe->len);
2605 : :
2606 [ # # ]: 0 : if (len < OPEN_HOW_SIZE_VER0)
2607 : : return -EINVAL;
2608 : :
2609 [ # # ]: 0 : ret = copy_struct_from_user(&req->open.how, sizeof(req->open.how), how,
2610 : : len);
2611 : 0 : if (ret)
2612 : 0 : return ret;
2613 : :
2614 [ # # ]: 0 : if (!(req->open.how.flags & O_PATH) && force_o_largefile())
2615 : 0 : req->open.how.flags |= O_LARGEFILE;
2616 : :
2617 : 0 : req->open.filename = getname(fname);
2618 [ # # ]: 0 : if (IS_ERR(req->open.filename)) {
2619 : 0 : ret = PTR_ERR(req->open.filename);
2620 : 0 : req->open.filename = NULL;
2621 : 0 : return ret;
2622 : : }
2623 : :
2624 : 0 : req->open.nofile = rlimit(RLIMIT_NOFILE);
2625 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
2626 : 0 : return 0;
2627 : : }
2628 : :
2629 : 0 : static int io_openat2(struct io_kiocb *req, struct io_kiocb **nxt,
2630 : : bool force_nonblock)
2631 : : {
2632 : 0 : struct open_flags op;
2633 : 0 : struct file *file;
2634 : 0 : int ret;
2635 : :
2636 [ # # ]: 0 : if (force_nonblock)
2637 : : return -EAGAIN;
2638 : :
2639 : 0 : ret = build_open_flags(&req->open.how, &op);
2640 [ # # ]: 0 : if (ret)
2641 : 0 : goto err;
2642 : :
2643 : 0 : ret = __get_unused_fd_flags(req->open.how.flags, req->open.nofile);
2644 [ # # ]: 0 : if (ret < 0)
2645 : 0 : goto err;
2646 : :
2647 : 0 : file = do_filp_open(req->open.dfd, req->open.filename, &op);
2648 [ # # ]: 0 : if (IS_ERR(file)) {
2649 : 0 : put_unused_fd(ret);
2650 : 0 : ret = PTR_ERR(file);
2651 : : } else {
2652 : 0 : fsnotify_open(file);
2653 : 0 : fd_install(ret, file);
2654 : : }
2655 : 0 : err:
2656 : 0 : putname(req->open.filename);
2657 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
2658 [ # # ]: 0 : if (ret < 0)
2659 [ # # ]: 0 : req_set_fail_links(req);
2660 : 0 : io_cqring_add_event(req, ret);
2661 : 0 : io_put_req_find_next(req, nxt);
2662 : 0 : return 0;
2663 : : }
2664 : :
2665 : 0 : static int io_openat(struct io_kiocb *req, struct io_kiocb **nxt,
2666 : : bool force_nonblock)
2667 : : {
2668 : 0 : req->open.how = build_open_how(req->open.how.flags, req->open.how.mode);
2669 : 0 : return io_openat2(req, nxt, force_nonblock);
2670 : : }
2671 : :
2672 : 0 : static int io_epoll_ctl_prep(struct io_kiocb *req,
2673 : : const struct io_uring_sqe *sqe)
2674 : : {
2675 : : #if defined(CONFIG_EPOLL)
2676 [ # # # # ]: 0 : if (sqe->ioprio || sqe->buf_index)
2677 : : return -EINVAL;
2678 : :
2679 [ # # ]: 0 : req->epoll.epfd = READ_ONCE(sqe->fd);
2680 : 0 : req->epoll.op = READ_ONCE(sqe->len);
2681 : 0 : req->epoll.fd = READ_ONCE(sqe->off);
2682 : :
2683 [ # # ]: 0 : if (ep_op_has_event(req->epoll.op)) {
2684 : 0 : struct epoll_event __user *ev;
2685 : :
2686 [ # # ]: 0 : ev = u64_to_user_ptr(READ_ONCE(sqe->addr));
2687 [ # # # # ]: 0 : if (copy_from_user(&req->epoll.event, ev, sizeof(*ev)))
2688 : 0 : return -EFAULT;
2689 : : }
2690 : :
2691 : : return 0;
2692 : : #else
2693 : : return -EOPNOTSUPP;
2694 : : #endif
2695 : : }
2696 : :
2697 : 0 : static int io_epoll_ctl(struct io_kiocb *req, struct io_kiocb **nxt,
2698 : : bool force_nonblock)
2699 : : {
2700 : : #if defined(CONFIG_EPOLL)
2701 : 0 : struct io_epoll *ie = &req->epoll;
2702 : 0 : int ret;
2703 : :
2704 : 0 : ret = do_epoll_ctl(ie->epfd, ie->op, ie->fd, &ie->event, force_nonblock);
2705 [ # # ]: 0 : if (force_nonblock && ret == -EAGAIN)
2706 : : return -EAGAIN;
2707 : :
2708 [ # # ]: 0 : if (ret < 0)
2709 [ # # ]: 0 : req_set_fail_links(req);
2710 : 0 : io_cqring_add_event(req, ret);
2711 : 0 : io_put_req_find_next(req, nxt);
2712 : 0 : return 0;
2713 : : #else
2714 : : return -EOPNOTSUPP;
2715 : : #endif
2716 : : }
2717 : :
2718 : 0 : static int io_madvise_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2719 : : {
2720 : : #if defined(CONFIG_ADVISE_SYSCALLS) && defined(CONFIG_MMU)
2721 [ # # # # : 0 : if (sqe->ioprio || sqe->buf_index || sqe->off)
# # # # ]
2722 : : return -EINVAL;
2723 : :
2724 : 0 : req->madvise.addr = READ_ONCE(sqe->addr);
2725 : 0 : req->madvise.len = READ_ONCE(sqe->len);
2726 : 0 : req->madvise.advice = READ_ONCE(sqe->fadvise_advice);
2727 : 0 : return 0;
2728 : : #else
2729 : : return -EOPNOTSUPP;
2730 : : #endif
2731 : : }
2732 : :
2733 : 0 : static int io_madvise(struct io_kiocb *req, struct io_kiocb **nxt,
2734 : : bool force_nonblock)
2735 : : {
2736 : : #if defined(CONFIG_ADVISE_SYSCALLS) && defined(CONFIG_MMU)
2737 : 0 : struct io_madvise *ma = &req->madvise;
2738 : 0 : int ret;
2739 : :
2740 [ # # ]: 0 : if (force_nonblock)
2741 : : return -EAGAIN;
2742 : :
2743 : 0 : ret = do_madvise(ma->addr, ma->len, ma->advice);
2744 [ # # ]: 0 : if (ret < 0)
2745 [ # # ]: 0 : req_set_fail_links(req);
2746 : 0 : io_cqring_add_event(req, ret);
2747 : 0 : io_put_req_find_next(req, nxt);
2748 : 0 : return 0;
2749 : : #else
2750 : : return -EOPNOTSUPP;
2751 : : #endif
2752 : : }
2753 : :
2754 : 0 : static int io_fadvise_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2755 : : {
2756 [ # # # # : 0 : if (sqe->ioprio || sqe->buf_index || sqe->addr)
# # # # ]
2757 : : return -EINVAL;
2758 : :
2759 : 0 : req->fadvise.offset = READ_ONCE(sqe->off);
2760 : 0 : req->fadvise.len = READ_ONCE(sqe->len);
2761 : 0 : req->fadvise.advice = READ_ONCE(sqe->fadvise_advice);
2762 : 0 : return 0;
2763 : : }
2764 : :
2765 : 0 : static int io_fadvise(struct io_kiocb *req, struct io_kiocb **nxt,
2766 : : bool force_nonblock)
2767 : : {
2768 : 0 : struct io_fadvise *fa = &req->fadvise;
2769 : 0 : int ret;
2770 : :
2771 [ # # ]: 0 : if (force_nonblock) {
2772 [ # # ]: 0 : switch (fa->advice) {
2773 : : case POSIX_FADV_NORMAL:
2774 : : case POSIX_FADV_RANDOM:
2775 : : case POSIX_FADV_SEQUENTIAL:
2776 : : break;
2777 : : default:
2778 : : return -EAGAIN;
2779 : : }
2780 : 0 : }
2781 : :
2782 : 0 : ret = vfs_fadvise(req->file, fa->offset, fa->len, fa->advice);
2783 [ # # ]: 0 : if (ret < 0)
2784 [ # # ]: 0 : req_set_fail_links(req);
2785 : 0 : io_cqring_add_event(req, ret);
2786 : 0 : io_put_req_find_next(req, nxt);
2787 : 0 : return 0;
2788 : : }
2789 : :
2790 : 0 : static int io_statx_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2791 : : {
2792 : 0 : const char __user *fname;
2793 : 0 : unsigned lookup_flags;
2794 : 0 : int ret;
2795 : :
2796 [ # # # # ]: 0 : if (sqe->ioprio || sqe->buf_index)
2797 : : return -EINVAL;
2798 [ # # ]: 0 : if (sqe->flags & IOSQE_FIXED_FILE)
2799 : : return -EBADF;
2800 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
2801 : : return 0;
2802 : :
2803 : 0 : req->open.dfd = READ_ONCE(sqe->fd);
2804 : 0 : req->open.mask = READ_ONCE(sqe->len);
2805 : 0 : fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
2806 : 0 : req->open.buffer = u64_to_user_ptr(READ_ONCE(sqe->addr2));
2807 : 0 : req->open.how.flags = READ_ONCE(sqe->statx_flags);
2808 : :
2809 [ # # ]: 0 : if (vfs_stat_set_lookup_flags(&lookup_flags, req->open.how.flags))
2810 : : return -EINVAL;
2811 : :
2812 : 0 : req->open.filename = getname_flags(fname, lookup_flags, NULL);
2813 [ # # ]: 0 : if (IS_ERR(req->open.filename)) {
2814 : 0 : ret = PTR_ERR(req->open.filename);
2815 : 0 : req->open.filename = NULL;
2816 : 0 : return ret;
2817 : : }
2818 : :
2819 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
2820 : 0 : return 0;
2821 : : }
2822 : :
2823 : 0 : static int io_statx(struct io_kiocb *req, struct io_kiocb **nxt,
2824 : : bool force_nonblock)
2825 : : {
2826 : 0 : struct io_open *ctx = &req->open;
2827 : 0 : unsigned lookup_flags;
2828 : 0 : struct path path;
2829 : 0 : struct kstat stat;
2830 : 0 : int ret;
2831 : :
2832 [ # # ]: 0 : if (force_nonblock)
2833 : : return -EAGAIN;
2834 : :
2835 [ # # ]: 0 : if (vfs_stat_set_lookup_flags(&lookup_flags, ctx->how.flags))
2836 : : return -EINVAL;
2837 : :
2838 : 0 : retry:
2839 : : /* filename_lookup() drops it, keep a reference */
2840 : 0 : ctx->filename->refcnt++;
2841 : :
2842 : 0 : ret = filename_lookup(ctx->dfd, ctx->filename, lookup_flags, &path,
2843 : : NULL);
2844 [ # # ]: 0 : if (ret)
2845 : 0 : goto err;
2846 : :
2847 : 0 : ret = vfs_getattr(&path, &stat, ctx->mask, ctx->how.flags);
2848 : 0 : path_put(&path);
2849 [ # # # # ]: 0 : if (retry_estale(ret, lookup_flags)) {
2850 : 0 : lookup_flags |= LOOKUP_REVAL;
2851 : 0 : goto retry;
2852 : : }
2853 [ # # ]: 0 : if (!ret)
2854 : 0 : ret = cp_statx(&stat, ctx->buffer);
2855 : 0 : err:
2856 : 0 : putname(ctx->filename);
2857 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
2858 [ # # ]: 0 : if (ret < 0)
2859 [ # # ]: 0 : req_set_fail_links(req);
2860 : 0 : io_cqring_add_event(req, ret);
2861 : 0 : io_put_req_find_next(req, nxt);
2862 : 0 : return 0;
2863 : : }
2864 : :
2865 : 0 : static int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2866 : : {
2867 : : /*
2868 : : * If we queue this for async, it must not be cancellable. That would
2869 : : * leave the 'file' in an undeterminate state.
2870 : : */
2871 : 0 : req->work.flags |= IO_WQ_WORK_NO_CANCEL;
2872 : :
2873 [ # # # # : 0 : if (sqe->ioprio || sqe->off || sqe->addr || sqe->len ||
# # # # ]
2874 [ # # ]: 0 : sqe->rw_flags || sqe->buf_index)
2875 : : return -EINVAL;
2876 [ # # ]: 0 : if (sqe->flags & IOSQE_FIXED_FILE)
2877 : : return -EBADF;
2878 : :
2879 [ # # ]: 0 : req->close.fd = READ_ONCE(sqe->fd);
2880 [ # # ]: 0 : if (req->file->f_op == &io_uring_fops ||
2881 [ # # ]: 0 : req->close.fd == req->ctx->ring_fd)
2882 : 0 : return -EBADF;
2883 : :
2884 : : return 0;
2885 : : }
2886 : :
2887 : : /* only called when __close_fd_get_file() is done */
2888 : 0 : static void __io_close_finish(struct io_kiocb *req, struct io_kiocb **nxt)
2889 : : {
2890 : 0 : int ret;
2891 : :
2892 : 0 : ret = filp_close(req->close.put_file, req->work.files);
2893 [ # # ]: 0 : if (ret < 0)
2894 [ # # ]: 0 : req_set_fail_links(req);
2895 : 0 : io_cqring_add_event(req, ret);
2896 : 0 : fput(req->close.put_file);
2897 : 0 : io_put_req_find_next(req, nxt);
2898 : 0 : }
2899 : :
2900 : 0 : static void io_close_finish(struct io_wq_work **workptr)
2901 : : {
2902 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
2903 : 0 : struct io_kiocb *nxt = NULL;
2904 : :
2905 : : /* not cancellable, don't do io_req_cancelled() */
2906 : 0 : __io_close_finish(req, &nxt);
2907 [ # # ]: 0 : if (nxt)
2908 : 0 : io_wq_assign_next(workptr, nxt);
2909 : 0 : }
2910 : :
2911 : 0 : static int io_close(struct io_kiocb *req, struct io_kiocb **nxt,
2912 : : bool force_nonblock)
2913 : : {
2914 : 0 : int ret;
2915 : :
2916 : 0 : req->close.put_file = NULL;
2917 : 0 : ret = __close_fd_get_file(req->close.fd, &req->close.put_file);
2918 [ # # ]: 0 : if (ret < 0)
2919 : : return ret;
2920 : :
2921 : : /* if the file has a flush method, be safe and punt to async */
2922 [ # # # # ]: 0 : if (req->close.put_file->f_op->flush && !io_wq_current_is_worker())
2923 : 0 : goto eagain;
2924 : :
2925 : : /*
2926 : : * No ->flush(), safely close from here and just punt the
2927 : : * fput() to async context.
2928 : : */
2929 : 0 : __io_close_finish(req, nxt);
2930 : 0 : return 0;
2931 : : eagain:
2932 : 0 : req->work.func = io_close_finish;
2933 : : /*
2934 : : * Do manual async queue here to avoid grabbing files - we don't
2935 : : * need the files, and it'll cause io_close_finish() to close
2936 : : * the file again and cause a double CQE entry for this request
2937 : : */
2938 : 0 : io_queue_async_work(req);
2939 : 0 : return 0;
2940 : : }
2941 : :
2942 : 0 : static int io_prep_sfr(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2943 : : {
2944 : 0 : struct io_ring_ctx *ctx = req->ctx;
2945 : :
2946 : 0 : if (!req->file)
2947 : : return -EBADF;
2948 : :
2949 [ # # # # ]: 0 : if (unlikely(ctx->flags & IORING_SETUP_IOPOLL))
2950 : : return -EINVAL;
2951 [ # # # # : 0 : if (unlikely(sqe->addr || sqe->ioprio || sqe->buf_index))
# # # # #
# # # ]
2952 : : return -EINVAL;
2953 : :
2954 : 0 : req->sync.off = READ_ONCE(sqe->off);
2955 : 0 : req->sync.len = READ_ONCE(sqe->len);
2956 : 0 : req->sync.flags = READ_ONCE(sqe->sync_range_flags);
2957 : 0 : return 0;
2958 : : }
2959 : :
2960 : 0 : static void io_sync_file_range_finish(struct io_wq_work **workptr)
2961 : : {
2962 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
2963 : 0 : struct io_kiocb *nxt = NULL;
2964 : 0 : int ret;
2965 : :
2966 [ # # ]: 0 : if (io_req_cancelled(req))
2967 : 0 : return;
2968 : :
2969 : 0 : ret = sync_file_range(req->file, req->sync.off, req->sync.len,
2970 : 0 : req->sync.flags);
2971 [ # # ]: 0 : if (ret < 0)
2972 [ # # ]: 0 : req_set_fail_links(req);
2973 : 0 : io_cqring_add_event(req, ret);
2974 : 0 : io_put_req_find_next(req, &nxt);
2975 [ # # ]: 0 : if (nxt)
2976 : 0 : io_wq_assign_next(workptr, nxt);
2977 : : }
2978 : :
2979 : 0 : static int io_sync_file_range(struct io_kiocb *req, struct io_kiocb **nxt,
2980 : : bool force_nonblock)
2981 : : {
2982 : 0 : struct io_wq_work *work, *old_work;
2983 : :
2984 : : /* sync_file_range always requires a blocking context */
2985 [ # # ]: 0 : if (force_nonblock) {
2986 : 0 : io_put_req(req);
2987 : 0 : req->work.func = io_sync_file_range_finish;
2988 : 0 : return -EAGAIN;
2989 : : }
2990 : :
2991 : 0 : work = old_work = &req->work;
2992 : 0 : io_sync_file_range_finish(&work);
2993 [ # # # # ]: 0 : if (work && work != old_work)
2994 : 0 : *nxt = container_of(work, struct io_kiocb, work);
2995 : : return 0;
2996 : : }
2997 : :
2998 : 0 : static int io_sendmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
2999 : : {
3000 : : #if defined(CONFIG_NET)
3001 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3002 : 0 : struct io_async_ctx *io = req->io;
3003 : 0 : int ret;
3004 : :
3005 [ # # ]: 0 : sr->msg_flags = READ_ONCE(sqe->msg_flags);
3006 : 0 : sr->msg = u64_to_user_ptr(READ_ONCE(sqe->addr));
3007 : 0 : sr->len = READ_ONCE(sqe->len);
3008 : :
3009 : : #ifdef CONFIG_COMPAT
3010 [ # # ]: 0 : if (req->ctx->compat)
3011 : 0 : sr->msg_flags |= MSG_CMSG_COMPAT;
3012 : : #endif
3013 : :
3014 [ # # # # ]: 0 : if (!io || req->opcode == IORING_OP_SEND)
3015 : : return 0;
3016 : : /* iovec is already imported */
3017 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
3018 : : return 0;
3019 : :
3020 : 0 : io->msg.iov = io->msg.fast_iov;
3021 : 0 : ret = sendmsg_copy_msghdr(&io->msg.msg, sr->msg, sr->msg_flags,
3022 : : &io->msg.iov);
3023 [ # # ]: 0 : if (!ret)
3024 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
3025 : : return ret;
3026 : : #else
3027 : : return -EOPNOTSUPP;
3028 : : #endif
3029 : : }
3030 : :
3031 : 0 : static int io_sendmsg(struct io_kiocb *req, struct io_kiocb **nxt,
3032 : : bool force_nonblock)
3033 : : {
3034 : : #if defined(CONFIG_NET)
3035 : 0 : struct io_async_msghdr *kmsg = NULL;
3036 : 0 : struct socket *sock;
3037 : 0 : int ret;
3038 : :
3039 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3040 : : return -EINVAL;
3041 : :
3042 : 0 : sock = sock_from_file(req->file, &ret);
3043 [ # # ]: 0 : if (sock) {
3044 : 0 : struct io_async_ctx io;
3045 : 0 : unsigned flags;
3046 : :
3047 [ # # ]: 0 : if (req->io) {
3048 : 0 : kmsg = &req->io->msg;
3049 : 0 : kmsg->msg.msg_name = &req->io->msg.addr;
3050 : : /* if iov is set, it's allocated already */
3051 [ # # ]: 0 : if (!kmsg->iov)
3052 : 0 : kmsg->iov = kmsg->fast_iov;
3053 : 0 : kmsg->msg.msg_iter.iov = kmsg->iov;
3054 : : } else {
3055 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3056 : :
3057 : 0 : kmsg = &io.msg;
3058 : 0 : kmsg->msg.msg_name = &io.msg.addr;
3059 : :
3060 : 0 : io.msg.iov = io.msg.fast_iov;
3061 : 0 : ret = sendmsg_copy_msghdr(&io.msg.msg, sr->msg,
3062 : 0 : sr->msg_flags, &io.msg.iov);
3063 [ # # ]: 0 : if (ret)
3064 : 0 : return ret;
3065 : : }
3066 : :
3067 : 0 : flags = req->sr_msg.msg_flags;
3068 [ # # ]: 0 : if (flags & MSG_DONTWAIT)
3069 : 0 : req->flags |= REQ_F_NOWAIT;
3070 [ # # ]: 0 : else if (force_nonblock)
3071 : 0 : flags |= MSG_DONTWAIT;
3072 : :
3073 : 0 : ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
3074 [ # # # # ]: 0 : if (force_nonblock && ret == -EAGAIN) {
3075 [ # # ]: 0 : if (req->io)
3076 : : return -EAGAIN;
3077 [ # # # # ]: 0 : if (io_alloc_async_ctx(req)) {
3078 [ # # ]: 0 : if (kmsg->iov != kmsg->fast_iov)
3079 : 0 : kfree(kmsg->iov);
3080 : 0 : return -ENOMEM;
3081 : : }
3082 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
3083 : 0 : memcpy(&req->io->msg, &io.msg, sizeof(io.msg));
3084 : 0 : return -EAGAIN;
3085 : : }
3086 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3087 : 0 : ret = -EINTR;
3088 : : }
3089 : :
3090 [ # # ]: 0 : if (kmsg && kmsg->iov != kmsg->fast_iov)
3091 : 0 : kfree(kmsg->iov);
3092 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
3093 : 0 : io_cqring_add_event(req, ret);
3094 [ # # ]: 0 : if (ret < 0)
3095 [ # # ]: 0 : req_set_fail_links(req);
3096 : 0 : io_put_req_find_next(req, nxt);
3097 : 0 : return 0;
3098 : : #else
3099 : : return -EOPNOTSUPP;
3100 : : #endif
3101 : : }
3102 : :
3103 : 0 : static int io_send(struct io_kiocb *req, struct io_kiocb **nxt,
3104 : : bool force_nonblock)
3105 : : {
3106 : : #if defined(CONFIG_NET)
3107 : 0 : struct socket *sock;
3108 : 0 : int ret;
3109 : :
3110 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3111 : : return -EINVAL;
3112 : :
3113 : 0 : sock = sock_from_file(req->file, &ret);
3114 [ # # ]: 0 : if (sock) {
3115 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3116 : 0 : struct msghdr msg;
3117 : 0 : struct iovec iov;
3118 : 0 : unsigned flags;
3119 : :
3120 : 0 : ret = import_single_range(WRITE, sr->buf, sr->len, &iov,
3121 : : &msg.msg_iter);
3122 [ # # ]: 0 : if (ret)
3123 : 0 : return ret;
3124 : :
3125 : 0 : msg.msg_name = NULL;
3126 : 0 : msg.msg_control = NULL;
3127 : 0 : msg.msg_controllen = 0;
3128 : 0 : msg.msg_namelen = 0;
3129 : :
3130 : 0 : flags = req->sr_msg.msg_flags;
3131 [ # # ]: 0 : if (flags & MSG_DONTWAIT)
3132 : 0 : req->flags |= REQ_F_NOWAIT;
3133 [ # # ]: 0 : else if (force_nonblock)
3134 : 0 : flags |= MSG_DONTWAIT;
3135 : :
3136 : 0 : msg.msg_flags = flags;
3137 : 0 : ret = sock_sendmsg(sock, &msg);
3138 [ # # # # ]: 0 : if (force_nonblock && ret == -EAGAIN)
3139 : : return -EAGAIN;
3140 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3141 : 0 : ret = -EINTR;
3142 : : }
3143 : :
3144 : 0 : io_cqring_add_event(req, ret);
3145 [ # # ]: 0 : if (ret < 0)
3146 [ # # ]: 0 : req_set_fail_links(req);
3147 : 0 : io_put_req_find_next(req, nxt);
3148 : 0 : return 0;
3149 : : #else
3150 : : return -EOPNOTSUPP;
3151 : : #endif
3152 : : }
3153 : :
3154 : 0 : static int io_recvmsg_prep(struct io_kiocb *req,
3155 : : const struct io_uring_sqe *sqe)
3156 : : {
3157 : : #if defined(CONFIG_NET)
3158 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3159 : 0 : struct io_async_ctx *io = req->io;
3160 : 0 : int ret;
3161 : :
3162 [ # # ]: 0 : sr->msg_flags = READ_ONCE(sqe->msg_flags);
3163 : 0 : sr->msg = u64_to_user_ptr(READ_ONCE(sqe->addr));
3164 : 0 : sr->len = READ_ONCE(sqe->len);
3165 : :
3166 : : #ifdef CONFIG_COMPAT
3167 [ # # ]: 0 : if (req->ctx->compat)
3168 : 0 : sr->msg_flags |= MSG_CMSG_COMPAT;
3169 : : #endif
3170 : :
3171 [ # # # # ]: 0 : if (!io || req->opcode == IORING_OP_RECV)
3172 : : return 0;
3173 : : /* iovec is already imported */
3174 [ # # ]: 0 : if (req->flags & REQ_F_NEED_CLEANUP)
3175 : : return 0;
3176 : :
3177 : 0 : io->msg.iov = io->msg.fast_iov;
3178 : 0 : ret = recvmsg_copy_msghdr(&io->msg.msg, sr->msg, sr->msg_flags,
3179 : : &io->msg.uaddr, &io->msg.iov);
3180 [ # # ]: 0 : if (!ret)
3181 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
3182 : : return ret;
3183 : : #else
3184 : : return -EOPNOTSUPP;
3185 : : #endif
3186 : : }
3187 : :
3188 : 0 : static int io_recvmsg(struct io_kiocb *req, struct io_kiocb **nxt,
3189 : : bool force_nonblock)
3190 : : {
3191 : : #if defined(CONFIG_NET)
3192 : 0 : struct io_async_msghdr *kmsg = NULL;
3193 : 0 : struct socket *sock;
3194 : 0 : int ret;
3195 : :
3196 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3197 : : return -EINVAL;
3198 : :
3199 : 0 : sock = sock_from_file(req->file, &ret);
3200 [ # # ]: 0 : if (sock) {
3201 : 0 : struct io_async_ctx io;
3202 : 0 : unsigned flags;
3203 : :
3204 [ # # ]: 0 : if (req->io) {
3205 : 0 : kmsg = &req->io->msg;
3206 : 0 : kmsg->msg.msg_name = &req->io->msg.addr;
3207 : : /* if iov is set, it's allocated already */
3208 [ # # ]: 0 : if (!kmsg->iov)
3209 : 0 : kmsg->iov = kmsg->fast_iov;
3210 : 0 : kmsg->msg.msg_iter.iov = kmsg->iov;
3211 : : } else {
3212 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3213 : :
3214 : 0 : kmsg = &io.msg;
3215 : 0 : kmsg->msg.msg_name = &io.msg.addr;
3216 : :
3217 : 0 : io.msg.iov = io.msg.fast_iov;
3218 : 0 : ret = recvmsg_copy_msghdr(&io.msg.msg, sr->msg,
3219 : 0 : sr->msg_flags, &io.msg.uaddr,
3220 : : &io.msg.iov);
3221 [ # # ]: 0 : if (ret)
3222 : 0 : return ret;
3223 : : }
3224 : :
3225 : 0 : flags = req->sr_msg.msg_flags;
3226 [ # # ]: 0 : if (flags & MSG_DONTWAIT)
3227 : 0 : req->flags |= REQ_F_NOWAIT;
3228 [ # # ]: 0 : else if (force_nonblock)
3229 : 0 : flags |= MSG_DONTWAIT;
3230 : :
3231 : 0 : ret = __sys_recvmsg_sock(sock, &kmsg->msg, req->sr_msg.msg,
3232 : : kmsg->uaddr, flags);
3233 [ # # # # ]: 0 : if (force_nonblock && ret == -EAGAIN) {
3234 [ # # ]: 0 : if (req->io)
3235 : : return -EAGAIN;
3236 [ # # # # ]: 0 : if (io_alloc_async_ctx(req)) {
3237 [ # # ]: 0 : if (kmsg->iov != kmsg->fast_iov)
3238 : 0 : kfree(kmsg->iov);
3239 : 0 : return -ENOMEM;
3240 : : }
3241 : 0 : memcpy(&req->io->msg, &io.msg, sizeof(io.msg));
3242 : 0 : req->flags |= REQ_F_NEED_CLEANUP;
3243 : 0 : return -EAGAIN;
3244 : : }
3245 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3246 : 0 : ret = -EINTR;
3247 : : }
3248 : :
3249 [ # # ]: 0 : if (kmsg && kmsg->iov != kmsg->fast_iov)
3250 : 0 : kfree(kmsg->iov);
3251 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
3252 : 0 : io_cqring_add_event(req, ret);
3253 [ # # ]: 0 : if (ret < 0)
3254 [ # # ]: 0 : req_set_fail_links(req);
3255 : 0 : io_put_req_find_next(req, nxt);
3256 : 0 : return 0;
3257 : : #else
3258 : : return -EOPNOTSUPP;
3259 : : #endif
3260 : : }
3261 : :
3262 : 0 : static int io_recv(struct io_kiocb *req, struct io_kiocb **nxt,
3263 : : bool force_nonblock)
3264 : : {
3265 : : #if defined(CONFIG_NET)
3266 : 0 : struct socket *sock;
3267 : 0 : int ret;
3268 : :
3269 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3270 : : return -EINVAL;
3271 : :
3272 : 0 : sock = sock_from_file(req->file, &ret);
3273 [ # # ]: 0 : if (sock) {
3274 : 0 : struct io_sr_msg *sr = &req->sr_msg;
3275 : 0 : struct msghdr msg;
3276 : 0 : struct iovec iov;
3277 : 0 : unsigned flags;
3278 : :
3279 : 0 : ret = import_single_range(READ, sr->buf, sr->len, &iov,
3280 : : &msg.msg_iter);
3281 [ # # ]: 0 : if (ret)
3282 : 0 : return ret;
3283 : :
3284 : 0 : msg.msg_name = NULL;
3285 : 0 : msg.msg_control = NULL;
3286 : 0 : msg.msg_controllen = 0;
3287 : 0 : msg.msg_namelen = 0;
3288 : 0 : msg.msg_iocb = NULL;
3289 : 0 : msg.msg_flags = 0;
3290 : :
3291 : 0 : flags = req->sr_msg.msg_flags;
3292 [ # # ]: 0 : if (flags & MSG_DONTWAIT)
3293 : 0 : req->flags |= REQ_F_NOWAIT;
3294 [ # # ]: 0 : else if (force_nonblock)
3295 : 0 : flags |= MSG_DONTWAIT;
3296 : :
3297 : 0 : ret = sock_recvmsg(sock, &msg, flags);
3298 [ # # # # ]: 0 : if (force_nonblock && ret == -EAGAIN)
3299 : : return -EAGAIN;
3300 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3301 : 0 : ret = -EINTR;
3302 : : }
3303 : :
3304 : 0 : io_cqring_add_event(req, ret);
3305 [ # # ]: 0 : if (ret < 0)
3306 [ # # ]: 0 : req_set_fail_links(req);
3307 : 0 : io_put_req_find_next(req, nxt);
3308 : 0 : return 0;
3309 : : #else
3310 : : return -EOPNOTSUPP;
3311 : : #endif
3312 : : }
3313 : :
3314 : :
3315 : 0 : static int io_accept_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3316 : : {
3317 : : #if defined(CONFIG_NET)
3318 : 0 : struct io_accept *accept = &req->accept;
3319 : :
3320 [ # # ]: 0 : if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
3321 : : return -EINVAL;
3322 [ # # # # : 0 : if (sqe->ioprio || sqe->len || sqe->buf_index)
# # ]
3323 : : return -EINVAL;
3324 : :
3325 : 0 : accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
3326 : 0 : accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
3327 : 0 : accept->flags = READ_ONCE(sqe->accept_flags);
3328 : 0 : accept->nofile = rlimit(RLIMIT_NOFILE);
3329 : 0 : return 0;
3330 : : #else
3331 : : return -EOPNOTSUPP;
3332 : : #endif
3333 : : }
3334 : :
3335 : : #if defined(CONFIG_NET)
3336 : 0 : static int __io_accept(struct io_kiocb *req, struct io_kiocb **nxt,
3337 : : bool force_nonblock)
3338 : : {
3339 : 0 : struct io_accept *accept = &req->accept;
3340 : 0 : unsigned file_flags;
3341 : 0 : int ret;
3342 : :
3343 [ # # ]: 0 : file_flags = force_nonblock ? O_NONBLOCK : 0;
3344 : 0 : ret = __sys_accept4_file(req->file, file_flags, accept->addr,
3345 : : accept->addr_len, accept->flags,
3346 : : accept->nofile);
3347 [ # # ]: 0 : if (ret == -EAGAIN && force_nonblock)
3348 : : return -EAGAIN;
3349 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3350 : : ret = -EINTR;
3351 [ # # ]: 0 : if (ret < 0)
3352 [ # # ]: 0 : req_set_fail_links(req);
3353 : 0 : io_cqring_add_event(req, ret);
3354 : 0 : io_put_req_find_next(req, nxt);
3355 : 0 : return 0;
3356 : : }
3357 : :
3358 : 0 : static void io_accept_finish(struct io_wq_work **workptr)
3359 : : {
3360 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
3361 : 0 : struct io_kiocb *nxt = NULL;
3362 : :
3363 [ # # ]: 0 : if (io_req_cancelled(req))
3364 : 0 : return;
3365 : 0 : __io_accept(req, &nxt, false);
3366 [ # # ]: 0 : if (nxt)
3367 : 0 : io_wq_assign_next(workptr, nxt);
3368 : : }
3369 : : #endif
3370 : :
3371 : 0 : static int io_accept(struct io_kiocb *req, struct io_kiocb **nxt,
3372 : : bool force_nonblock)
3373 : : {
3374 : : #if defined(CONFIG_NET)
3375 : 0 : int ret;
3376 : :
3377 : 0 : ret = __io_accept(req, nxt, force_nonblock);
3378 [ # # ]: 0 : if (ret == -EAGAIN && force_nonblock) {
3379 : 0 : req->work.func = io_accept_finish;
3380 : 0 : io_put_req(req);
3381 : 0 : return -EAGAIN;
3382 : : }
3383 : : return 0;
3384 : : #else
3385 : : return -EOPNOTSUPP;
3386 : : #endif
3387 : : }
3388 : :
3389 : 0 : static int io_connect_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3390 : : {
3391 : : #if defined(CONFIG_NET)
3392 : 0 : struct io_connect *conn = &req->connect;
3393 : 0 : struct io_async_ctx *io = req->io;
3394 : :
3395 [ # # ]: 0 : if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)))
3396 : : return -EINVAL;
3397 [ # # # # : 0 : if (sqe->ioprio || sqe->len || sqe->buf_index || sqe->rw_flags)
# # # # ]
3398 : : return -EINVAL;
3399 : :
3400 [ # # ]: 0 : conn->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
3401 : 0 : conn->addr_len = READ_ONCE(sqe->addr2);
3402 : :
3403 [ # # ]: 0 : if (!io)
3404 : : return 0;
3405 : :
3406 : 0 : return move_addr_to_kernel(conn->addr, conn->addr_len,
3407 : : &io->connect.address);
3408 : : #else
3409 : : return -EOPNOTSUPP;
3410 : : #endif
3411 : : }
3412 : :
3413 : 0 : static int io_connect(struct io_kiocb *req, struct io_kiocb **nxt,
3414 : : bool force_nonblock)
3415 : : {
3416 : : #if defined(CONFIG_NET)
3417 : 0 : struct io_async_ctx __io, *io;
3418 : 0 : unsigned file_flags;
3419 : 0 : int ret;
3420 : :
3421 [ # # ]: 0 : if (req->io) {
3422 : : io = req->io;
3423 : : } else {
3424 : 0 : ret = move_addr_to_kernel(req->connect.addr,
3425 : : req->connect.addr_len,
3426 : : &__io.connect.address);
3427 [ # # ]: 0 : if (ret)
3428 : 0 : goto out;
3429 : : io = &__io;
3430 : : }
3431 : :
3432 [ # # ]: 0 : file_flags = force_nonblock ? O_NONBLOCK : 0;
3433 : :
3434 : 0 : ret = __sys_connect_file(req->file, &io->connect.address,
3435 : : req->connect.addr_len, file_flags);
3436 [ # # # # ]: 0 : if ((ret == -EAGAIN || ret == -EINPROGRESS) && force_nonblock) {
3437 [ # # ]: 0 : if (req->io)
3438 : : return -EAGAIN;
3439 [ # # # # ]: 0 : if (io_alloc_async_ctx(req)) {
3440 : 0 : ret = -ENOMEM;
3441 : 0 : goto out;
3442 : : }
3443 : 0 : memcpy(&req->io->connect, &__io.connect, sizeof(__io.connect));
3444 : 0 : return -EAGAIN;
3445 : : }
3446 [ # # ]: 0 : if (ret == -ERESTARTSYS)
3447 : : ret = -EINTR;
3448 : 0 : out:
3449 [ # # ]: 0 : if (ret < 0)
3450 [ # # ]: 0 : req_set_fail_links(req);
3451 : 0 : io_cqring_add_event(req, ret);
3452 : 0 : io_put_req_find_next(req, nxt);
3453 : 0 : return 0;
3454 : : #else
3455 : : return -EOPNOTSUPP;
3456 : : #endif
3457 : : }
3458 : :
3459 : 0 : static void io_poll_remove_one(struct io_kiocb *req)
3460 : : {
3461 : 0 : struct io_poll_iocb *poll = &req->poll;
3462 : :
3463 : 0 : spin_lock(&poll->head->lock);
3464 [ # # ]: 0 : WRITE_ONCE(poll->canceled, true);
3465 [ # # ]: 0 : if (!list_empty(&poll->wait.entry)) {
3466 : 0 : list_del_init(&poll->wait.entry);
3467 : 0 : io_queue_async_work(req);
3468 : : }
3469 : 0 : spin_unlock(&poll->head->lock);
3470 [ # # ]: 0 : hash_del(&req->hash_node);
3471 : 0 : }
3472 : :
3473 : 0 : static void io_poll_remove_all(struct io_ring_ctx *ctx)
3474 : : {
3475 : 0 : struct hlist_node *tmp;
3476 : 0 : struct io_kiocb *req;
3477 : 0 : int i;
3478 : :
3479 : 0 : spin_lock_irq(&ctx->completion_lock);
3480 [ # # ]: 0 : for (i = 0; i < (1U << ctx->cancel_hash_bits); i++) {
3481 : 0 : struct hlist_head *list;
3482 : :
3483 : 0 : list = &ctx->cancel_hash[i];
3484 [ # # # # : 0 : hlist_for_each_entry_safe(req, tmp, list, hash_node)
# # ]
3485 : 0 : io_poll_remove_one(req);
3486 : : }
3487 : 0 : spin_unlock_irq(&ctx->completion_lock);
3488 : 0 : }
3489 : :
3490 : : static int io_poll_cancel(struct io_ring_ctx *ctx, __u64 sqe_addr)
3491 : : {
3492 : : struct hlist_head *list;
3493 : : struct io_kiocb *req;
3494 : :
3495 : : list = &ctx->cancel_hash[hash_long(sqe_addr, ctx->cancel_hash_bits)];
3496 : : hlist_for_each_entry(req, list, hash_node) {
3497 : : if (sqe_addr == req->user_data) {
3498 : : io_poll_remove_one(req);
3499 : : return 0;
3500 : : }
3501 : : }
3502 : :
3503 : : return -ENOENT;
3504 : : }
3505 : :
3506 : 0 : static int io_poll_remove_prep(struct io_kiocb *req,
3507 : : const struct io_uring_sqe *sqe)
3508 : : {
3509 : 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3510 : : return -EINVAL;
3511 [ # # # # : 0 : if (sqe->ioprio || sqe->off || sqe->len || sqe->buf_index ||
# # # # #
# # # # #
# # ]
3512 [ # # # # ]: 0 : sqe->poll_events)
3513 : : return -EINVAL;
3514 : :
3515 : 0 : req->poll.addr = READ_ONCE(sqe->addr);
3516 : 0 : return 0;
3517 : : }
3518 : :
3519 : : /*
3520 : : * Find a running poll command that matches one specified in sqe->addr,
3521 : : * and remove it if found.
3522 : : */
3523 : 0 : static int io_poll_remove(struct io_kiocb *req)
3524 : : {
3525 : 0 : struct io_ring_ctx *ctx = req->ctx;
3526 : 0 : u64 addr;
3527 : 0 : int ret;
3528 : :
3529 : 0 : addr = req->poll.addr;
3530 : 0 : spin_lock_irq(&ctx->completion_lock);
3531 : 0 : ret = io_poll_cancel(ctx, addr);
3532 : 0 : spin_unlock_irq(&ctx->completion_lock);
3533 : :
3534 : 0 : io_cqring_add_event(req, ret);
3535 [ # # ]: 0 : if (ret < 0)
3536 [ # # ]: 0 : req_set_fail_links(req);
3537 : 0 : io_put_req(req);
3538 : 0 : return 0;
3539 : : }
3540 : :
3541 : 0 : static void io_poll_complete(struct io_kiocb *req, __poll_t mask, int error)
3542 : : {
3543 : 0 : struct io_ring_ctx *ctx = req->ctx;
3544 : :
3545 : 0 : req->poll.done = true;
3546 [ # # ]: 0 : if (error)
3547 : 0 : io_cqring_fill_event(req, error);
3548 : : else
3549 : 0 : io_cqring_fill_event(req, mangle_poll(mask));
3550 : 0 : io_commit_cqring(ctx);
3551 : 0 : }
3552 : :
3553 : 0 : static void io_poll_complete_work(struct io_wq_work **workptr)
3554 : : {
3555 : 0 : struct io_wq_work *work = *workptr;
3556 : 0 : struct io_kiocb *req = container_of(work, struct io_kiocb, work);
3557 : 0 : struct io_poll_iocb *poll = &req->poll;
3558 : 0 : struct poll_table_struct pt = { ._key = poll->events };
3559 : 0 : struct io_ring_ctx *ctx = req->ctx;
3560 : 0 : struct io_kiocb *nxt = NULL;
3561 : 0 : __poll_t mask = 0;
3562 : 0 : int ret = 0;
3563 : :
3564 [ # # ]: 0 : if (work->flags & IO_WQ_WORK_CANCEL) {
3565 : 0 : WRITE_ONCE(poll->canceled, true);
3566 : 0 : ret = -ECANCELED;
3567 [ # # ]: 0 : } else if (READ_ONCE(poll->canceled)) {
3568 : : ret = -ECANCELED;
3569 : : }
3570 : :
3571 : 0 : if (ret != -ECANCELED)
3572 [ # # ]: 0 : mask = vfs_poll(poll->file, &pt) & poll->events;
3573 : :
3574 : : /*
3575 : : * Note that ->ki_cancel callers also delete iocb from active_reqs after
3576 : : * calling ->ki_cancel. We need the ctx_lock roundtrip here to
3577 : : * synchronize with them. In the cancellation case the list_del_init
3578 : : * itself is not actually needed, but harmless so we keep it in to
3579 : : * avoid further branches in the fast path.
3580 : : */
3581 : 0 : spin_lock_irq(&ctx->completion_lock);
3582 [ # # ]: 0 : if (!mask && ret != -ECANCELED) {
3583 : 0 : add_wait_queue(poll->head, &poll->wait);
3584 : 0 : spin_unlock_irq(&ctx->completion_lock);
3585 : 0 : return;
3586 : : }
3587 [ # # ]: 0 : hash_del(&req->hash_node);
3588 : 0 : io_poll_complete(req, mask, ret);
3589 : 0 : spin_unlock_irq(&ctx->completion_lock);
3590 : :
3591 : 0 : io_cqring_ev_posted(ctx);
3592 : :
3593 [ # # ]: 0 : if (ret < 0)
3594 [ # # ]: 0 : req_set_fail_links(req);
3595 : 0 : io_put_req_find_next(req, &nxt);
3596 [ # # ]: 0 : if (nxt)
3597 : 0 : io_wq_assign_next(workptr, nxt);
3598 : : }
3599 : :
3600 : 0 : static void __io_poll_flush(struct io_ring_ctx *ctx, struct llist_node *nodes)
3601 : : {
3602 : 0 : struct io_kiocb *req, *tmp;
3603 : 0 : struct req_batch rb;
3604 : :
3605 : 0 : rb.to_free = rb.need_iter = 0;
3606 : 0 : spin_lock_irq(&ctx->completion_lock);
3607 [ # # ]: 0 : llist_for_each_entry_safe(req, tmp, nodes, llist_node) {
3608 [ # # ]: 0 : hash_del(&req->hash_node);
3609 : 0 : io_poll_complete(req, req->result, 0);
3610 : :
3611 [ # # # # ]: 0 : if (refcount_dec_and_test(&req->refs) &&
3612 : 0 : !io_req_multi_free(&rb, req)) {
3613 : 0 : req->flags |= REQ_F_COMP_LOCKED;
3614 : 0 : io_free_req(req);
3615 : : }
3616 : : }
3617 : 0 : spin_unlock_irq(&ctx->completion_lock);
3618 : :
3619 : 0 : io_cqring_ev_posted(ctx);
3620 : 0 : io_free_req_many(ctx, &rb);
3621 : 0 : }
3622 : :
3623 : 0 : static void io_poll_flush(struct io_wq_work **workptr)
3624 : : {
3625 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
3626 : 0 : struct llist_node *nodes;
3627 : :
3628 : 0 : nodes = llist_del_all(&req->ctx->poll_llist);
3629 [ # # ]: 0 : if (nodes)
3630 : 0 : __io_poll_flush(req->ctx, nodes);
3631 : 0 : }
3632 : :
3633 : 0 : static void io_poll_trigger_evfd(struct io_wq_work **workptr)
3634 : : {
3635 : 0 : struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
3636 : :
3637 : 0 : eventfd_signal(req->ctx->cq_ev_fd, 1);
3638 : 0 : io_put_req(req);
3639 : 0 : }
3640 : :
3641 : 0 : static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
3642 : : void *key)
3643 : : {
3644 : 0 : struct io_poll_iocb *poll = wait->private;
3645 : 0 : struct io_kiocb *req = container_of(poll, struct io_kiocb, poll);
3646 : 0 : struct io_ring_ctx *ctx = req->ctx;
3647 : 0 : __poll_t mask = key_to_poll(key);
3648 : :
3649 : : /* for instances that support it check for an event match first: */
3650 [ # # # # ]: 0 : if (mask && !(mask & poll->events))
3651 : : return 0;
3652 : :
3653 [ # # ]: 0 : list_del_init(&poll->wait.entry);
3654 : :
3655 : : /*
3656 : : * Run completion inline if we can. We're using trylock here because
3657 : : * we are violating the completion_lock -> poll wq lock ordering.
3658 : : * If we have a link timeout we're going to need the completion_lock
3659 : : * for finalizing the request, mark us as having grabbed that already.
3660 : : */
3661 [ # # ]: 0 : if (mask) {
3662 : 0 : unsigned long flags;
3663 : :
3664 [ # # ]: 0 : if (llist_empty(&ctx->poll_llist) &&
3665 [ # # ]: 0 : spin_trylock_irqsave(&ctx->completion_lock, flags)) {
3666 : 0 : bool trigger_ev;
3667 : :
3668 [ # # ]: 0 : hash_del(&req->hash_node);
3669 : 0 : io_poll_complete(req, mask, 0);
3670 : :
3671 : 0 : trigger_ev = io_should_trigger_evfd(ctx);
3672 [ # # # # ]: 0 : if (trigger_ev && eventfd_signal_count()) {
3673 : 0 : trigger_ev = false;
3674 : 0 : req->work.func = io_poll_trigger_evfd;
3675 : : } else {
3676 : 0 : req->flags |= REQ_F_COMP_LOCKED;
3677 : 0 : io_put_req(req);
3678 : 0 : req = NULL;
3679 : : }
3680 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
3681 : 0 : __io_cqring_ev_posted(ctx, trigger_ev);
3682 : : } else {
3683 : 0 : req->result = mask;
3684 : 0 : req->llist_node.next = NULL;
3685 : : /* if the list wasn't empty, we're done */
3686 [ # # ]: 0 : if (!llist_add(&req->llist_node, &ctx->poll_llist))
3687 : : req = NULL;
3688 : : else
3689 : 0 : req->work.func = io_poll_flush;
3690 : : }
3691 : : }
3692 [ # # ]: 0 : if (req)
3693 : 0 : io_queue_async_work(req);
3694 : :
3695 : : return 1;
3696 : : }
3697 : :
3698 : : struct io_poll_table {
3699 : : struct poll_table_struct pt;
3700 : : struct io_kiocb *req;
3701 : : int error;
3702 : : };
3703 : :
3704 : 0 : static void io_poll_queue_proc(struct file *file, struct wait_queue_head *head,
3705 : : struct poll_table_struct *p)
3706 : : {
3707 : 0 : struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);
3708 : :
3709 [ # # ]: 0 : if (unlikely(pt->req->poll.head)) {
3710 : 0 : pt->error = -EINVAL;
3711 : 0 : return;
3712 : : }
3713 : :
3714 : 0 : pt->error = 0;
3715 : 0 : pt->req->poll.head = head;
3716 : 0 : add_wait_queue(head, &pt->req->poll.wait);
3717 : : }
3718 : :
3719 : 0 : static void io_poll_req_insert(struct io_kiocb *req)
3720 : : {
3721 : 0 : struct io_ring_ctx *ctx = req->ctx;
3722 : 0 : struct hlist_head *list;
3723 : :
3724 : 0 : list = &ctx->cancel_hash[hash_long(req->user_data, ctx->cancel_hash_bits)];
3725 [ # # ]: 0 : hlist_add_head(&req->hash_node, list);
3726 : 0 : }
3727 : :
3728 : 0 : static int io_poll_add_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
3729 : : {
3730 : 0 : struct io_poll_iocb *poll = &req->poll;
3731 : 0 : u16 events;
3732 : :
3733 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3734 : : return -EINVAL;
3735 [ # # # # : 0 : if (sqe->addr || sqe->ioprio || sqe->off || sqe->len || sqe->buf_index)
# # # # #
# ]
3736 : : return -EINVAL;
3737 [ # # ]: 0 : if (!poll->file)
3738 : : return -EBADF;
3739 : :
3740 : 0 : events = READ_ONCE(sqe->poll_events);
3741 : 0 : poll->events = demangle_poll(events) | EPOLLERR | EPOLLHUP;
3742 : 0 : return 0;
3743 : : }
3744 : :
3745 : 0 : static int io_poll_add(struct io_kiocb *req, struct io_kiocb **nxt)
3746 : : {
3747 : 0 : struct io_poll_iocb *poll = &req->poll;
3748 : 0 : struct io_ring_ctx *ctx = req->ctx;
3749 : 0 : struct io_poll_table ipt;
3750 : 0 : bool cancel = false;
3751 : 0 : __poll_t mask;
3752 : :
3753 : 0 : INIT_IO_WORK(&req->work, io_poll_complete_work);
3754 [ # # ]: 0 : INIT_HLIST_NODE(&req->hash_node);
3755 : :
3756 : 0 : poll->head = NULL;
3757 : 0 : poll->done = false;
3758 : 0 : poll->canceled = false;
3759 : :
3760 : 0 : ipt.pt._qproc = io_poll_queue_proc;
3761 : 0 : ipt.pt._key = poll->events;
3762 : 0 : ipt.req = req;
3763 : 0 : ipt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */
3764 : :
3765 : : /* initialized the list so that we can do list_empty checks */
3766 [ # # ]: 0 : INIT_LIST_HEAD(&poll->wait.entry);
3767 [ # # ]: 0 : init_waitqueue_func_entry(&poll->wait, io_poll_wake);
3768 : 0 : poll->wait.private = poll;
3769 : :
3770 : 0 : INIT_LIST_HEAD(&req->list);
3771 : :
3772 [ # # ]: 0 : mask = vfs_poll(poll->file, &ipt.pt) & poll->events;
3773 : :
3774 : 0 : spin_lock_irq(&ctx->completion_lock);
3775 [ # # ]: 0 : if (likely(poll->head)) {
3776 : 0 : spin_lock(&poll->head->lock);
3777 [ # # ]: 0 : if (unlikely(list_empty(&poll->wait.entry))) {
3778 [ # # ]: 0 : if (ipt.error)
3779 : 0 : cancel = true;
3780 : 0 : ipt.error = 0;
3781 : 0 : mask = 0;
3782 : : }
3783 [ # # # # ]: 0 : if (mask || ipt.error)
3784 : 0 : list_del_init(&poll->wait.entry);
3785 [ # # ]: 0 : else if (cancel)
3786 : 0 : WRITE_ONCE(poll->canceled, true);
3787 [ # # ]: 0 : else if (!poll->done) /* actually waiting for an event */
3788 [ # # ]: 0 : io_poll_req_insert(req);
3789 : 0 : spin_unlock(&poll->head->lock);
3790 : : }
3791 [ # # ]: 0 : if (mask) { /* no async, we'd stolen it */
3792 : 0 : ipt.error = 0;
3793 : 0 : io_poll_complete(req, mask, 0);
3794 : : }
3795 : 0 : spin_unlock_irq(&ctx->completion_lock);
3796 : :
3797 [ # # ]: 0 : if (mask) {
3798 : 0 : io_cqring_ev_posted(ctx);
3799 : 0 : io_put_req_find_next(req, nxt);
3800 : : }
3801 : 0 : return ipt.error;
3802 : : }
3803 : :
3804 : 0 : static enum hrtimer_restart io_timeout_fn(struct hrtimer *timer)
3805 : : {
3806 : 0 : struct io_timeout_data *data = container_of(timer,
3807 : : struct io_timeout_data, timer);
3808 : 0 : struct io_kiocb *req = data->req;
3809 : 0 : struct io_ring_ctx *ctx = req->ctx;
3810 : 0 : unsigned long flags;
3811 : :
3812 : 0 : atomic_inc(&ctx->cq_timeouts);
3813 : :
3814 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
3815 : : /*
3816 : : * We could be racing with timeout deletion. If the list is empty,
3817 : : * then timeout lookup already found it and will be handling it.
3818 : : */
3819 [ # # ]: 0 : if (!list_empty(&req->list)) {
3820 : 0 : struct io_kiocb *prev;
3821 : :
3822 : : /*
3823 : : * Adjust the reqs sequence before the current one because it
3824 : : * will consume a slot in the cq_ring and the cq_tail
3825 : : * pointer will be increased, otherwise other timeout reqs may
3826 : : * return in advance without waiting for enough wait_nr.
3827 : : */
3828 : 0 : prev = req;
3829 [ # # ]: 0 : list_for_each_entry_continue_reverse(prev, &ctx->timeout_list, list)
3830 : 0 : prev->sequence++;
3831 : 0 : list_del_init(&req->list);
3832 : : }
3833 : :
3834 : 0 : io_cqring_fill_event(req, -ETIME);
3835 : 0 : io_commit_cqring(ctx);
3836 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
3837 : :
3838 : 0 : io_cqring_ev_posted(ctx);
3839 [ # # ]: 0 : req_set_fail_links(req);
3840 : 0 : io_put_req(req);
3841 : 0 : return HRTIMER_NORESTART;
3842 : : }
3843 : :
3844 : 0 : static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data)
3845 : : {
3846 : 0 : struct io_kiocb *req;
3847 : 0 : int ret = -ENOENT;
3848 : :
3849 [ # # ]: 0 : list_for_each_entry(req, &ctx->timeout_list, list) {
3850 [ # # ]: 0 : if (user_data == req->user_data) {
3851 : 0 : list_del_init(&req->list);
3852 : 0 : ret = 0;
3853 : 0 : break;
3854 : : }
3855 : : }
3856 : :
3857 : 0 : if (ret == -ENOENT)
3858 : : return ret;
3859 : :
3860 : 0 : ret = hrtimer_try_to_cancel(&req->io->timeout.timer);
3861 [ # # ]: 0 : if (ret == -1)
3862 : : return -EALREADY;
3863 : :
3864 [ # # ]: 0 : req_set_fail_links(req);
3865 : 0 : io_cqring_fill_event(req, -ECANCELED);
3866 : 0 : io_put_req(req);
3867 : 0 : return 0;
3868 : : }
3869 : :
3870 : 0 : static int io_timeout_remove_prep(struct io_kiocb *req,
3871 : : const struct io_uring_sqe *sqe)
3872 : : {
3873 : 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3874 : : return -EINVAL;
3875 [ # # # # : 0 : if (sqe->flags || sqe->ioprio || sqe->buf_index || sqe->len)
# # # # #
# # # ]
3876 : : return -EINVAL;
3877 : :
3878 [ # # # # ]: 0 : req->timeout.addr = READ_ONCE(sqe->addr);
3879 : 0 : req->timeout.flags = READ_ONCE(sqe->timeout_flags);
3880 [ # # # # ]: 0 : if (req->timeout.flags)
3881 : 0 : return -EINVAL;
3882 : :
3883 : : return 0;
3884 : : }
3885 : :
3886 : : /*
3887 : : * Remove or update an existing timeout command
3888 : : */
3889 : 0 : static int io_timeout_remove(struct io_kiocb *req)
3890 : : {
3891 : 0 : struct io_ring_ctx *ctx = req->ctx;
3892 : 0 : int ret;
3893 : :
3894 : 0 : spin_lock_irq(&ctx->completion_lock);
3895 : 0 : ret = io_timeout_cancel(ctx, req->timeout.addr);
3896 : :
3897 : 0 : io_cqring_fill_event(req, ret);
3898 : 0 : io_commit_cqring(ctx);
3899 : 0 : spin_unlock_irq(&ctx->completion_lock);
3900 : 0 : io_cqring_ev_posted(ctx);
3901 [ # # ]: 0 : if (ret < 0)
3902 [ # # ]: 0 : req_set_fail_links(req);
3903 : 0 : io_put_req(req);
3904 : 0 : return 0;
3905 : : }
3906 : :
3907 : 0 : static int io_timeout_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe,
3908 : : bool is_timeout_link)
3909 : : {
3910 : 0 : struct io_timeout_data *data;
3911 : 0 : unsigned flags;
3912 : :
3913 [ # # ]: 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
3914 : : return -EINVAL;
3915 [ # # # # : 0 : if (sqe->ioprio || sqe->buf_index || sqe->len != 1)
# # ]
3916 : : return -EINVAL;
3917 [ # # # # ]: 0 : if (sqe->off && is_timeout_link)
3918 : : return -EINVAL;
3919 [ # # ]: 0 : flags = READ_ONCE(sqe->timeout_flags);
3920 [ # # ]: 0 : if (flags & ~IORING_TIMEOUT_ABS)
3921 : : return -EINVAL;
3922 : :
3923 [ # # ]: 0 : req->timeout.count = READ_ONCE(sqe->off);
3924 : :
3925 [ # # # # : 0 : if (!req->io && io_alloc_async_ctx(req))
# # ]
3926 : : return -ENOMEM;
3927 : :
3928 : 0 : data = &req->io->timeout;
3929 : 0 : data->req = req;
3930 : 0 : req->flags |= REQ_F_TIMEOUT;
3931 : :
3932 [ # # ]: 0 : if (get_timespec64(&data->ts, u64_to_user_ptr(sqe->addr)))
3933 : : return -EFAULT;
3934 : :
3935 [ # # ]: 0 : if (flags & IORING_TIMEOUT_ABS)
3936 : 0 : data->mode = HRTIMER_MODE_ABS;
3937 : : else
3938 : 0 : data->mode = HRTIMER_MODE_REL;
3939 : :
3940 : 0 : hrtimer_init(&data->timer, CLOCK_MONOTONIC, data->mode);
3941 : 0 : return 0;
3942 : : }
3943 : :
3944 : 0 : static int io_timeout(struct io_kiocb *req)
3945 : : {
3946 : 0 : unsigned count;
3947 : 0 : struct io_ring_ctx *ctx = req->ctx;
3948 : 0 : struct io_timeout_data *data;
3949 : 0 : struct list_head *entry;
3950 : 0 : unsigned span = 0;
3951 : :
3952 : 0 : data = &req->io->timeout;
3953 : :
3954 : : /*
3955 : : * sqe->off holds how many events that need to occur for this
3956 : : * timeout event to be satisfied. If it isn't set, then this is
3957 : : * a pure timeout request, sequence isn't used.
3958 : : */
3959 : 0 : count = req->timeout.count;
3960 [ # # ]: 0 : if (!count) {
3961 : 0 : req->flags |= REQ_F_TIMEOUT_NOSEQ;
3962 : 0 : spin_lock_irq(&ctx->completion_lock);
3963 : 0 : entry = ctx->timeout_list.prev;
3964 : 0 : goto add;
3965 : : }
3966 : :
3967 : 0 : req->sequence = ctx->cached_sq_head + count - 1;
3968 : 0 : data->seq_offset = count;
3969 : :
3970 : : /*
3971 : : * Insertion sort, ensuring the first entry in the list is always
3972 : : * the one we need first.
3973 : : */
3974 : 0 : spin_lock_irq(&ctx->completion_lock);
3975 [ # # ]: 0 : list_for_each_prev(entry, &ctx->timeout_list) {
3976 : 0 : struct io_kiocb *nxt = list_entry(entry, struct io_kiocb, list);
3977 : 0 : unsigned nxt_sq_head;
3978 : 0 : long long tmp, tmp_nxt;
3979 : 0 : u32 nxt_offset = nxt->io->timeout.seq_offset;
3980 : :
3981 [ # # ]: 0 : if (nxt->flags & REQ_F_TIMEOUT_NOSEQ)
3982 : 0 : continue;
3983 : :
3984 : : /*
3985 : : * Since cached_sq_head + count - 1 can overflow, use type long
3986 : : * long to store it.
3987 : : */
3988 : 0 : tmp = (long long)ctx->cached_sq_head + count - 1;
3989 : 0 : nxt_sq_head = nxt->sequence - nxt_offset + 1;
3990 : 0 : tmp_nxt = (long long)nxt_sq_head + nxt_offset - 1;
3991 : :
3992 : : /*
3993 : : * cached_sq_head may overflow, and it will never overflow twice
3994 : : * once there is some timeout req still be valid.
3995 : : */
3996 [ # # ]: 0 : if (ctx->cached_sq_head < nxt_sq_head)
3997 : 0 : tmp += UINT_MAX;
3998 : :
3999 [ # # ]: 0 : if (tmp > tmp_nxt)
4000 : : break;
4001 : :
4002 : : /*
4003 : : * Sequence of reqs after the insert one and itself should
4004 : : * be adjusted because each timeout req consumes a slot.
4005 : : */
4006 : 0 : span++;
4007 : 0 : nxt->sequence++;
4008 : : }
4009 : 0 : req->sequence -= span;
4010 : 0 : add:
4011 [ # # ]: 0 : list_add(&req->list, entry);
4012 : 0 : data->timer.function = io_timeout_fn;
4013 [ # # ]: 0 : hrtimer_start(&data->timer, timespec64_to_ktime(data->ts), data->mode);
4014 : 0 : spin_unlock_irq(&ctx->completion_lock);
4015 : 0 : return 0;
4016 : : }
4017 : :
4018 : 0 : static bool io_cancel_cb(struct io_wq_work *work, void *data)
4019 : : {
4020 : 0 : struct io_kiocb *req = container_of(work, struct io_kiocb, work);
4021 : :
4022 : 0 : return req->user_data == (unsigned long) data;
4023 : : }
4024 : :
4025 : 0 : static int io_async_cancel_one(struct io_ring_ctx *ctx, void *sqe_addr)
4026 : : {
4027 : 0 : enum io_wq_cancel cancel_ret;
4028 : 0 : int ret = 0;
4029 : :
4030 : 0 : cancel_ret = io_wq_cancel_cb(ctx->io_wq, io_cancel_cb, sqe_addr);
4031 [ # # # ]: 0 : switch (cancel_ret) {
4032 : : case IO_WQ_CANCEL_OK:
4033 : : ret = 0;
4034 : : break;
4035 : : case IO_WQ_CANCEL_RUNNING:
4036 : 0 : ret = -EALREADY;
4037 : 0 : break;
4038 : : case IO_WQ_CANCEL_NOTFOUND:
4039 : 0 : ret = -ENOENT;
4040 : 0 : break;
4041 : : }
4042 : :
4043 : 0 : return ret;
4044 : : }
4045 : :
4046 : 0 : static void io_async_find_and_cancel(struct io_ring_ctx *ctx,
4047 : : struct io_kiocb *req, __u64 sqe_addr,
4048 : : struct io_kiocb **nxt, int success_ret)
4049 : : {
4050 : 0 : unsigned long flags;
4051 : 0 : int ret;
4052 : :
4053 : 0 : ret = io_async_cancel_one(ctx, (void *) (unsigned long) sqe_addr);
4054 : 0 : if (ret != -ENOENT) {
4055 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
4056 : 0 : goto done;
4057 : : }
4058 : :
4059 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
4060 : 0 : ret = io_timeout_cancel(ctx, sqe_addr);
4061 [ # # ]: 0 : if (ret != -ENOENT)
4062 : 0 : goto done;
4063 : 0 : ret = io_poll_cancel(ctx, sqe_addr);
4064 : 0 : done:
4065 [ # # ]: 0 : if (!ret)
4066 : 0 : ret = success_ret;
4067 : 0 : io_cqring_fill_event(req, ret);
4068 : 0 : io_commit_cqring(ctx);
4069 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
4070 : 0 : io_cqring_ev_posted(ctx);
4071 : :
4072 [ # # ]: 0 : if (ret < 0)
4073 [ # # ]: 0 : req_set_fail_links(req);
4074 : 0 : io_put_req_find_next(req, nxt);
4075 : 0 : }
4076 : :
4077 : 0 : static int io_async_cancel_prep(struct io_kiocb *req,
4078 : : const struct io_uring_sqe *sqe)
4079 : : {
4080 : 0 : if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
4081 : : return -EINVAL;
4082 [ # # # # : 0 : if (sqe->flags || sqe->ioprio || sqe->off || sqe->len ||
# # # # #
# # # ]
4083 : : sqe->cancel_flags)
4084 : : return -EINVAL;
4085 : :
4086 : 0 : req->cancel.addr = READ_ONCE(sqe->addr);
4087 : 0 : return 0;
4088 : : }
4089 : :
4090 : 0 : static int io_async_cancel(struct io_kiocb *req, struct io_kiocb **nxt)
4091 : : {
4092 : 0 : struct io_ring_ctx *ctx = req->ctx;
4093 : :
4094 : 0 : io_async_find_and_cancel(ctx, req, req->cancel.addr, nxt, 0);
4095 : 0 : return 0;
4096 : : }
4097 : :
4098 : 0 : static int io_files_update_prep(struct io_kiocb *req,
4099 : : const struct io_uring_sqe *sqe)
4100 : : {
4101 [ # # # # ]: 0 : if (sqe->flags || sqe->ioprio || sqe->rw_flags)
4102 : : return -EINVAL;
4103 : :
4104 [ # # # # ]: 0 : req->files_update.offset = READ_ONCE(sqe->off);
4105 : 0 : req->files_update.nr_args = READ_ONCE(sqe->len);
4106 [ # # # # ]: 0 : if (!req->files_update.nr_args)
4107 : : return -EINVAL;
4108 : 0 : req->files_update.arg = READ_ONCE(sqe->addr);
4109 : 0 : return 0;
4110 : : }
4111 : :
4112 : 0 : static int io_files_update(struct io_kiocb *req, bool force_nonblock)
4113 : : {
4114 : 0 : struct io_ring_ctx *ctx = req->ctx;
4115 : 0 : struct io_uring_files_update up;
4116 : 0 : int ret;
4117 : :
4118 [ # # ]: 0 : if (force_nonblock)
4119 : : return -EAGAIN;
4120 : :
4121 : 0 : up.offset = req->files_update.offset;
4122 : 0 : up.fds = req->files_update.arg;
4123 : :
4124 : 0 : mutex_lock(&ctx->uring_lock);
4125 : 0 : ret = __io_sqe_files_update(ctx, &up, req->files_update.nr_args);
4126 : 0 : mutex_unlock(&ctx->uring_lock);
4127 : :
4128 [ # # ]: 0 : if (ret < 0)
4129 [ # # ]: 0 : req_set_fail_links(req);
4130 : 0 : io_cqring_add_event(req, ret);
4131 : 0 : io_put_req(req);
4132 : 0 : return 0;
4133 : : }
4134 : :
4135 : 0 : static int io_req_defer_prep(struct io_kiocb *req,
4136 : : const struct io_uring_sqe *sqe)
4137 : : {
4138 : 0 : ssize_t ret = 0;
4139 : :
4140 [ # # ]: 0 : if (!sqe)
4141 : : return 0;
4142 : :
4143 [ # # ]: 0 : if (io_op_defs[req->opcode].file_table) {
4144 : 0 : ret = io_grab_files(req);
4145 [ # # ]: 0 : if (unlikely(ret))
4146 : : return ret;
4147 : : }
4148 : :
4149 : 0 : io_req_work_grab_env(req, &io_op_defs[req->opcode]);
4150 : :
4151 [ # # # # : 0 : switch (req->opcode) {
# # # # #
# # # # #
# # # # #
# # # # #
# ]
4152 : : case IORING_OP_NOP:
4153 : : break;
4154 : 0 : case IORING_OP_READV:
4155 : : case IORING_OP_READ_FIXED:
4156 : : case IORING_OP_READ:
4157 : 0 : ret = io_read_prep(req, sqe, true);
4158 : 0 : break;
4159 : 0 : case IORING_OP_WRITEV:
4160 : : case IORING_OP_WRITE_FIXED:
4161 : : case IORING_OP_WRITE:
4162 : 0 : ret = io_write_prep(req, sqe, true);
4163 : 0 : break;
4164 : 0 : case IORING_OP_POLL_ADD:
4165 : 0 : ret = io_poll_add_prep(req, sqe);
4166 : 0 : break;
4167 : 0 : case IORING_OP_POLL_REMOVE:
4168 [ # # ]: 0 : ret = io_poll_remove_prep(req, sqe);
4169 : 0 : break;
4170 : 0 : case IORING_OP_FSYNC:
4171 : 0 : ret = io_prep_fsync(req, sqe);
4172 : 0 : break;
4173 : : case IORING_OP_SYNC_FILE_RANGE:
4174 [ # # ]: 0 : ret = io_prep_sfr(req, sqe);
4175 : 0 : break;
4176 : 0 : case IORING_OP_SENDMSG:
4177 : : case IORING_OP_SEND:
4178 : 0 : ret = io_sendmsg_prep(req, sqe);
4179 : 0 : break;
4180 : 0 : case IORING_OP_RECVMSG:
4181 : : case IORING_OP_RECV:
4182 : 0 : ret = io_recvmsg_prep(req, sqe);
4183 : 0 : break;
4184 : 0 : case IORING_OP_CONNECT:
4185 : 0 : ret = io_connect_prep(req, sqe);
4186 : 0 : break;
4187 : 0 : case IORING_OP_TIMEOUT:
4188 : 0 : ret = io_timeout_prep(req, sqe, false);
4189 : 0 : break;
4190 : : case IORING_OP_TIMEOUT_REMOVE:
4191 [ # # ]: 0 : ret = io_timeout_remove_prep(req, sqe);
4192 : 0 : break;
4193 : 0 : case IORING_OP_ASYNC_CANCEL:
4194 [ # # ]: 0 : ret = io_async_cancel_prep(req, sqe);
4195 : 0 : break;
4196 : 0 : case IORING_OP_LINK_TIMEOUT:
4197 : 0 : ret = io_timeout_prep(req, sqe, true);
4198 : 0 : break;
4199 : 0 : case IORING_OP_ACCEPT:
4200 : 0 : ret = io_accept_prep(req, sqe);
4201 : 0 : break;
4202 : : case IORING_OP_FALLOCATE:
4203 [ # # ]: 0 : ret = io_fallocate_prep(req, sqe);
4204 : 0 : break;
4205 : 0 : case IORING_OP_OPENAT:
4206 : 0 : ret = io_openat_prep(req, sqe);
4207 : 0 : break;
4208 : 0 : case IORING_OP_CLOSE:
4209 : 0 : ret = io_close_prep(req, sqe);
4210 : 0 : break;
4211 : : case IORING_OP_FILES_UPDATE:
4212 [ # # ]: 0 : ret = io_files_update_prep(req, sqe);
4213 : 0 : break;
4214 : 0 : case IORING_OP_STATX:
4215 : 0 : ret = io_statx_prep(req, sqe);
4216 : 0 : break;
4217 : : case IORING_OP_FADVISE:
4218 [ # # ]: 0 : ret = io_fadvise_prep(req, sqe);
4219 : 0 : break;
4220 : : case IORING_OP_MADVISE:
4221 [ # # ]: 0 : ret = io_madvise_prep(req, sqe);
4222 : 0 : break;
4223 : 0 : case IORING_OP_OPENAT2:
4224 : 0 : ret = io_openat2_prep(req, sqe);
4225 : 0 : break;
4226 : 0 : case IORING_OP_EPOLL_CTL:
4227 : 0 : ret = io_epoll_ctl_prep(req, sqe);
4228 : 0 : break;
4229 : 0 : default:
4230 [ # # ]: 0 : printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
4231 : : req->opcode);
4232 : 0 : ret = -EINVAL;
4233 : 0 : break;
4234 : : }
4235 : :
4236 : 0 : return ret;
4237 : : }
4238 : :
4239 : 0 : static int io_req_defer(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4240 : : {
4241 : 0 : struct io_ring_ctx *ctx = req->ctx;
4242 : 0 : int ret;
4243 : :
4244 : : /* Still need defer if there is pending req in defer list. */
4245 [ # # # # ]: 0 : if (!req_need_defer(req) && list_empty(&ctx->defer_list))
4246 : : return 0;
4247 : :
4248 [ # # # # : 0 : if (!req->io && io_alloc_async_ctx(req))
# # ]
4249 : : return -EAGAIN;
4250 : :
4251 : 0 : ret = io_req_defer_prep(req, sqe);
4252 [ # # ]: 0 : if (ret < 0)
4253 : : return ret;
4254 : :
4255 : 0 : spin_lock_irq(&ctx->completion_lock);
4256 [ # # # # ]: 0 : if (!req_need_defer(req) && list_empty(&ctx->defer_list)) {
4257 : 0 : spin_unlock_irq(&ctx->completion_lock);
4258 : 0 : return 0;
4259 : : }
4260 : :
4261 : 0 : trace_io_uring_defer(ctx, req, req->user_data);
4262 : 0 : list_add_tail(&req->list, &ctx->defer_list);
4263 : 0 : spin_unlock_irq(&ctx->completion_lock);
4264 : 0 : return -EIOCBQUEUED;
4265 : : }
4266 : :
4267 : 0 : static void io_cleanup_req(struct io_kiocb *req)
4268 : : {
4269 : 0 : struct io_async_ctx *io = req->io;
4270 : :
4271 [ # # # # ]: 0 : switch (req->opcode) {
4272 : 0 : case IORING_OP_READV:
4273 : : case IORING_OP_READ_FIXED:
4274 : : case IORING_OP_READ:
4275 : : case IORING_OP_WRITEV:
4276 : : case IORING_OP_WRITE_FIXED:
4277 : : case IORING_OP_WRITE:
4278 [ # # ]: 0 : if (io->rw.iov != io->rw.fast_iov)
4279 : 0 : kfree(io->rw.iov);
4280 : : break;
4281 : 0 : case IORING_OP_SENDMSG:
4282 : : case IORING_OP_RECVMSG:
4283 [ # # ]: 0 : if (io->msg.iov != io->msg.fast_iov)
4284 : 0 : kfree(io->msg.iov);
4285 : : break;
4286 : 0 : case IORING_OP_OPENAT:
4287 : : case IORING_OP_OPENAT2:
4288 : : case IORING_OP_STATX:
4289 : 0 : putname(req->open.filename);
4290 : 0 : break;
4291 : : }
4292 : :
4293 : 0 : req->flags &= ~REQ_F_NEED_CLEANUP;
4294 : 0 : }
4295 : :
4296 : 0 : static int io_issue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
4297 : : struct io_kiocb **nxt, bool force_nonblock)
4298 : : {
4299 : 0 : struct io_ring_ctx *ctx = req->ctx;
4300 : 0 : int ret;
4301 : :
4302 [ # # # # : 0 : switch (req->opcode) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
4303 : 0 : case IORING_OP_NOP:
4304 : 0 : ret = io_nop(req);
4305 : 0 : break;
4306 : 0 : case IORING_OP_READV:
4307 : : case IORING_OP_READ_FIXED:
4308 : : case IORING_OP_READ:
4309 [ # # ]: 0 : if (sqe) {
4310 : 0 : ret = io_read_prep(req, sqe, force_nonblock);
4311 [ # # ]: 0 : if (ret < 0)
4312 : : break;
4313 : : }
4314 : 0 : ret = io_read(req, nxt, force_nonblock);
4315 : 0 : break;
4316 : 0 : case IORING_OP_WRITEV:
4317 : : case IORING_OP_WRITE_FIXED:
4318 : : case IORING_OP_WRITE:
4319 [ # # ]: 0 : if (sqe) {
4320 : 0 : ret = io_write_prep(req, sqe, force_nonblock);
4321 [ # # ]: 0 : if (ret < 0)
4322 : : break;
4323 : : }
4324 : 0 : ret = io_write(req, nxt, force_nonblock);
4325 : 0 : break;
4326 : 0 : case IORING_OP_FSYNC:
4327 [ # # ]: 0 : if (sqe) {
4328 : 0 : ret = io_prep_fsync(req, sqe);
4329 [ # # ]: 0 : if (ret < 0)
4330 : : break;
4331 : : }
4332 : 0 : ret = io_fsync(req, nxt, force_nonblock);
4333 : 0 : break;
4334 : 0 : case IORING_OP_POLL_ADD:
4335 [ # # ]: 0 : if (sqe) {
4336 : 0 : ret = io_poll_add_prep(req, sqe);
4337 [ # # ]: 0 : if (ret)
4338 : : break;
4339 : : }
4340 : 0 : ret = io_poll_add(req, nxt);
4341 : 0 : break;
4342 : 0 : case IORING_OP_POLL_REMOVE:
4343 [ # # ]: 0 : if (sqe) {
4344 [ # # ]: 0 : ret = io_poll_remove_prep(req, sqe);
4345 : 0 : if (ret < 0)
4346 : : break;
4347 : : }
4348 : 0 : ret = io_poll_remove(req);
4349 : 0 : break;
4350 : 0 : case IORING_OP_SYNC_FILE_RANGE:
4351 [ # # ]: 0 : if (sqe) {
4352 [ # # ]: 0 : ret = io_prep_sfr(req, sqe);
4353 : 0 : if (ret < 0)
4354 : : break;
4355 : : }
4356 : 0 : ret = io_sync_file_range(req, nxt, force_nonblock);
4357 : 0 : break;
4358 : 0 : case IORING_OP_SENDMSG:
4359 : : case IORING_OP_SEND:
4360 [ # # ]: 0 : if (sqe) {
4361 : 0 : ret = io_sendmsg_prep(req, sqe);
4362 [ # # ]: 0 : if (ret < 0)
4363 : : break;
4364 : : }
4365 [ # # ]: 0 : if (req->opcode == IORING_OP_SENDMSG)
4366 : 0 : ret = io_sendmsg(req, nxt, force_nonblock);
4367 : : else
4368 : 0 : ret = io_send(req, nxt, force_nonblock);
4369 : : break;
4370 : 0 : case IORING_OP_RECVMSG:
4371 : : case IORING_OP_RECV:
4372 [ # # ]: 0 : if (sqe) {
4373 : 0 : ret = io_recvmsg_prep(req, sqe);
4374 [ # # ]: 0 : if (ret)
4375 : : break;
4376 : : }
4377 [ # # ]: 0 : if (req->opcode == IORING_OP_RECVMSG)
4378 : 0 : ret = io_recvmsg(req, nxt, force_nonblock);
4379 : : else
4380 : 0 : ret = io_recv(req, nxt, force_nonblock);
4381 : : break;
4382 : 0 : case IORING_OP_TIMEOUT:
4383 [ # # ]: 0 : if (sqe) {
4384 : 0 : ret = io_timeout_prep(req, sqe, false);
4385 [ # # ]: 0 : if (ret)
4386 : : break;
4387 : : }
4388 : 0 : ret = io_timeout(req);
4389 : 0 : break;
4390 : 0 : case IORING_OP_TIMEOUT_REMOVE:
4391 [ # # ]: 0 : if (sqe) {
4392 [ # # ]: 0 : ret = io_timeout_remove_prep(req, sqe);
4393 : : if (ret)
4394 : : break;
4395 : : }
4396 : 0 : ret = io_timeout_remove(req);
4397 : 0 : break;
4398 : 0 : case IORING_OP_ACCEPT:
4399 [ # # ]: 0 : if (sqe) {
4400 : 0 : ret = io_accept_prep(req, sqe);
4401 [ # # ]: 0 : if (ret)
4402 : : break;
4403 : : }
4404 : 0 : ret = io_accept(req, nxt, force_nonblock);
4405 : 0 : break;
4406 : 0 : case IORING_OP_CONNECT:
4407 [ # # ]: 0 : if (sqe) {
4408 : 0 : ret = io_connect_prep(req, sqe);
4409 [ # # ]: 0 : if (ret)
4410 : : break;
4411 : : }
4412 : 0 : ret = io_connect(req, nxt, force_nonblock);
4413 : 0 : break;
4414 : 0 : case IORING_OP_ASYNC_CANCEL:
4415 [ # # ]: 0 : if (sqe) {
4416 [ # # ]: 0 : ret = io_async_cancel_prep(req, sqe);
4417 : 0 : if (ret)
4418 : : break;
4419 : : }
4420 : 0 : ret = io_async_cancel(req, nxt);
4421 : 0 : break;
4422 : 0 : case IORING_OP_FALLOCATE:
4423 [ # # ]: 0 : if (sqe) {
4424 [ # # ]: 0 : ret = io_fallocate_prep(req, sqe);
4425 : 0 : if (ret)
4426 : : break;
4427 : : }
4428 : 0 : ret = io_fallocate(req, nxt, force_nonblock);
4429 : 0 : break;
4430 : 0 : case IORING_OP_OPENAT:
4431 [ # # ]: 0 : if (sqe) {
4432 : 0 : ret = io_openat_prep(req, sqe);
4433 [ # # ]: 0 : if (ret)
4434 : : break;
4435 : : }
4436 : 0 : ret = io_openat(req, nxt, force_nonblock);
4437 : 0 : break;
4438 : 0 : case IORING_OP_CLOSE:
4439 [ # # ]: 0 : if (sqe) {
4440 : 0 : ret = io_close_prep(req, sqe);
4441 [ # # ]: 0 : if (ret)
4442 : : break;
4443 : : }
4444 : 0 : ret = io_close(req, nxt, force_nonblock);
4445 : 0 : break;
4446 : 0 : case IORING_OP_FILES_UPDATE:
4447 [ # # ]: 0 : if (sqe) {
4448 [ # # ]: 0 : ret = io_files_update_prep(req, sqe);
4449 : 0 : if (ret)
4450 : : break;
4451 : : }
4452 : 0 : ret = io_files_update(req, force_nonblock);
4453 : 0 : break;
4454 : 0 : case IORING_OP_STATX:
4455 [ # # ]: 0 : if (sqe) {
4456 : 0 : ret = io_statx_prep(req, sqe);
4457 [ # # ]: 0 : if (ret)
4458 : : break;
4459 : : }
4460 : 0 : ret = io_statx(req, nxt, force_nonblock);
4461 : 0 : break;
4462 : 0 : case IORING_OP_FADVISE:
4463 [ # # ]: 0 : if (sqe) {
4464 [ # # ]: 0 : ret = io_fadvise_prep(req, sqe);
4465 : 0 : if (ret)
4466 : : break;
4467 : : }
4468 : 0 : ret = io_fadvise(req, nxt, force_nonblock);
4469 : 0 : break;
4470 : 0 : case IORING_OP_MADVISE:
4471 [ # # ]: 0 : if (sqe) {
4472 [ # # ]: 0 : ret = io_madvise_prep(req, sqe);
4473 : 0 : if (ret)
4474 : : break;
4475 : : }
4476 : 0 : ret = io_madvise(req, nxt, force_nonblock);
4477 : 0 : break;
4478 : 0 : case IORING_OP_OPENAT2:
4479 [ # # ]: 0 : if (sqe) {
4480 : 0 : ret = io_openat2_prep(req, sqe);
4481 [ # # ]: 0 : if (ret)
4482 : : break;
4483 : : }
4484 : 0 : ret = io_openat2(req, nxt, force_nonblock);
4485 : 0 : break;
4486 : 0 : case IORING_OP_EPOLL_CTL:
4487 [ # # ]: 0 : if (sqe) {
4488 : 0 : ret = io_epoll_ctl_prep(req, sqe);
4489 [ # # ]: 0 : if (ret)
4490 : : break;
4491 : : }
4492 : 0 : ret = io_epoll_ctl(req, nxt, force_nonblock);
4493 : 0 : break;
4494 : : default:
4495 : : ret = -EINVAL;
4496 : : break;
4497 : : }
4498 : :
4499 [ # # ]: 0 : if (ret)
4500 : 0 : return ret;
4501 : :
4502 [ # # ]: 0 : if (ctx->flags & IORING_SETUP_IOPOLL) {
4503 [ # # ]: 0 : const bool in_async = io_wq_current_is_worker();
4504 : :
4505 [ # # ]: 0 : if (req->result == -EAGAIN)
4506 : : return -EAGAIN;
4507 : :
4508 : : /* workqueue context doesn't hold uring_lock, grab it now */
4509 [ # # ]: 0 : if (in_async)
4510 : 0 : mutex_lock(&ctx->uring_lock);
4511 : :
4512 : 0 : io_iopoll_req_issued(req);
4513 : :
4514 [ # # ]: 0 : if (in_async)
4515 : 0 : mutex_unlock(&ctx->uring_lock);
4516 : : }
4517 : :
4518 : : return 0;
4519 : : }
4520 : :
4521 : 0 : static void io_wq_submit_work(struct io_wq_work **workptr)
4522 : : {
4523 : 0 : struct io_wq_work *work = *workptr;
4524 : 0 : struct io_kiocb *req = container_of(work, struct io_kiocb, work);
4525 : 0 : struct io_kiocb *nxt = NULL;
4526 : 0 : int ret = 0;
4527 : :
4528 : : /* if NO_CANCEL is set, we must still run the work */
4529 [ # # ]: 0 : if ((work->flags & (IO_WQ_WORK_CANCEL|IO_WQ_WORK_NO_CANCEL)) ==
4530 : : IO_WQ_WORK_CANCEL) {
4531 : : ret = -ECANCELED;
4532 : : }
4533 : :
4534 : 0 : if (!ret) {
4535 : 0 : req->in_async = true;
4536 : 0 : do {
4537 : 0 : ret = io_issue_sqe(req, NULL, &nxt, false);
4538 : : /*
4539 : : * We can get EAGAIN for polled IO even though we're
4540 : : * forcing a sync submission from here, since we can't
4541 : : * wait for request slots on the block side.
4542 : : */
4543 [ # # ]: 0 : if (ret != -EAGAIN)
4544 : : break;
4545 : 0 : cond_resched();
4546 : 0 : } while (1);
4547 : : }
4548 : :
4549 : : /* drop submission reference */
4550 : 0 : io_put_req(req);
4551 : :
4552 [ # # ]: 0 : if (ret) {
4553 [ # # ]: 0 : req_set_fail_links(req);
4554 : 0 : io_cqring_add_event(req, ret);
4555 : 0 : io_put_req(req);
4556 : : }
4557 : :
4558 : : /* if a dependent link is ready, pass it back */
4559 [ # # # # ]: 0 : if (!ret && nxt)
4560 : 0 : io_wq_assign_next(workptr, nxt);
4561 : 0 : }
4562 : :
4563 : 0 : static int io_req_needs_file(struct io_kiocb *req, int fd)
4564 : : {
4565 : 0 : if (!io_op_defs[req->opcode].needs_file)
4566 : : return 0;
4567 [ # # # # ]: 0 : if ((fd == -1 || fd == AT_FDCWD) && io_op_defs[req->opcode].fd_non_neg)
4568 : : return 0;
4569 : : return 1;
4570 : : }
4571 : :
4572 : 0 : static inline struct file *io_file_from_index(struct io_ring_ctx *ctx,
4573 : : int index)
4574 : : {
4575 : 0 : struct fixed_file_table *table;
4576 : :
4577 : 0 : table = &ctx->file_data->table[index >> IORING_FILE_TABLE_SHIFT];
4578 : 0 : return table->files[index & IORING_FILE_TABLE_MASK];;
4579 : : }
4580 : :
4581 : 0 : static int io_req_set_file(struct io_submit_state *state, struct io_kiocb *req,
4582 : : const struct io_uring_sqe *sqe)
4583 : : {
4584 : 0 : struct io_ring_ctx *ctx = req->ctx;
4585 : 0 : unsigned flags;
4586 : 0 : int fd;
4587 : :
4588 [ # # ]: 0 : flags = READ_ONCE(sqe->flags);
4589 : 0 : fd = READ_ONCE(sqe->fd);
4590 : :
4591 [ # # ]: 0 : if (!io_req_needs_file(req, fd))
4592 : : return 0;
4593 : :
4594 [ # # ]: 0 : if (flags & IOSQE_FIXED_FILE) {
4595 [ # # # # ]: 0 : if (unlikely(!ctx->file_data ||
4596 : : (unsigned) fd >= ctx->nr_user_files))
4597 : : return -EBADF;
4598 : 0 : fd = array_index_nospec(fd, ctx->nr_user_files);
4599 : 0 : req->file = io_file_from_index(ctx, fd);
4600 [ # # ]: 0 : if (!req->file)
4601 : : return -EBADF;
4602 : 0 : req->flags |= REQ_F_FIXED_FILE;
4603 : 0 : percpu_ref_get(&ctx->file_data->refs);
4604 : : } else {
4605 [ # # ]: 0 : if (req->needs_fixed_file)
4606 : : return -EBADF;
4607 : 0 : trace_io_uring_file_get(ctx, fd);
4608 : 0 : req->file = io_file_get(state, fd);
4609 [ # # ]: 0 : if (unlikely(!req->file))
4610 : 0 : return -EBADF;
4611 : : }
4612 : :
4613 : : return 0;
4614 : : }
4615 : :
4616 : 0 : static int io_grab_files(struct io_kiocb *req)
4617 : : {
4618 : 0 : int ret = -EBADF;
4619 : 0 : struct io_ring_ctx *ctx = req->ctx;
4620 : :
4621 [ # # ]: 0 : if (req->work.files)
4622 : : return 0;
4623 [ # # ]: 0 : if (!ctx->ring_file)
4624 : : return -EBADF;
4625 : :
4626 : 0 : rcu_read_lock();
4627 : 0 : spin_lock_irq(&ctx->inflight_lock);
4628 : : /*
4629 : : * We use the f_ops->flush() handler to ensure that we can flush
4630 : : * out work accessing these files if the fd is closed. Check if
4631 : : * the fd has changed since we started down this path, and disallow
4632 : : * this operation if it has.
4633 : : */
4634 [ # # # # ]: 0 : if (fcheck(ctx->ring_fd) == ctx->ring_file) {
4635 : 0 : list_add(&req->inflight_entry, &ctx->inflight_list);
4636 : 0 : req->flags |= REQ_F_INFLIGHT;
4637 : 0 : req->work.files = current->files;
4638 : 0 : ret = 0;
4639 : : }
4640 : 0 : spin_unlock_irq(&ctx->inflight_lock);
4641 : 0 : rcu_read_unlock();
4642 : :
4643 : 0 : return ret;
4644 : : }
4645 : :
4646 : 0 : static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer)
4647 : : {
4648 : 0 : struct io_timeout_data *data = container_of(timer,
4649 : : struct io_timeout_data, timer);
4650 : 0 : struct io_kiocb *req = data->req;
4651 : 0 : struct io_ring_ctx *ctx = req->ctx;
4652 : 0 : struct io_kiocb *prev = NULL;
4653 : 0 : unsigned long flags;
4654 : :
4655 : 0 : spin_lock_irqsave(&ctx->completion_lock, flags);
4656 : :
4657 : : /*
4658 : : * We don't expect the list to be empty, that will only happen if we
4659 : : * race with the completion of the linked work.
4660 : : */
4661 [ # # ]: 0 : if (!list_empty(&req->link_list)) {
4662 : 0 : prev = list_entry(req->link_list.prev, struct io_kiocb,
4663 : : link_list);
4664 [ # # ]: 0 : if (refcount_inc_not_zero(&prev->refs)) {
4665 : 0 : list_del_init(&req->link_list);
4666 : 0 : prev->flags &= ~REQ_F_LINK_TIMEOUT;
4667 : : } else
4668 : : prev = NULL;
4669 : : }
4670 : :
4671 : 0 : spin_unlock_irqrestore(&ctx->completion_lock, flags);
4672 : :
4673 [ # # ]: 0 : if (prev) {
4674 [ # # ]: 0 : req_set_fail_links(prev);
4675 : 0 : io_async_find_and_cancel(ctx, req, prev->user_data, NULL,
4676 : : -ETIME);
4677 : 0 : io_put_req(prev);
4678 : : } else {
4679 : 0 : io_cqring_add_event(req, -ETIME);
4680 : 0 : io_put_req(req);
4681 : : }
4682 : 0 : return HRTIMER_NORESTART;
4683 : : }
4684 : :
4685 : 0 : static void io_queue_linked_timeout(struct io_kiocb *req)
4686 : : {
4687 : 0 : struct io_ring_ctx *ctx = req->ctx;
4688 : :
4689 : : /*
4690 : : * If the list is now empty, then our linked request finished before
4691 : : * we got a chance to setup the timer
4692 : : */
4693 : 0 : spin_lock_irq(&ctx->completion_lock);
4694 [ # # ]: 0 : if (!list_empty(&req->link_list)) {
4695 : 0 : struct io_timeout_data *data = &req->io->timeout;
4696 : :
4697 : 0 : data->timer.function = io_link_timeout_fn;
4698 [ # # ]: 0 : hrtimer_start(&data->timer, timespec64_to_ktime(data->ts),
4699 : : data->mode);
4700 : : }
4701 : 0 : spin_unlock_irq(&ctx->completion_lock);
4702 : :
4703 : : /* drop submission reference */
4704 : 0 : io_put_req(req);
4705 : 0 : }
4706 : :
4707 : 0 : static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req)
4708 : : {
4709 : 0 : struct io_kiocb *nxt;
4710 : :
4711 [ # # ]: 0 : if (!(req->flags & REQ_F_LINK))
4712 : : return NULL;
4713 : :
4714 [ # # # # ]: 0 : nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb,
4715 : : link_list);
4716 [ # # # # : 0 : if (!nxt || nxt->opcode != IORING_OP_LINK_TIMEOUT)
# # # # ]
4717 : : return NULL;
4718 : :
4719 : 0 : req->flags |= REQ_F_LINK_TIMEOUT;
4720 : 0 : return nxt;
4721 : : }
4722 : :
4723 : 0 : static void __io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4724 : : {
4725 : 0 : struct io_kiocb *linked_timeout;
4726 : 0 : struct io_kiocb *nxt = NULL;
4727 : 0 : const struct cred *old_creds = NULL;
4728 : 0 : int ret;
4729 : :
4730 : 0 : again:
4731 [ # # ]: 0 : linked_timeout = io_prep_linked_timeout(req);
4732 : :
4733 [ # # # # ]: 0 : if (req->work.creds && req->work.creds != current_cred()) {
4734 [ # # ]: 0 : if (old_creds)
4735 : 0 : revert_creds(old_creds);
4736 [ # # ]: 0 : if (old_creds == req->work.creds)
4737 : : old_creds = NULL; /* restored original creds */
4738 : : else
4739 : 0 : old_creds = override_creds(req->work.creds);
4740 : : }
4741 : :
4742 : 0 : ret = io_issue_sqe(req, sqe, &nxt, true);
4743 : :
4744 : : /*
4745 : : * We async punt it if the file wasn't marked NOWAIT, or if the file
4746 : : * doesn't support non-blocking read/write attempts
4747 : : */
4748 [ # # # # ]: 0 : if (ret == -EAGAIN && (!(req->flags & REQ_F_NOWAIT) ||
4749 : : (req->flags & REQ_F_MUST_PUNT))) {
4750 : 0 : punt:
4751 [ # # ]: 0 : if (io_op_defs[req->opcode].file_table) {
4752 : 0 : ret = io_grab_files(req);
4753 [ # # ]: 0 : if (ret)
4754 : 0 : goto err;
4755 : : }
4756 : :
4757 : : /*
4758 : : * Queued up for async execution, worker will release
4759 : : * submit reference when the iocb is actually submitted.
4760 : : */
4761 : 0 : io_queue_async_work(req);
4762 : 0 : goto done_req;
4763 : : }
4764 : :
4765 : 0 : err:
4766 : : /* drop submission reference */
4767 : 0 : io_put_req_find_next(req, &nxt);
4768 : :
4769 [ # # ]: 0 : if (linked_timeout) {
4770 [ # # ]: 0 : if (!ret)
4771 : 0 : io_queue_linked_timeout(linked_timeout);
4772 : : else
4773 : 0 : io_put_req(linked_timeout);
4774 : : }
4775 : :
4776 : : /* and drop final reference, if we failed */
4777 [ # # ]: 0 : if (ret) {
4778 : 0 : io_cqring_add_event(req, ret);
4779 [ # # ]: 0 : req_set_fail_links(req);
4780 : 0 : io_put_req(req);
4781 : : }
4782 : 0 : done_req:
4783 [ # # ]: 0 : if (nxt) {
4784 : 0 : req = nxt;
4785 : 0 : nxt = NULL;
4786 : :
4787 [ # # ]: 0 : if (req->flags & REQ_F_FORCE_ASYNC)
4788 : 0 : goto punt;
4789 : 0 : goto again;
4790 : : }
4791 [ # # ]: 0 : if (old_creds)
4792 : 0 : revert_creds(old_creds);
4793 : 0 : }
4794 : :
4795 : 0 : static void io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe)
4796 : : {
4797 : 0 : int ret;
4798 : :
4799 : 0 : ret = io_req_defer(req, sqe);
4800 [ # # ]: 0 : if (ret) {
4801 [ # # ]: 0 : if (ret != -EIOCBQUEUED) {
4802 : 0 : fail_req:
4803 : 0 : io_cqring_add_event(req, ret);
4804 [ # # ]: 0 : req_set_fail_links(req);
4805 : 0 : io_double_put_req(req);
4806 : : }
4807 [ # # ]: 0 : } else if (req->flags & REQ_F_FORCE_ASYNC) {
4808 : 0 : ret = io_req_defer_prep(req, sqe);
4809 [ # # ]: 0 : if (unlikely(ret < 0))
4810 : 0 : goto fail_req;
4811 : : /*
4812 : : * Never try inline submit of IOSQE_ASYNC is set, go straight
4813 : : * to async execution.
4814 : : */
4815 : 0 : req->work.flags |= IO_WQ_WORK_CONCURRENT;
4816 : 0 : io_queue_async_work(req);
4817 : : } else {
4818 : 0 : __io_queue_sqe(req, sqe);
4819 : : }
4820 : 0 : }
4821 : :
4822 : 0 : static inline void io_queue_link_head(struct io_kiocb *req)
4823 : : {
4824 [ # # ]: 0 : if (unlikely(req->flags & REQ_F_FAIL_LINK)) {
4825 : 0 : io_cqring_add_event(req, -ECANCELED);
4826 : 0 : io_double_put_req(req);
4827 : : } else
4828 : 0 : io_queue_sqe(req, NULL);
4829 : 0 : }
4830 : :
4831 : : #define SQE_VALID_FLAGS (IOSQE_FIXED_FILE|IOSQE_IO_DRAIN|IOSQE_IO_LINK| \
4832 : : IOSQE_IO_HARDLINK | IOSQE_ASYNC)
4833 : :
4834 : 0 : static bool io_submit_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
4835 : : struct io_submit_state *state, struct io_kiocb **link)
4836 : : {
4837 : 0 : struct io_ring_ctx *ctx = req->ctx;
4838 : 0 : unsigned int sqe_flags;
4839 : 0 : int ret, id;
4840 : :
4841 [ # # ]: 0 : sqe_flags = READ_ONCE(sqe->flags);
4842 : :
4843 : : /* enforce forwards compatibility on users */
4844 [ # # ]: 0 : if (unlikely(sqe_flags & ~SQE_VALID_FLAGS)) {
4845 : 0 : ret = -EINVAL;
4846 : 0 : goto err_req;
4847 : : }
4848 : :
4849 [ # # ]: 0 : id = READ_ONCE(sqe->personality);
4850 [ # # ]: 0 : if (id) {
4851 : 0 : req->work.creds = idr_find(&ctx->personality_idr, id);
4852 [ # # ]: 0 : if (unlikely(!req->work.creds)) {
4853 : 0 : ret = -EINVAL;
4854 : 0 : goto err_req;
4855 : : }
4856 [ # # ]: 0 : get_cred(req->work.creds);
4857 : : }
4858 : :
4859 : : /* same numerical values with corresponding REQ_F_*, safe to copy */
4860 : 0 : req->flags |= sqe_flags & (IOSQE_IO_DRAIN|IOSQE_IO_HARDLINK|
4861 : : IOSQE_ASYNC);
4862 : :
4863 : 0 : ret = io_req_set_file(state, req, sqe);
4864 [ # # ]: 0 : if (unlikely(ret)) {
4865 : 0 : err_req:
4866 : 0 : io_cqring_add_event(req, ret);
4867 : 0 : io_double_put_req(req);
4868 : 0 : return false;
4869 : : }
4870 : :
4871 : : /*
4872 : : * If we already have a head request, queue this one for async
4873 : : * submittal once the head completes. If we don't have a head but
4874 : : * IOSQE_IO_LINK is set in the sqe, start a new head. This one will be
4875 : : * submitted sync once the chain is complete. If none of those
4876 : : * conditions are true (normal request), then just queue it.
4877 : : */
4878 [ # # ]: 0 : if (*link) {
4879 : 0 : struct io_kiocb *head = *link;
4880 : :
4881 : : /*
4882 : : * Taking sequential execution of a link, draining both sides
4883 : : * of the link also fullfils IOSQE_IO_DRAIN semantics for all
4884 : : * requests in the link. So, it drains the head and the
4885 : : * next after the link request. The last one is done via
4886 : : * drain_next flag to persist the effect across calls.
4887 : : */
4888 [ # # ]: 0 : if (sqe_flags & IOSQE_IO_DRAIN) {
4889 : 0 : head->flags |= REQ_F_IO_DRAIN;
4890 : 0 : ctx->drain_next = 1;
4891 : : }
4892 [ # # # # ]: 0 : if (io_alloc_async_ctx(req)) {
4893 : 0 : ret = -EAGAIN;
4894 : 0 : goto err_req;
4895 : : }
4896 : :
4897 : 0 : ret = io_req_defer_prep(req, sqe);
4898 [ # # ]: 0 : if (ret) {
4899 : : /* fail even hard links since we don't submit */
4900 : 0 : head->flags |= REQ_F_FAIL_LINK;
4901 : 0 : goto err_req;
4902 : : }
4903 : 0 : trace_io_uring_link(ctx, req, head);
4904 [ # # ]: 0 : list_add_tail(&req->link_list, &head->link_list);
4905 : :
4906 : : /* last request of a link, enqueue the link */
4907 [ # # ]: 0 : if (!(sqe_flags & (IOSQE_IO_LINK|IOSQE_IO_HARDLINK))) {
4908 : 0 : io_queue_link_head(head);
4909 : 0 : *link = NULL;
4910 : : }
4911 : : } else {
4912 [ # # ]: 0 : if (unlikely(ctx->drain_next)) {
4913 : 0 : req->flags |= REQ_F_IO_DRAIN;
4914 : 0 : req->ctx->drain_next = 0;
4915 : : }
4916 [ # # ]: 0 : if (sqe_flags & (IOSQE_IO_LINK|IOSQE_IO_HARDLINK)) {
4917 : 0 : req->flags |= REQ_F_LINK;
4918 [ # # ]: 0 : INIT_LIST_HEAD(&req->link_list);
4919 : :
4920 [ # # # # ]: 0 : if (io_alloc_async_ctx(req)) {
4921 : 0 : ret = -EAGAIN;
4922 : 0 : goto err_req;
4923 : : }
4924 : 0 : ret = io_req_defer_prep(req, sqe);
4925 [ # # ]: 0 : if (ret)
4926 : 0 : req->flags |= REQ_F_FAIL_LINK;
4927 : 0 : *link = req;
4928 : : } else {
4929 : 0 : io_queue_sqe(req, sqe);
4930 : : }
4931 : : }
4932 : :
4933 : : return true;
4934 : : }
4935 : :
4936 : : /*
4937 : : * Batched submission is done, ensure local IO is flushed out.
4938 : : */
4939 : 0 : static void io_submit_state_end(struct io_submit_state *state)
4940 : : {
4941 : 0 : blk_finish_plug(&state->plug);
4942 : 0 : io_file_put(state);
4943 [ # # ]: 0 : if (state->free_reqs)
4944 : 0 : kmem_cache_free_bulk(req_cachep, state->free_reqs, state->reqs);
4945 : 0 : }
4946 : :
4947 : : /*
4948 : : * Start submission side cache.
4949 : : */
4950 : 0 : static void io_submit_state_start(struct io_submit_state *state,
4951 : : unsigned int max_ios)
4952 : : {
4953 : 0 : blk_start_plug(&state->plug);
4954 : 0 : state->free_reqs = 0;
4955 : 0 : state->file = NULL;
4956 : 0 : state->ios_left = max_ios;
4957 : : }
4958 : :
4959 : 0 : static void io_commit_sqring(struct io_ring_ctx *ctx)
4960 : : {
4961 : 0 : struct io_rings *rings = ctx->rings;
4962 : :
4963 : : /*
4964 : : * Ensure any loads from the SQEs are done at this point,
4965 : : * since once we write the new head, the application could
4966 : : * write new data to them.
4967 : : */
4968 : 0 : smp_store_release(&rings->sq.head, ctx->cached_sq_head);
4969 : : }
4970 : :
4971 : : /*
4972 : : * Fetch an sqe, if one is available. Note that sqe_ptr will point to memory
4973 : : * that is mapped by userspace. This means that care needs to be taken to
4974 : : * ensure that reads are stable, as we cannot rely on userspace always
4975 : : * being a good citizen. If members of the sqe are validated and then later
4976 : : * used, it's important that those reads are done through READ_ONCE() to
4977 : : * prevent a re-load down the line.
4978 : : */
4979 : 0 : static bool io_get_sqring(struct io_ring_ctx *ctx, struct io_kiocb *req,
4980 : : const struct io_uring_sqe **sqe_ptr)
4981 : : {
4982 : 0 : u32 *sq_array = ctx->sq_array;
4983 : 0 : unsigned head;
4984 : :
4985 : : /*
4986 : : * The cached sq head (or cq tail) serves two purposes:
4987 : : *
4988 : : * 1) allows us to batch the cost of updating the user visible
4989 : : * head updates.
4990 : : * 2) allows the kernel side to track the head on its own, even
4991 : : * though the application is the one updating it.
4992 : : */
4993 [ # # ]: 0 : head = READ_ONCE(sq_array[ctx->cached_sq_head & ctx->sq_mask]);
4994 [ # # ]: 0 : if (likely(head < ctx->sq_entries)) {
4995 : : /*
4996 : : * All io need record the previous position, if LINK vs DARIN,
4997 : : * it can be used to mark the position of the first IO in the
4998 : : * link list.
4999 : : */
5000 : 0 : req->sequence = ctx->cached_sq_head;
5001 : 0 : *sqe_ptr = &ctx->sq_sqes[head];
5002 : 0 : req->opcode = READ_ONCE((*sqe_ptr)->opcode);
5003 : 0 : req->user_data = READ_ONCE((*sqe_ptr)->user_data);
5004 : 0 : ctx->cached_sq_head++;
5005 : 0 : return true;
5006 : : }
5007 : :
5008 : : /* drop invalid entries */
5009 : 0 : ctx->cached_sq_head++;
5010 : 0 : ctx->cached_sq_dropped++;
5011 : 0 : WRITE_ONCE(ctx->rings->sq_dropped, ctx->cached_sq_dropped);
5012 : 0 : return false;
5013 : : }
5014 : :
5015 : 0 : static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr,
5016 : : struct file *ring_file, int ring_fd,
5017 : : struct mm_struct **mm, bool async)
5018 : : {
5019 : 0 : struct io_submit_state state, *statep = NULL;
5020 : 0 : struct io_kiocb *link = NULL;
5021 : 0 : int i, submitted = 0;
5022 : 0 : bool mm_fault = false;
5023 : :
5024 : : /* if we have a backlog and couldn't flush it all, return BUSY */
5025 [ # # ]: 0 : if (test_bit(0, &ctx->sq_check_overflow)) {
5026 [ # # # # ]: 0 : if (!list_empty(&ctx->cq_overflow_list) &&
5027 : 0 : !io_cqring_overflow_flush(ctx, false))
5028 : : return -EBUSY;
5029 : : }
5030 : :
5031 : : /* make sure SQ entry isn't read before tail */
5032 : 0 : nr = min3(nr, ctx->sq_entries, io_sqring_entries(ctx));
5033 : :
5034 [ # # ]: 0 : if (!percpu_ref_tryget_many(&ctx->refs, nr))
5035 : : return -EAGAIN;
5036 : :
5037 [ # # ]: 0 : if (nr > IO_PLUG_THRESHOLD) {
5038 : 0 : io_submit_state_start(&state, nr);
5039 : 0 : statep = &state;
5040 : : }
5041 : :
5042 : 0 : ctx->ring_fd = ring_fd;
5043 : 0 : ctx->ring_file = ring_file;
5044 : :
5045 [ # # ]: 0 : for (i = 0; i < nr; i++) {
5046 : 0 : const struct io_uring_sqe *sqe;
5047 : 0 : struct io_kiocb *req;
5048 : 0 : int err;
5049 : :
5050 : 0 : req = io_get_req(ctx, statep);
5051 [ # # ]: 0 : if (unlikely(!req)) {
5052 [ # # ]: 0 : if (!submitted)
5053 : 0 : submitted = -EAGAIN;
5054 : 0 : break;
5055 : : }
5056 [ # # ]: 0 : if (!io_get_sqring(ctx, req, &sqe)) {
5057 : 0 : __io_req_do_free(req);
5058 : 0 : break;
5059 : : }
5060 : :
5061 : : /* will complete beyond this point, count as submitted */
5062 : 0 : submitted++;
5063 : :
5064 [ # # ]: 0 : if (unlikely(req->opcode >= IORING_OP_LAST)) {
5065 : : err = -EINVAL;
5066 : 0 : fail_req:
5067 : 0 : io_cqring_add_event(req, err);
5068 : 0 : io_double_put_req(req);
5069 : 0 : break;
5070 : : }
5071 : :
5072 [ # # # # ]: 0 : if (io_op_defs[req->opcode].needs_mm && !*mm) {
5073 [ # # # # ]: 0 : mm_fault = mm_fault || !mmget_not_zero(ctx->sqo_mm);
5074 [ # # ]: 0 : if (unlikely(mm_fault)) {
5075 : 0 : err = -EFAULT;
5076 : 0 : goto fail_req;
5077 : : }
5078 : 0 : use_mm(ctx->sqo_mm);
5079 : 0 : *mm = ctx->sqo_mm;
5080 : : }
5081 : :
5082 : 0 : req->in_async = async;
5083 : 0 : req->needs_fixed_file = async;
5084 : 0 : trace_io_uring_submit_sqe(ctx, req->opcode, req->user_data,
5085 : : true, async);
5086 [ # # ]: 0 : if (!io_submit_sqe(req, sqe, statep, &link))
5087 : : break;
5088 : : }
5089 : :
5090 [ # # ]: 0 : if (unlikely(submitted != nr)) {
5091 [ # # ]: 0 : int ref_used = (submitted == -EAGAIN) ? 0 : submitted;
5092 : :
5093 : 0 : percpu_ref_put_many(&ctx->refs, nr - ref_used);
5094 : : }
5095 [ # # ]: 0 : if (link)
5096 : 0 : io_queue_link_head(link);
5097 [ # # ]: 0 : if (statep)
5098 : 0 : io_submit_state_end(&state);
5099 : :
5100 : : /* Commit SQ ring head once we've consumed and submitted all SQEs */
5101 : 0 : io_commit_sqring(ctx);
5102 : :
5103 : 0 : return submitted;
5104 : : }
5105 : :
5106 : 0 : static int io_sq_thread(void *data)
5107 : : {
5108 : 0 : struct io_ring_ctx *ctx = data;
5109 : 0 : struct mm_struct *cur_mm = NULL;
5110 : 0 : const struct cred *old_cred;
5111 : 0 : mm_segment_t old_fs;
5112 : 0 : DEFINE_WAIT(wait);
5113 : 0 : unsigned long timeout;
5114 : 0 : int ret = 0;
5115 : :
5116 : 0 : complete(&ctx->completions[1]);
5117 : :
5118 [ # # # ]: 0 : old_fs = get_fs();
5119 [ # # # ]: 0 : set_fs(USER_DS);
5120 : 0 : old_cred = override_creds(ctx->creds);
5121 : :
5122 : 0 : timeout = jiffies + ctx->sq_thread_idle;
5123 [ # # ]: 0 : while (!kthread_should_park()) {
5124 : 0 : unsigned int to_submit;
5125 : :
5126 [ # # ]: 0 : if (!list_empty(&ctx->poll_list)) {
5127 : 0 : unsigned nr_events = 0;
5128 : :
5129 : 0 : mutex_lock(&ctx->uring_lock);
5130 [ # # ]: 0 : if (!list_empty(&ctx->poll_list))
5131 : 0 : io_iopoll_getevents(ctx, &nr_events, 0);
5132 : : else
5133 : 0 : timeout = jiffies + ctx->sq_thread_idle;
5134 : 0 : mutex_unlock(&ctx->uring_lock);
5135 : : }
5136 : :
5137 : 0 : to_submit = io_sqring_entries(ctx);
5138 : :
5139 : : /*
5140 : : * If submit got -EBUSY, flag us as needing the application
5141 : : * to enter the kernel to reap and flush events.
5142 : : */
5143 [ # # ]: 0 : if (!to_submit || ret == -EBUSY) {
5144 : : /*
5145 : : * Drop cur_mm before scheduling, we can't hold it for
5146 : : * long periods (or over schedule()). Do this before
5147 : : * adding ourselves to the waitqueue, as the unuse/drop
5148 : : * may sleep.
5149 : : */
5150 [ # # ]: 0 : if (cur_mm) {
5151 : 0 : unuse_mm(cur_mm);
5152 : 0 : mmput(cur_mm);
5153 : 0 : cur_mm = NULL;
5154 : : }
5155 : :
5156 : : /*
5157 : : * We're polling. If we're within the defined idle
5158 : : * period, then let us spin without work before going
5159 : : * to sleep. The exception is if we got EBUSY doing
5160 : : * more IO, we should wait for the application to
5161 : : * reap events and wake us up.
5162 : : */
5163 [ # # ]: 0 : if (!list_empty(&ctx->poll_list) ||
5164 [ # # # # : 0 : (!time_after(jiffies, timeout) && ret != -EBUSY &&
# # ]
5165 [ # # ]: 0 : !percpu_ref_is_dying(&ctx->refs))) {
5166 : 0 : cond_resched();
5167 : 0 : continue;
5168 : : }
5169 : :
5170 : 0 : prepare_to_wait(&ctx->sqo_wait, &wait,
5171 : : TASK_INTERRUPTIBLE);
5172 : :
5173 : : /*
5174 : : * While doing polled IO, before going to sleep, we need
5175 : : * to check if there are new reqs added to poll_list, it
5176 : : * is because reqs may have been punted to io worker and
5177 : : * will be added to poll_list later, hence check the
5178 : : * poll_list again.
5179 : : */
5180 [ # # ]: 0 : if ((ctx->flags & IORING_SETUP_IOPOLL) &&
5181 : : !list_empty_careful(&ctx->poll_list)) {
5182 : 0 : finish_wait(&ctx->sqo_wait, &wait);
5183 : 0 : continue;
5184 : : }
5185 : :
5186 : : /* Tell userspace we may need a wakeup call */
5187 : 0 : ctx->rings->sq_flags |= IORING_SQ_NEED_WAKEUP;
5188 : : /* make sure to read SQ tail after writing flags */
5189 : 0 : smp_mb();
5190 : :
5191 : 0 : to_submit = io_sqring_entries(ctx);
5192 [ # # ]: 0 : if (!to_submit || ret == -EBUSY) {
5193 [ # # ]: 0 : if (kthread_should_park()) {
5194 : 0 : finish_wait(&ctx->sqo_wait, &wait);
5195 : 0 : break;
5196 : : }
5197 [ # # ]: 0 : if (signal_pending(current))
5198 : 0 : flush_signals(current);
5199 : 0 : schedule();
5200 : 0 : finish_wait(&ctx->sqo_wait, &wait);
5201 : :
5202 : 0 : ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
5203 : 0 : continue;
5204 : : }
5205 : 0 : finish_wait(&ctx->sqo_wait, &wait);
5206 : :
5207 : 0 : ctx->rings->sq_flags &= ~IORING_SQ_NEED_WAKEUP;
5208 : : }
5209 : :
5210 : 0 : mutex_lock(&ctx->uring_lock);
5211 : 0 : ret = io_submit_sqes(ctx, to_submit, NULL, -1, &cur_mm, true);
5212 : 0 : mutex_unlock(&ctx->uring_lock);
5213 : 0 : timeout = jiffies + ctx->sq_thread_idle;
5214 : : }
5215 : :
5216 : 0 : set_fs(old_fs);
5217 [ # # ]: 0 : if (cur_mm) {
5218 : 0 : unuse_mm(cur_mm);
5219 : 0 : mmput(cur_mm);
5220 : : }
5221 : 0 : revert_creds(old_cred);
5222 : :
5223 : 0 : kthread_parkme();
5224 : :
5225 : 0 : return 0;
5226 : : }
5227 : :
5228 : : struct io_wait_queue {
5229 : : struct wait_queue_entry wq;
5230 : : struct io_ring_ctx *ctx;
5231 : : unsigned to_wait;
5232 : : unsigned nr_timeouts;
5233 : : };
5234 : :
5235 : 0 : static inline bool io_should_wake(struct io_wait_queue *iowq, bool noflush)
5236 : : {
5237 : 0 : struct io_ring_ctx *ctx = iowq->ctx;
5238 : :
5239 : : /*
5240 : : * Wake up if we have enough events, or if a timeout occurred since we
5241 : : * started waiting. For timeouts, we always want to return to userspace,
5242 : : * regardless of event count.
5243 : : */
5244 [ # # ]: 0 : return io_cqring_events(ctx, noflush) >= iowq->to_wait ||
5245 [ # # ]: 0 : atomic_read(&ctx->cq_timeouts) != iowq->nr_timeouts;
5246 : : }
5247 : :
5248 : 0 : static int io_wake_function(struct wait_queue_entry *curr, unsigned int mode,
5249 : : int wake_flags, void *key)
5250 : : {
5251 : 0 : struct io_wait_queue *iowq = container_of(curr, struct io_wait_queue,
5252 : : wq);
5253 : :
5254 : : /* use noflush == true, as we can't safely rely on locking context */
5255 [ # # ]: 0 : if (!io_should_wake(iowq, true))
5256 : : return -1;
5257 : :
5258 : 0 : return autoremove_wake_function(curr, mode, wake_flags, key);
5259 : : }
5260 : :
5261 : : /*
5262 : : * Wait until events become available, if we don't already have some. The
5263 : : * application must reap them itself, as they reside on the shared cq ring.
5264 : : */
5265 : 0 : static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
5266 : : const sigset_t __user *sig, size_t sigsz)
5267 : : {
5268 : 0 : struct io_wait_queue iowq = {
5269 : : .wq = {
5270 : : .private = current,
5271 : : .func = io_wake_function,
5272 : : .entry = LIST_HEAD_INIT(iowq.wq.entry),
5273 : : },
5274 : : .ctx = ctx,
5275 : : .to_wait = min_events,
5276 : : };
5277 : 0 : struct io_rings *rings = ctx->rings;
5278 : 0 : int ret = 0;
5279 : :
5280 [ # # ]: 0 : if (io_cqring_events(ctx, false) >= min_events)
5281 : : return 0;
5282 : :
5283 [ # # ]: 0 : if (sig) {
5284 : : #ifdef CONFIG_COMPAT
5285 [ # # # # ]: 0 : if (in_compat_syscall())
5286 : 0 : ret = set_compat_user_sigmask((const compat_sigset_t __user *)sig,
5287 : : sigsz);
5288 : : else
5289 : : #endif
5290 : 0 : ret = set_user_sigmask(sig, sigsz);
5291 : :
5292 [ # # ]: 0 : if (ret)
5293 : : return ret;
5294 : : }
5295 : :
5296 : 0 : iowq.nr_timeouts = atomic_read(&ctx->cq_timeouts);
5297 : 0 : trace_io_uring_cqring_wait(ctx, min_events);
5298 : 0 : do {
5299 : 0 : prepare_to_wait_exclusive(&ctx->wait, &iowq.wq,
5300 : : TASK_INTERRUPTIBLE);
5301 [ # # ]: 0 : if (io_should_wake(&iowq, false))
5302 : : break;
5303 : 0 : schedule();
5304 [ # # ]: 0 : if (signal_pending(current)) {
5305 : : ret = -EINTR;
5306 : : break;
5307 : : }
5308 : : } while (1);
5309 : 0 : finish_wait(&ctx->wait, &iowq.wq);
5310 : :
5311 : 0 : restore_saved_sigmask_unless(ret == -EINTR);
5312 : :
5313 [ # # ]: 0 : return READ_ONCE(rings->cq.head) == READ_ONCE(rings->cq.tail) ? ret : 0;
5314 : : }
5315 : :
5316 : : static void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
5317 : : {
5318 : : #if defined(CONFIG_UNIX)
5319 : : if (ctx->ring_sock) {
5320 : : struct sock *sock = ctx->ring_sock->sk;
5321 : : struct sk_buff *skb;
5322 : :
5323 : : while ((skb = skb_dequeue(&sock->sk_receive_queue)) != NULL)
5324 : : kfree_skb(skb);
5325 : : }
5326 : : #else
5327 : : int i;
5328 : :
5329 : : for (i = 0; i < ctx->nr_user_files; i++) {
5330 : : struct file *file;
5331 : :
5332 : : file = io_file_from_index(ctx, i);
5333 : : if (file)
5334 : : fput(file);
5335 : : }
5336 : : #endif
5337 : : }
5338 : :
5339 : 0 : static void io_file_ref_kill(struct percpu_ref *ref)
5340 : : {
5341 : 0 : struct fixed_file_data *data;
5342 : :
5343 : 0 : data = container_of(ref, struct fixed_file_data, refs);
5344 : 0 : complete(&data->done);
5345 : 0 : }
5346 : :
5347 : 0 : static void io_file_ref_exit_and_free(struct work_struct *work)
5348 : : {
5349 : 0 : struct fixed_file_data *data;
5350 : :
5351 : 0 : data = container_of(work, struct fixed_file_data, ref_work);
5352 : :
5353 : : /*
5354 : : * Ensure any percpu-ref atomic switch callback has run, it could have
5355 : : * been in progress when the files were being unregistered. Once
5356 : : * that's done, we can safely exit and free the ref and containing
5357 : : * data structure.
5358 : : */
5359 : 0 : rcu_barrier();
5360 : 0 : percpu_ref_exit(&data->refs);
5361 : 0 : kfree(data);
5362 : 0 : }
5363 : :
5364 : 0 : static int io_sqe_files_unregister(struct io_ring_ctx *ctx)
5365 : : {
5366 : 0 : struct fixed_file_data *data = ctx->file_data;
5367 : 0 : unsigned nr_tables, i;
5368 : :
5369 [ # # ]: 0 : if (!data)
5370 : : return -ENXIO;
5371 : :
5372 : 0 : percpu_ref_kill_and_confirm(&data->refs, io_file_ref_kill);
5373 : 0 : flush_work(&data->ref_work);
5374 : 0 : wait_for_completion(&data->done);
5375 : 0 : io_ring_file_ref_flush(data);
5376 : :
5377 : 0 : __io_sqe_files_unregister(ctx);
5378 : 0 : nr_tables = DIV_ROUND_UP(ctx->nr_user_files, IORING_MAX_FILES_TABLE);
5379 [ # # ]: 0 : for (i = 0; i < nr_tables; i++)
5380 : 0 : kfree(data->table[i].files);
5381 : 0 : kfree(data->table);
5382 : 0 : INIT_WORK(&data->ref_work, io_file_ref_exit_and_free);
5383 : 0 : queue_work(system_wq, &data->ref_work);
5384 : 0 : ctx->file_data = NULL;
5385 : 0 : ctx->nr_user_files = 0;
5386 : 0 : return 0;
5387 : : }
5388 : :
5389 : : static void io_sq_thread_stop(struct io_ring_ctx *ctx)
5390 : : {
5391 : : if (ctx->sqo_thread) {
5392 : : wait_for_completion(&ctx->completions[1]);
5393 : : /*
5394 : : * The park is a bit of a work-around, without it we get
5395 : : * warning spews on shutdown with SQPOLL set and affinity
5396 : : * set to a single CPU.
5397 : : */
5398 : : kthread_park(ctx->sqo_thread);
5399 : : kthread_stop(ctx->sqo_thread);
5400 : : ctx->sqo_thread = NULL;
5401 : : }
5402 : : }
5403 : :
5404 : 0 : static void io_finish_async(struct io_ring_ctx *ctx)
5405 : : {
5406 : 0 : io_sq_thread_stop(ctx);
5407 : :
5408 [ # # ]: 0 : if (ctx->io_wq) {
5409 : 0 : io_wq_destroy(ctx->io_wq);
5410 : 0 : ctx->io_wq = NULL;
5411 : : }
5412 : 0 : }
5413 : :
5414 : : #if defined(CONFIG_UNIX)
5415 : : /*
5416 : : * Ensure the UNIX gc is aware of our file set, so we are certain that
5417 : : * the io_uring can be safely unregistered on process exit, even if we have
5418 : : * loops in the file referencing.
5419 : : */
5420 : 0 : static int __io_sqe_files_scm(struct io_ring_ctx *ctx, int nr, int offset)
5421 : : {
5422 : 0 : struct sock *sk = ctx->ring_sock->sk;
5423 : 0 : struct scm_fp_list *fpl;
5424 : 0 : struct sk_buff *skb;
5425 : 0 : int i, nr_files;
5426 : :
5427 [ # # # # ]: 0 : if (!capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) {
5428 : 0 : unsigned long inflight = ctx->user->unix_inflight + nr;
5429 : :
5430 [ # # ]: 0 : if (inflight > task_rlimit(current, RLIMIT_NOFILE))
5431 : : return -EMFILE;
5432 : : }
5433 : :
5434 : 0 : fpl = kzalloc(sizeof(*fpl), GFP_KERNEL);
5435 [ # # ]: 0 : if (!fpl)
5436 : : return -ENOMEM;
5437 : :
5438 : 0 : skb = alloc_skb(0, GFP_KERNEL);
5439 [ # # ]: 0 : if (!skb) {
5440 : 0 : kfree(fpl);
5441 : 0 : return -ENOMEM;
5442 : : }
5443 : :
5444 : 0 : skb->sk = sk;
5445 : :
5446 : 0 : nr_files = 0;
5447 : 0 : fpl->user = get_uid(ctx->user);
5448 [ # # ]: 0 : for (i = 0; i < nr; i++) {
5449 : 0 : struct file *file = io_file_from_index(ctx, i + offset);
5450 : :
5451 [ # # ]: 0 : if (!file)
5452 : 0 : continue;
5453 : 0 : fpl->fp[nr_files] = get_file(file);
5454 : 0 : unix_inflight(fpl->user, fpl->fp[nr_files]);
5455 : 0 : nr_files++;
5456 : : }
5457 : :
5458 [ # # ]: 0 : if (nr_files) {
5459 : 0 : fpl->max = SCM_MAX_FD;
5460 : 0 : fpl->count = nr_files;
5461 : 0 : UNIXCB(skb).fp = fpl;
5462 : 0 : skb->destructor = unix_destruct_scm;
5463 : 0 : refcount_add(skb->truesize, &sk->sk_wmem_alloc);
5464 : 0 : skb_queue_head(&sk->sk_receive_queue, skb);
5465 : :
5466 [ # # ]: 0 : for (i = 0; i < nr_files; i++)
5467 : 0 : fput(fpl->fp[i]);
5468 : : } else {
5469 : 0 : kfree_skb(skb);
5470 : 0 : kfree(fpl);
5471 : : }
5472 : :
5473 : : return 0;
5474 : : }
5475 : :
5476 : : /*
5477 : : * If UNIX sockets are enabled, fd passing can cause a reference cycle which
5478 : : * causes regular reference counting to break down. We rely on the UNIX
5479 : : * garbage collection to take care of this problem for us.
5480 : : */
5481 : 0 : static int io_sqe_files_scm(struct io_ring_ctx *ctx)
5482 : : {
5483 : 0 : unsigned left, total;
5484 : 0 : int ret = 0;
5485 : :
5486 : 0 : total = 0;
5487 : 0 : left = ctx->nr_user_files;
5488 [ # # ]: 0 : while (left) {
5489 : 0 : unsigned this_files = min_t(unsigned, left, SCM_MAX_FD);
5490 : :
5491 : 0 : ret = __io_sqe_files_scm(ctx, this_files, total);
5492 [ # # ]: 0 : if (ret)
5493 : : break;
5494 : 0 : left -= this_files;
5495 : 0 : total += this_files;
5496 : : }
5497 : :
5498 [ # # ]: 0 : if (!ret)
5499 : : return 0;
5500 : :
5501 [ # # ]: 0 : while (total < ctx->nr_user_files) {
5502 : 0 : struct file *file = io_file_from_index(ctx, total);
5503 : :
5504 [ # # ]: 0 : if (file)
5505 : 0 : fput(file);
5506 : 0 : total++;
5507 : : }
5508 : :
5509 : : return ret;
5510 : : }
5511 : : #else
5512 : : static int io_sqe_files_scm(struct io_ring_ctx *ctx)
5513 : : {
5514 : : return 0;
5515 : : }
5516 : : #endif
5517 : :
5518 : : static int io_sqe_alloc_file_tables(struct io_ring_ctx *ctx, unsigned nr_tables,
5519 : : unsigned nr_files)
5520 : : {
5521 : : int i;
5522 : :
5523 : : for (i = 0; i < nr_tables; i++) {
5524 : : struct fixed_file_table *table = &ctx->file_data->table[i];
5525 : : unsigned this_files;
5526 : :
5527 : : this_files = min(nr_files, IORING_MAX_FILES_TABLE);
5528 : : table->files = kcalloc(this_files, sizeof(struct file *),
5529 : : GFP_KERNEL);
5530 : : if (!table->files)
5531 : : break;
5532 : : nr_files -= this_files;
5533 : : }
5534 : :
5535 : : if (i == nr_tables)
5536 : : return 0;
5537 : :
5538 : : for (i = 0; i < nr_tables; i++) {
5539 : : struct fixed_file_table *table = &ctx->file_data->table[i];
5540 : : kfree(table->files);
5541 : : }
5542 : : return 1;
5543 : : }
5544 : :
5545 : : static void io_ring_file_put(struct io_ring_ctx *ctx, struct file *file)
5546 : : {
5547 : : #if defined(CONFIG_UNIX)
5548 : : struct sock *sock = ctx->ring_sock->sk;
5549 : : struct sk_buff_head list, *head = &sock->sk_receive_queue;
5550 : : struct sk_buff *skb;
5551 : : int i;
5552 : :
5553 : : __skb_queue_head_init(&list);
5554 : :
5555 : : /*
5556 : : * Find the skb that holds this file in its SCM_RIGHTS. When found,
5557 : : * remove this entry and rearrange the file array.
5558 : : */
5559 : : skb = skb_dequeue(head);
5560 : : while (skb) {
5561 : : struct scm_fp_list *fp;
5562 : :
5563 : : fp = UNIXCB(skb).fp;
5564 : : for (i = 0; i < fp->count; i++) {
5565 : : int left;
5566 : :
5567 : : if (fp->fp[i] != file)
5568 : : continue;
5569 : :
5570 : : unix_notinflight(fp->user, fp->fp[i]);
5571 : : left = fp->count - 1 - i;
5572 : : if (left) {
5573 : : memmove(&fp->fp[i], &fp->fp[i + 1],
5574 : : left * sizeof(struct file *));
5575 : : }
5576 : : fp->count--;
5577 : : if (!fp->count) {
5578 : : kfree_skb(skb);
5579 : : skb = NULL;
5580 : : } else {
5581 : : __skb_queue_tail(&list, skb);
5582 : : }
5583 : : fput(file);
5584 : : file = NULL;
5585 : : break;
5586 : : }
5587 : :
5588 : : if (!file)
5589 : : break;
5590 : :
5591 : : __skb_queue_tail(&list, skb);
5592 : :
5593 : : skb = skb_dequeue(head);
5594 : : }
5595 : :
5596 : : if (skb_peek(&list)) {
5597 : : spin_lock_irq(&head->lock);
5598 : : while ((skb = __skb_dequeue(&list)) != NULL)
5599 : : __skb_queue_tail(head, skb);
5600 : : spin_unlock_irq(&head->lock);
5601 : : }
5602 : : #else
5603 : : fput(file);
5604 : : #endif
5605 : : }
5606 : :
5607 : : struct io_file_put {
5608 : : struct llist_node llist;
5609 : : struct file *file;
5610 : : struct completion *done;
5611 : : };
5612 : :
5613 : 0 : static void io_ring_file_ref_flush(struct fixed_file_data *data)
5614 : : {
5615 : 0 : struct io_file_put *pfile, *tmp;
5616 : 0 : struct llist_node *node;
5617 : :
5618 [ # # ]: 0 : while ((node = llist_del_all(&data->put_llist)) != NULL) {
5619 [ # # ]: 0 : llist_for_each_entry_safe(pfile, tmp, node, llist) {
5620 : 0 : io_ring_file_put(data->ctx, pfile->file);
5621 [ # # ]: 0 : if (pfile->done)
5622 : 0 : complete(pfile->done);
5623 : : else
5624 : 0 : kfree(pfile);
5625 : : }
5626 : : }
5627 : 0 : }
5628 : :
5629 : 0 : static void io_ring_file_ref_switch(struct work_struct *work)
5630 : : {
5631 : 0 : struct fixed_file_data *data;
5632 : :
5633 : 0 : data = container_of(work, struct fixed_file_data, ref_work);
5634 : 0 : io_ring_file_ref_flush(data);
5635 : 0 : percpu_ref_switch_to_percpu(&data->refs);
5636 : 0 : }
5637 : :
5638 : 0 : static void io_file_data_ref_zero(struct percpu_ref *ref)
5639 : : {
5640 : 0 : struct fixed_file_data *data;
5641 : :
5642 : 0 : data = container_of(ref, struct fixed_file_data, refs);
5643 : :
5644 : : /*
5645 : : * We can't safely switch from inside this context, punt to wq. If
5646 : : * the table ref is going away, the table is being unregistered.
5647 : : * Don't queue up the async work for that case, the caller will
5648 : : * handle it.
5649 : : */
5650 [ # # ]: 0 : if (!percpu_ref_is_dying(&data->refs))
5651 : 0 : queue_work(system_wq, &data->ref_work);
5652 : 0 : }
5653 : :
5654 : 0 : static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
5655 : : unsigned nr_args)
5656 : : {
5657 : 0 : __s32 __user *fds = (__s32 __user *) arg;
5658 : 0 : unsigned nr_tables;
5659 : 0 : struct file *file;
5660 : 0 : int fd, ret = 0;
5661 : 0 : unsigned i;
5662 : :
5663 [ # # ]: 0 : if (ctx->file_data)
5664 : : return -EBUSY;
5665 [ # # ]: 0 : if (!nr_args)
5666 : : return -EINVAL;
5667 [ # # ]: 0 : if (nr_args > IORING_MAX_FIXED_FILES)
5668 : : return -EMFILE;
5669 : :
5670 : 0 : ctx->file_data = kzalloc(sizeof(*ctx->file_data), GFP_KERNEL);
5671 [ # # ]: 0 : if (!ctx->file_data)
5672 : : return -ENOMEM;
5673 : 0 : ctx->file_data->ctx = ctx;
5674 : 0 : init_completion(&ctx->file_data->done);
5675 : :
5676 : 0 : nr_tables = DIV_ROUND_UP(nr_args, IORING_MAX_FILES_TABLE);
5677 : 0 : ctx->file_data->table = kcalloc(nr_tables,
5678 : : sizeof(struct fixed_file_table),
5679 : : GFP_KERNEL);
5680 [ # # ]: 0 : if (!ctx->file_data->table) {
5681 : 0 : kfree(ctx->file_data);
5682 : 0 : ctx->file_data = NULL;
5683 : 0 : return -ENOMEM;
5684 : : }
5685 : :
5686 [ # # ]: 0 : if (percpu_ref_init(&ctx->file_data->refs, io_file_data_ref_zero,
5687 : : PERCPU_REF_ALLOW_REINIT, GFP_KERNEL)) {
5688 : 0 : kfree(ctx->file_data->table);
5689 : 0 : kfree(ctx->file_data);
5690 : 0 : ctx->file_data = NULL;
5691 : 0 : return -ENOMEM;
5692 : : }
5693 : 0 : ctx->file_data->put_llist.first = NULL;
5694 : 0 : INIT_WORK(&ctx->file_data->ref_work, io_ring_file_ref_switch);
5695 : :
5696 [ # # ]: 0 : if (io_sqe_alloc_file_tables(ctx, nr_tables, nr_args)) {
5697 : 0 : percpu_ref_exit(&ctx->file_data->refs);
5698 : 0 : kfree(ctx->file_data->table);
5699 : 0 : kfree(ctx->file_data);
5700 : 0 : ctx->file_data = NULL;
5701 : 0 : return -ENOMEM;
5702 : : }
5703 : :
5704 [ # # ]: 0 : for (i = 0; i < nr_args; i++, ctx->nr_user_files++) {
5705 : 0 : struct fixed_file_table *table;
5706 : 0 : unsigned index;
5707 : :
5708 : 0 : ret = -EFAULT;
5709 [ # # ]: 0 : if (copy_from_user(&fd, &fds[i], sizeof(fd)))
5710 : : break;
5711 : : /* allow sparse sets */
5712 [ # # ]: 0 : if (fd == -1) {
5713 : 0 : ret = 0;
5714 : 0 : continue;
5715 : : }
5716 : :
5717 : 0 : table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
5718 : 0 : index = i & IORING_FILE_TABLE_MASK;
5719 : 0 : file = fget(fd);
5720 : :
5721 : 0 : ret = -EBADF;
5722 [ # # ]: 0 : if (!file)
5723 : : break;
5724 : :
5725 : : /*
5726 : : * Don't allow io_uring instances to be registered. If UNIX
5727 : : * isn't enabled, then this causes a reference cycle and this
5728 : : * instance can never get freed. If UNIX is enabled we'll
5729 : : * handle it just fine, but there's still no point in allowing
5730 : : * a ring fd as it doesn't support regular read/write anyway.
5731 : : */
5732 [ # # ]: 0 : if (file->f_op == &io_uring_fops) {
5733 : 0 : fput(file);
5734 : 0 : break;
5735 : : }
5736 : 0 : ret = 0;
5737 : 0 : table->files[index] = file;
5738 : : }
5739 : :
5740 [ # # ]: 0 : if (ret) {
5741 [ # # ]: 0 : for (i = 0; i < ctx->nr_user_files; i++) {
5742 : 0 : file = io_file_from_index(ctx, i);
5743 [ # # ]: 0 : if (file)
5744 : 0 : fput(file);
5745 : : }
5746 [ # # ]: 0 : for (i = 0; i < nr_tables; i++)
5747 : 0 : kfree(ctx->file_data->table[i].files);
5748 : :
5749 : 0 : kfree(ctx->file_data->table);
5750 : 0 : kfree(ctx->file_data);
5751 : 0 : ctx->file_data = NULL;
5752 : 0 : ctx->nr_user_files = 0;
5753 : 0 : return ret;
5754 : : }
5755 : :
5756 : 0 : ret = io_sqe_files_scm(ctx);
5757 [ # # ]: 0 : if (ret)
5758 : 0 : io_sqe_files_unregister(ctx);
5759 : :
5760 : : return ret;
5761 : : }
5762 : :
5763 : 0 : static int io_sqe_file_register(struct io_ring_ctx *ctx, struct file *file,
5764 : : int index)
5765 : : {
5766 : : #if defined(CONFIG_UNIX)
5767 : 0 : struct sock *sock = ctx->ring_sock->sk;
5768 : 0 : struct sk_buff_head *head = &sock->sk_receive_queue;
5769 : 0 : struct sk_buff *skb;
5770 : :
5771 : : /*
5772 : : * See if we can merge this file into an existing skb SCM_RIGHTS
5773 : : * file set. If there's no room, fall back to allocating a new skb
5774 : : * and filling it in.
5775 : : */
5776 : 0 : spin_lock_irq(&head->lock);
5777 [ # # ]: 0 : skb = skb_peek(head);
5778 [ # # ]: 0 : if (skb) {
5779 : 0 : struct scm_fp_list *fpl = UNIXCB(skb).fp;
5780 : :
5781 [ # # ]: 0 : if (fpl->count < SCM_MAX_FD) {
5782 : 0 : __skb_unlink(skb, head);
5783 : 0 : spin_unlock_irq(&head->lock);
5784 : 0 : fpl->fp[fpl->count] = get_file(file);
5785 : 0 : unix_inflight(fpl->user, fpl->fp[fpl->count]);
5786 : 0 : fpl->count++;
5787 : 0 : spin_lock_irq(&head->lock);
5788 : 0 : __skb_queue_head(head, skb);
5789 : : } else {
5790 : : skb = NULL;
5791 : : }
5792 : : }
5793 : 0 : spin_unlock_irq(&head->lock);
5794 : :
5795 [ # # ]: 0 : if (skb) {
5796 : 0 : fput(file);
5797 : 0 : return 0;
5798 : : }
5799 : :
5800 : 0 : return __io_sqe_files_scm(ctx, 1, index);
5801 : : #else
5802 : : return 0;
5803 : : #endif
5804 : : }
5805 : :
5806 : 0 : static void io_atomic_switch(struct percpu_ref *ref)
5807 : : {
5808 : 0 : struct fixed_file_data *data;
5809 : :
5810 : : /*
5811 : : * Juggle reference to ensure we hit zero, if needed, so we can
5812 : : * switch back to percpu mode
5813 : : */
5814 : 0 : data = container_of(ref, struct fixed_file_data, refs);
5815 : 0 : percpu_ref_put(&data->refs);
5816 : 0 : percpu_ref_get(&data->refs);
5817 : 0 : }
5818 : :
5819 : 0 : static bool io_queue_file_removal(struct fixed_file_data *data,
5820 : : struct file *file)
5821 : : {
5822 : 0 : struct io_file_put *pfile, pfile_stack;
5823 : 0 : DECLARE_COMPLETION_ONSTACK(done);
5824 : :
5825 : : /*
5826 : : * If we fail allocating the struct we need for doing async reomval
5827 : : * of this file, just punt to sync and wait for it.
5828 : : */
5829 : 0 : pfile = kzalloc(sizeof(*pfile), GFP_KERNEL);
5830 [ # # ]: 0 : if (!pfile) {
5831 : 0 : pfile = &pfile_stack;
5832 : 0 : pfile->done = &done;
5833 : : }
5834 : :
5835 : 0 : pfile->file = file;
5836 : 0 : llist_add(&pfile->llist, &data->put_llist);
5837 : :
5838 [ # # ]: 0 : if (pfile == &pfile_stack) {
5839 : 0 : percpu_ref_switch_to_atomic(&data->refs, io_atomic_switch);
5840 : 0 : wait_for_completion(&done);
5841 : 0 : flush_work(&data->ref_work);
5842 : 0 : return false;
5843 : : }
5844 : :
5845 : : return true;
5846 : : }
5847 : :
5848 : : static int __io_sqe_files_update(struct io_ring_ctx *ctx,
5849 : : struct io_uring_files_update *up,
5850 : : unsigned nr_args)
5851 : : {
5852 : : struct fixed_file_data *data = ctx->file_data;
5853 : : bool ref_switch = false;
5854 : : struct file *file;
5855 : : __s32 __user *fds;
5856 : : int fd, i, err;
5857 : : __u32 done;
5858 : :
5859 : : if (check_add_overflow(up->offset, nr_args, &done))
5860 : : return -EOVERFLOW;
5861 : : if (done > ctx->nr_user_files)
5862 : : return -EINVAL;
5863 : :
5864 : : done = 0;
5865 : : fds = u64_to_user_ptr(up->fds);
5866 : : while (nr_args) {
5867 : : struct fixed_file_table *table;
5868 : : unsigned index;
5869 : :
5870 : : err = 0;
5871 : : if (copy_from_user(&fd, &fds[done], sizeof(fd))) {
5872 : : err = -EFAULT;
5873 : : break;
5874 : : }
5875 : : i = array_index_nospec(up->offset, ctx->nr_user_files);
5876 : : table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
5877 : : index = i & IORING_FILE_TABLE_MASK;
5878 : : if (table->files[index]) {
5879 : : file = io_file_from_index(ctx, index);
5880 : : table->files[index] = NULL;
5881 : : if (io_queue_file_removal(data, file))
5882 : : ref_switch = true;
5883 : : }
5884 : : if (fd != -1) {
5885 : : file = fget(fd);
5886 : : if (!file) {
5887 : : err = -EBADF;
5888 : : break;
5889 : : }
5890 : : /*
5891 : : * Don't allow io_uring instances to be registered. If
5892 : : * UNIX isn't enabled, then this causes a reference
5893 : : * cycle and this instance can never get freed. If UNIX
5894 : : * is enabled we'll handle it just fine, but there's
5895 : : * still no point in allowing a ring fd as it doesn't
5896 : : * support regular read/write anyway.
5897 : : */
5898 : : if (file->f_op == &io_uring_fops) {
5899 : : fput(file);
5900 : : err = -EBADF;
5901 : : break;
5902 : : }
5903 : : table->files[index] = file;
5904 : : err = io_sqe_file_register(ctx, file, i);
5905 : : if (err)
5906 : : break;
5907 : : }
5908 : : nr_args--;
5909 : : done++;
5910 : : up->offset++;
5911 : : }
5912 : :
5913 : : if (ref_switch)
5914 : : percpu_ref_switch_to_atomic(&data->refs, io_atomic_switch);
5915 : :
5916 : : return done ? done : err;
5917 : : }
5918 : 0 : static int io_sqe_files_update(struct io_ring_ctx *ctx, void __user *arg,
5919 : : unsigned nr_args)
5920 : : {
5921 : 0 : struct io_uring_files_update up;
5922 : :
5923 [ # # ]: 0 : if (!ctx->file_data)
5924 : : return -ENXIO;
5925 [ # # ]: 0 : if (!nr_args)
5926 : : return -EINVAL;
5927 [ # # ]: 0 : if (copy_from_user(&up, arg, sizeof(up)))
5928 : : return -EFAULT;
5929 [ # # ]: 0 : if (up.resv)
5930 : : return -EINVAL;
5931 : :
5932 : 0 : return __io_sqe_files_update(ctx, &up, nr_args);
5933 : : }
5934 : :
5935 : 0 : static void io_put_work(struct io_wq_work *work)
5936 : : {
5937 : 0 : struct io_kiocb *req = container_of(work, struct io_kiocb, work);
5938 : :
5939 : 0 : io_put_req(req);
5940 : 0 : }
5941 : :
5942 : 0 : static void io_get_work(struct io_wq_work *work)
5943 : : {
5944 : 0 : struct io_kiocb *req = container_of(work, struct io_kiocb, work);
5945 : :
5946 : 0 : refcount_inc(&req->refs);
5947 : 0 : }
5948 : :
5949 : : static int io_init_wq_offload(struct io_ring_ctx *ctx,
5950 : : struct io_uring_params *p)
5951 : : {
5952 : : struct io_wq_data data;
5953 : : struct fd f;
5954 : : struct io_ring_ctx *ctx_attach;
5955 : : unsigned int concurrency;
5956 : : int ret = 0;
5957 : :
5958 : : data.user = ctx->user;
5959 : : data.get_work = io_get_work;
5960 : : data.put_work = io_put_work;
5961 : :
5962 : : if (!(p->flags & IORING_SETUP_ATTACH_WQ)) {
5963 : : /* Do QD, or 4 * CPUS, whatever is smallest */
5964 : : concurrency = min(ctx->sq_entries, 4 * num_online_cpus());
5965 : :
5966 : : ctx->io_wq = io_wq_create(concurrency, &data);
5967 : : if (IS_ERR(ctx->io_wq)) {
5968 : : ret = PTR_ERR(ctx->io_wq);
5969 : : ctx->io_wq = NULL;
5970 : : }
5971 : : return ret;
5972 : : }
5973 : :
5974 : : f = fdget(p->wq_fd);
5975 : : if (!f.file)
5976 : : return -EBADF;
5977 : :
5978 : : if (f.file->f_op != &io_uring_fops) {
5979 : : ret = -EINVAL;
5980 : : goto out_fput;
5981 : : }
5982 : :
5983 : : ctx_attach = f.file->private_data;
5984 : : /* @io_wq is protected by holding the fd */
5985 : : if (!io_wq_get(ctx_attach->io_wq, &data)) {
5986 : : ret = -EINVAL;
5987 : : goto out_fput;
5988 : : }
5989 : :
5990 : : ctx->io_wq = ctx_attach->io_wq;
5991 : : out_fput:
5992 : : fdput(f);
5993 : : return ret;
5994 : : }
5995 : :
5996 : 0 : static int io_sq_offload_start(struct io_ring_ctx *ctx,
5997 : : struct io_uring_params *p)
5998 : : {
5999 : 0 : int ret;
6000 : :
6001 : 0 : init_waitqueue_head(&ctx->sqo_wait);
6002 : 0 : mmgrab(current->mm);
6003 [ # # ]: 0 : ctx->sqo_mm = current->mm;
6004 : :
6005 [ # # ]: 0 : if (ctx->flags & IORING_SETUP_SQPOLL) {
6006 : 0 : ret = -EPERM;
6007 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
6008 : 0 : goto err;
6009 : :
6010 [ # # ]: 0 : ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
6011 [ # # ]: 0 : if (!ctx->sq_thread_idle)
6012 : 0 : ctx->sq_thread_idle = HZ;
6013 : :
6014 [ # # ]: 0 : if (p->flags & IORING_SETUP_SQ_AFF) {
6015 : 0 : int cpu = p->sq_thread_cpu;
6016 : :
6017 : 0 : ret = -EINVAL;
6018 [ # # ]: 0 : if (cpu >= nr_cpu_ids)
6019 : 0 : goto err;
6020 [ # # ]: 0 : if (!cpu_online(cpu))
6021 : 0 : goto err;
6022 : :
6023 : 0 : ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
6024 : : ctx, cpu,
6025 : : "io_uring-sq");
6026 : : } else {
6027 : 0 : ctx->sqo_thread = kthread_create(io_sq_thread, ctx,
6028 : : "io_uring-sq");
6029 : : }
6030 [ # # ]: 0 : if (IS_ERR(ctx->sqo_thread)) {
6031 : 0 : ret = PTR_ERR(ctx->sqo_thread);
6032 : 0 : ctx->sqo_thread = NULL;
6033 : 0 : goto err;
6034 : : }
6035 : 0 : wake_up_process(ctx->sqo_thread);
6036 [ # # ]: 0 : } else if (p->flags & IORING_SETUP_SQ_AFF) {
6037 : : /* Can't have SQ_AFF without SQPOLL */
6038 : 0 : ret = -EINVAL;
6039 : 0 : goto err;
6040 : : }
6041 : :
6042 : 0 : ret = io_init_wq_offload(ctx, p);
6043 [ # # ]: 0 : if (ret)
6044 : 0 : goto err;
6045 : :
6046 : : return 0;
6047 : 0 : err:
6048 : 0 : io_finish_async(ctx);
6049 : 0 : mmdrop(ctx->sqo_mm);
6050 : 0 : ctx->sqo_mm = NULL;
6051 : 0 : return ret;
6052 : : }
6053 : :
6054 : 0 : static void io_unaccount_mem(struct user_struct *user, unsigned long nr_pages)
6055 : : {
6056 : 0 : atomic_long_sub(nr_pages, &user->locked_vm);
6057 : 0 : }
6058 : :
6059 : 0 : static int io_account_mem(struct user_struct *user, unsigned long nr_pages)
6060 : : {
6061 : 0 : unsigned long page_limit, cur_pages, new_pages;
6062 : :
6063 : : /* Don't allow more pages than we can safely lock */
6064 : 0 : page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
6065 : :
6066 : 0 : do {
6067 : 0 : cur_pages = atomic_long_read(&user->locked_vm);
6068 : 0 : new_pages = cur_pages + nr_pages;
6069 [ # # ]: 0 : if (new_pages > page_limit)
6070 : : return -ENOMEM;
6071 : 0 : } while (atomic_long_cmpxchg(&user->locked_vm, cur_pages,
6072 [ # # ]: 0 : new_pages) != cur_pages);
6073 : :
6074 : : return 0;
6075 : : }
6076 : :
6077 : 0 : static void io_mem_free(void *ptr)
6078 : : {
6079 : 0 : struct page *page;
6080 : :
6081 [ # # ]: 0 : if (!ptr)
6082 : : return;
6083 : :
6084 [ # # ]: 0 : page = virt_to_head_page(ptr);
6085 [ # # ]: 0 : if (put_page_testzero(page))
6086 : 0 : free_compound_page(page);
6087 : : }
6088 : :
6089 : : static void *io_mem_alloc(size_t size)
6090 : : {
6091 : : gfp_t gfp_flags = GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN | __GFP_COMP |
6092 : : __GFP_NORETRY;
6093 : :
6094 : : return (void *) __get_free_pages(gfp_flags, get_order(size));
6095 : : }
6096 : :
6097 : 0 : static unsigned long rings_size(unsigned sq_entries, unsigned cq_entries,
6098 : : size_t *sq_offset)
6099 : : {
6100 : 0 : struct io_rings *rings;
6101 : 0 : size_t off, sq_array_size;
6102 : :
6103 : 0 : off = struct_size(rings, cqes, cq_entries);
6104 [ # # ]: 0 : if (off == SIZE_MAX)
6105 : : return SIZE_MAX;
6106 : :
6107 : : #ifdef CONFIG_SMP
6108 : 0 : off = ALIGN(off, SMP_CACHE_BYTES);
6109 [ # # ]: 0 : if (off == 0)
6110 : : return SIZE_MAX;
6111 : : #endif
6112 : :
6113 [ # # ]: 0 : sq_array_size = array_size(sizeof(u32), sq_entries);
6114 : 0 : if (sq_array_size == SIZE_MAX)
6115 : : return SIZE_MAX;
6116 : :
6117 [ # # ]: 0 : if (check_add_overflow(off, sq_array_size, &off))
6118 : : return SIZE_MAX;
6119 : :
6120 : 0 : if (sq_offset)
6121 : : *sq_offset = off;
6122 : :
6123 : : return off;
6124 : : }
6125 : :
6126 : 0 : static unsigned long ring_pages(unsigned sq_entries, unsigned cq_entries)
6127 : : {
6128 : 0 : size_t pages;
6129 : :
6130 [ # # ]: 0 : pages = (size_t)1 << get_order(
6131 : : rings_size(sq_entries, cq_entries, NULL));
6132 : 0 : pages += (size_t)1 << get_order(
6133 : : array_size(sizeof(struct io_uring_sqe), sq_entries));
6134 : :
6135 : 0 : return pages;
6136 : : }
6137 : :
6138 : 0 : static int io_sqe_buffer_unregister(struct io_ring_ctx *ctx)
6139 : : {
6140 : 0 : int i, j;
6141 : :
6142 [ # # ]: 0 : if (!ctx->user_bufs)
6143 : : return -ENXIO;
6144 : :
6145 [ # # ]: 0 : for (i = 0; i < ctx->nr_user_bufs; i++) {
6146 : 0 : struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
6147 : :
6148 [ # # ]: 0 : for (j = 0; j < imu->nr_bvecs; j++)
6149 : 0 : unpin_user_page(imu->bvec[j].bv_page);
6150 : :
6151 [ # # ]: 0 : if (ctx->account_mem)
6152 : 0 : io_unaccount_mem(ctx->user, imu->nr_bvecs);
6153 : 0 : kvfree(imu->bvec);
6154 : 0 : imu->nr_bvecs = 0;
6155 : : }
6156 : :
6157 : 0 : kfree(ctx->user_bufs);
6158 : 0 : ctx->user_bufs = NULL;
6159 : 0 : ctx->nr_user_bufs = 0;
6160 : 0 : return 0;
6161 : : }
6162 : :
6163 : 0 : static int io_copy_iov(struct io_ring_ctx *ctx, struct iovec *dst,
6164 : : void __user *arg, unsigned index)
6165 : : {
6166 : 0 : struct iovec __user *src;
6167 : :
6168 : : #ifdef CONFIG_COMPAT
6169 [ # # ]: 0 : if (ctx->compat) {
6170 : 0 : struct compat_iovec __user *ciovs;
6171 : 0 : struct compat_iovec ciov;
6172 : :
6173 : 0 : ciovs = (struct compat_iovec __user *) arg;
6174 [ # # ]: 0 : if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
6175 : : return -EFAULT;
6176 : :
6177 : 0 : dst->iov_base = u64_to_user_ptr((u64)ciov.iov_base);
6178 : 0 : dst->iov_len = ciov.iov_len;
6179 : 0 : return 0;
6180 : : }
6181 : : #endif
6182 : 0 : src = (struct iovec __user *) arg;
6183 [ # # # # ]: 0 : if (copy_from_user(dst, &src[index], sizeof(*dst)))
6184 : 0 : return -EFAULT;
6185 : : return 0;
6186 : : }
6187 : :
6188 : 0 : static int io_sqe_buffer_register(struct io_ring_ctx *ctx, void __user *arg,
6189 : : unsigned nr_args)
6190 : : {
6191 : 0 : struct vm_area_struct **vmas = NULL;
6192 : 0 : struct page **pages = NULL;
6193 : 0 : int i, j, got_pages = 0;
6194 : 0 : int ret = -EINVAL;
6195 : :
6196 [ # # ]: 0 : if (ctx->user_bufs)
6197 : : return -EBUSY;
6198 [ # # ]: 0 : if (!nr_args || nr_args > UIO_MAXIOV)
6199 : : return -EINVAL;
6200 : :
6201 : 0 : ctx->user_bufs = kcalloc(nr_args, sizeof(struct io_mapped_ubuf),
6202 : : GFP_KERNEL);
6203 [ # # ]: 0 : if (!ctx->user_bufs)
6204 : : return -ENOMEM;
6205 : :
6206 [ # # ]: 0 : for (i = 0; i < nr_args; i++) {
6207 : 0 : struct io_mapped_ubuf *imu = &ctx->user_bufs[i];
6208 : 0 : unsigned long off, start, end, ubuf;
6209 : 0 : int pret, nr_pages;
6210 : 0 : struct iovec iov;
6211 : 0 : size_t size;
6212 : :
6213 : 0 : ret = io_copy_iov(ctx, &iov, arg, i);
6214 [ # # ]: 0 : if (ret)
6215 : 0 : goto err;
6216 : :
6217 : : /*
6218 : : * Don't impose further limits on the size and buffer
6219 : : * constraints here, we'll -EINVAL later when IO is
6220 : : * submitted if they are wrong.
6221 : : */
6222 : 0 : ret = -EFAULT;
6223 [ # # # # ]: 0 : if (!iov.iov_base || !iov.iov_len)
6224 : 0 : goto err;
6225 : :
6226 : : /* arbitrary limit, but we need something */
6227 [ # # ]: 0 : if (iov.iov_len > SZ_1G)
6228 : 0 : goto err;
6229 : :
6230 : 0 : ubuf = (unsigned long) iov.iov_base;
6231 : 0 : end = (ubuf + iov.iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
6232 : 0 : start = ubuf >> PAGE_SHIFT;
6233 : 0 : nr_pages = end - start;
6234 : :
6235 [ # # ]: 0 : if (ctx->account_mem) {
6236 : 0 : ret = io_account_mem(ctx->user, nr_pages);
6237 [ # # ]: 0 : if (ret)
6238 : 0 : goto err;
6239 : : }
6240 : :
6241 : 0 : ret = 0;
6242 [ # # ]: 0 : if (!pages || nr_pages > got_pages) {
6243 : 0 : kfree(vmas);
6244 : 0 : kfree(pages);
6245 [ # # ]: 0 : pages = kvmalloc_array(nr_pages, sizeof(struct page *),
6246 : : GFP_KERNEL);
6247 [ # # ]: 0 : vmas = kvmalloc_array(nr_pages,
6248 : : sizeof(struct vm_area_struct *),
6249 : : GFP_KERNEL);
6250 [ # # ]: 0 : if (!pages || !vmas) {
6251 : 0 : ret = -ENOMEM;
6252 [ # # ]: 0 : if (ctx->account_mem)
6253 : 0 : io_unaccount_mem(ctx->user, nr_pages);
6254 : 0 : goto err;
6255 : : }
6256 : : got_pages = nr_pages;
6257 : : }
6258 : :
6259 [ # # ]: 0 : imu->bvec = kvmalloc_array(nr_pages, sizeof(struct bio_vec),
6260 : : GFP_KERNEL);
6261 : 0 : ret = -ENOMEM;
6262 [ # # ]: 0 : if (!imu->bvec) {
6263 [ # # ]: 0 : if (ctx->account_mem)
6264 : 0 : io_unaccount_mem(ctx->user, nr_pages);
6265 : 0 : goto err;
6266 : : }
6267 : :
6268 : 0 : ret = 0;
6269 : 0 : down_read(¤t->mm->mmap_sem);
6270 : 0 : pret = pin_user_pages(ubuf, nr_pages,
6271 : : FOLL_WRITE | FOLL_LONGTERM,
6272 : : pages, vmas);
6273 [ # # ]: 0 : if (pret == nr_pages) {
6274 : : /* don't support file backed memory */
6275 [ # # ]: 0 : for (j = 0; j < nr_pages; j++) {
6276 : 0 : struct vm_area_struct *vma = vmas[j];
6277 : :
6278 [ # # # # ]: 0 : if (vma->vm_file &&
6279 : : !is_file_hugepages(vma->vm_file)) {
6280 : : ret = -EOPNOTSUPP;
6281 : : break;
6282 : : }
6283 : : }
6284 : : } else {
6285 [ # # ]: 0 : ret = pret < 0 ? pret : -EFAULT;
6286 : : }
6287 : 0 : up_read(¤t->mm->mmap_sem);
6288 [ # # ]: 0 : if (ret) {
6289 : : /*
6290 : : * if we did partial map, or found file backed vmas,
6291 : : * release any pages we did get
6292 : : */
6293 [ # # ]: 0 : if (pret > 0)
6294 : 0 : unpin_user_pages(pages, pret);
6295 [ # # ]: 0 : if (ctx->account_mem)
6296 : 0 : io_unaccount_mem(ctx->user, nr_pages);
6297 : 0 : kvfree(imu->bvec);
6298 : 0 : goto err;
6299 : : }
6300 : :
6301 : 0 : off = ubuf & ~PAGE_MASK;
6302 : 0 : size = iov.iov_len;
6303 [ # # ]: 0 : for (j = 0; j < nr_pages; j++) {
6304 : 0 : size_t vec_len;
6305 : :
6306 : 0 : vec_len = min_t(size_t, size, PAGE_SIZE - off);
6307 : 0 : imu->bvec[j].bv_page = pages[j];
6308 : 0 : imu->bvec[j].bv_len = vec_len;
6309 : 0 : imu->bvec[j].bv_offset = off;
6310 : 0 : off = 0;
6311 : 0 : size -= vec_len;
6312 : : }
6313 : : /* store original address for later verification */
6314 : 0 : imu->ubuf = ubuf;
6315 : 0 : imu->len = iov.iov_len;
6316 : 0 : imu->nr_bvecs = nr_pages;
6317 : :
6318 : 0 : ctx->nr_user_bufs++;
6319 : : }
6320 : 0 : kvfree(pages);
6321 : 0 : kvfree(vmas);
6322 : 0 : return 0;
6323 : : err:
6324 : 0 : kvfree(pages);
6325 : 0 : kvfree(vmas);
6326 : 0 : io_sqe_buffer_unregister(ctx);
6327 : 0 : return ret;
6328 : : }
6329 : :
6330 : : static int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg)
6331 : : {
6332 : : __s32 __user *fds = arg;
6333 : : int fd;
6334 : :
6335 : : if (ctx->cq_ev_fd)
6336 : : return -EBUSY;
6337 : :
6338 : : if (copy_from_user(&fd, fds, sizeof(*fds)))
6339 : : return -EFAULT;
6340 : :
6341 : : ctx->cq_ev_fd = eventfd_ctx_fdget(fd);
6342 : : if (IS_ERR(ctx->cq_ev_fd)) {
6343 : : int ret = PTR_ERR(ctx->cq_ev_fd);
6344 : : ctx->cq_ev_fd = NULL;
6345 : : return ret;
6346 : : }
6347 : :
6348 : : return 0;
6349 : : }
6350 : :
6351 : 0 : static int io_eventfd_unregister(struct io_ring_ctx *ctx)
6352 : : {
6353 : 0 : if (ctx->cq_ev_fd) {
6354 : 0 : eventfd_ctx_put(ctx->cq_ev_fd);
6355 : 0 : ctx->cq_ev_fd = NULL;
6356 : 0 : return 0;
6357 : : }
6358 : :
6359 : : return -ENXIO;
6360 : : }
6361 : :
6362 : 0 : static void io_ring_ctx_free(struct io_ring_ctx *ctx)
6363 : : {
6364 : 0 : io_finish_async(ctx);
6365 [ # # ]: 0 : if (ctx->sqo_mm)
6366 : 0 : mmdrop(ctx->sqo_mm);
6367 : :
6368 : 0 : io_iopoll_reap_events(ctx);
6369 : 0 : io_sqe_buffer_unregister(ctx);
6370 : 0 : io_sqe_files_unregister(ctx);
6371 [ # # ]: 0 : io_eventfd_unregister(ctx);
6372 : 0 : idr_destroy(&ctx->personality_idr);
6373 : :
6374 : : #if defined(CONFIG_UNIX)
6375 [ # # ]: 0 : if (ctx->ring_sock) {
6376 : 0 : ctx->ring_sock->file = NULL; /* so that iput() is called */
6377 : 0 : sock_release(ctx->ring_sock);
6378 : : }
6379 : : #endif
6380 : :
6381 : 0 : io_mem_free(ctx->rings);
6382 : 0 : io_mem_free(ctx->sq_sqes);
6383 : :
6384 : 0 : percpu_ref_exit(&ctx->refs);
6385 [ # # ]: 0 : if (ctx->account_mem)
6386 : 0 : io_unaccount_mem(ctx->user,
6387 : : ring_pages(ctx->sq_entries, ctx->cq_entries));
6388 : 0 : free_uid(ctx->user);
6389 : 0 : put_cred(ctx->creds);
6390 : 0 : kfree(ctx->completions);
6391 : 0 : kfree(ctx->cancel_hash);
6392 : 0 : kmem_cache_free(req_cachep, ctx->fallback_req);
6393 : 0 : kfree(ctx);
6394 : 0 : }
6395 : :
6396 : 0 : static __poll_t io_uring_poll(struct file *file, poll_table *wait)
6397 : : {
6398 : 0 : struct io_ring_ctx *ctx = file->private_data;
6399 : 0 : __poll_t mask = 0;
6400 : :
6401 [ # # ]: 0 : poll_wait(file, &ctx->cq_wait, wait);
6402 : : /*
6403 : : * synchronizes with barrier from wq_has_sleeper call in
6404 : : * io_commit_cqring
6405 : : */
6406 : 0 : smp_rmb();
6407 [ # # ]: 0 : if (READ_ONCE(ctx->rings->sq.tail) - ctx->cached_sq_head !=
6408 [ # # ]: 0 : ctx->rings->sq_ring_entries)
6409 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
6410 [ # # ]: 0 : if (io_cqring_events(ctx, false))
6411 : 0 : mask |= EPOLLIN | EPOLLRDNORM;
6412 : :
6413 : 0 : return mask;
6414 : : }
6415 : :
6416 : 0 : static int io_uring_fasync(int fd, struct file *file, int on)
6417 : : {
6418 : 0 : struct io_ring_ctx *ctx = file->private_data;
6419 : :
6420 : 0 : return fasync_helper(fd, file, on, &ctx->cq_fasync);
6421 : : }
6422 : :
6423 : 0 : static int io_remove_personalities(int id, void *p, void *data)
6424 : : {
6425 : 0 : struct io_ring_ctx *ctx = data;
6426 : 0 : const struct cred *cred;
6427 : :
6428 : 0 : cred = idr_remove(&ctx->personality_idr, id);
6429 [ # # ]: 0 : if (cred)
6430 : 0 : put_cred(cred);
6431 : 0 : return 0;
6432 : : }
6433 : :
6434 : 0 : static void io_ring_ctx_wait_and_kill(struct io_ring_ctx *ctx)
6435 : : {
6436 : 0 : mutex_lock(&ctx->uring_lock);
6437 : 0 : percpu_ref_kill(&ctx->refs);
6438 : 0 : mutex_unlock(&ctx->uring_lock);
6439 : :
6440 : : /*
6441 : : * Wait for sq thread to idle, if we have one. It won't spin on new
6442 : : * work after we've killed the ctx ref above. This is important to do
6443 : : * before we cancel existing commands, as the thread could otherwise
6444 : : * be queueing new work post that. If that's work we need to cancel,
6445 : : * it could cause shutdown to hang.
6446 : : */
6447 [ # # # # ]: 0 : while (ctx->sqo_thread && !wq_has_sleeper(&ctx->sqo_wait))
6448 : 0 : cpu_relax();
6449 : :
6450 : 0 : io_kill_timeouts(ctx);
6451 : 0 : io_poll_remove_all(ctx);
6452 : :
6453 [ # # ]: 0 : if (ctx->io_wq)
6454 : 0 : io_wq_cancel_all(ctx->io_wq);
6455 : :
6456 : 0 : io_iopoll_reap_events(ctx);
6457 : : /* if we failed setting up the ctx, we might not have any rings */
6458 [ # # ]: 0 : if (ctx->rings)
6459 : 0 : io_cqring_overflow_flush(ctx, true);
6460 : 0 : idr_for_each(&ctx->personality_idr, io_remove_personalities, ctx);
6461 : 0 : wait_for_completion(&ctx->completions[0]);
6462 : 0 : io_ring_ctx_free(ctx);
6463 : 0 : }
6464 : :
6465 : 0 : static int io_uring_release(struct inode *inode, struct file *file)
6466 : : {
6467 : 0 : struct io_ring_ctx *ctx = file->private_data;
6468 : :
6469 : 0 : file->private_data = NULL;
6470 : 0 : io_ring_ctx_wait_and_kill(ctx);
6471 : 0 : return 0;
6472 : : }
6473 : :
6474 : 0 : static void io_uring_cancel_files(struct io_ring_ctx *ctx,
6475 : : struct files_struct *files)
6476 : : {
6477 : 0 : struct io_kiocb *req;
6478 : 0 : DEFINE_WAIT(wait);
6479 : :
6480 [ # # ]: 0 : while (!list_empty_careful(&ctx->inflight_list)) {
6481 : 0 : struct io_kiocb *cancel_req = NULL;
6482 : :
6483 : 0 : spin_lock_irq(&ctx->inflight_lock);
6484 [ # # ]: 0 : list_for_each_entry(req, &ctx->inflight_list, inflight_entry) {
6485 [ # # ]: 0 : if (req->work.files != files)
6486 : 0 : continue;
6487 : : /* req is being completed, ignore */
6488 [ # # ]: 0 : if (!refcount_inc_not_zero(&req->refs))
6489 : 0 : continue;
6490 : : cancel_req = req;
6491 : : break;
6492 : : }
6493 [ # # ]: 0 : if (cancel_req)
6494 : 0 : prepare_to_wait(&ctx->inflight_wait, &wait,
6495 : : TASK_UNINTERRUPTIBLE);
6496 : 0 : spin_unlock_irq(&ctx->inflight_lock);
6497 : :
6498 : : /* We need to keep going until we don't find a matching req */
6499 [ # # ]: 0 : if (!cancel_req)
6500 : : break;
6501 : :
6502 [ # # ]: 0 : if (cancel_req->flags & REQ_F_OVERFLOW) {
6503 : 0 : spin_lock_irq(&ctx->completion_lock);
6504 [ # # ]: 0 : list_del(&cancel_req->list);
6505 : 0 : cancel_req->flags &= ~REQ_F_OVERFLOW;
6506 [ # # ]: 0 : if (list_empty(&ctx->cq_overflow_list)) {
6507 : 0 : clear_bit(0, &ctx->sq_check_overflow);
6508 : 0 : clear_bit(0, &ctx->cq_check_overflow);
6509 : : }
6510 : 0 : spin_unlock_irq(&ctx->completion_lock);
6511 : :
6512 : 0 : WRITE_ONCE(ctx->rings->cq_overflow,
6513 : : atomic_inc_return(&ctx->cached_cq_overflow));
6514 : :
6515 : : /*
6516 : : * Put inflight ref and overflow ref. If that's
6517 : : * all we had, then we're done with this request.
6518 : : */
6519 [ # # ]: 0 : if (refcount_sub_and_test(2, &cancel_req->refs)) {
6520 : 0 : io_put_req(cancel_req);
6521 : 0 : continue;
6522 : : }
6523 : : }
6524 : :
6525 : 0 : io_wq_cancel_work(ctx->io_wq, &cancel_req->work);
6526 : 0 : io_put_req(cancel_req);
6527 : 0 : schedule();
6528 : : }
6529 : 0 : finish_wait(&ctx->inflight_wait, &wait);
6530 : 0 : }
6531 : :
6532 : 0 : static int io_uring_flush(struct file *file, void *data)
6533 : : {
6534 : 0 : struct io_ring_ctx *ctx = file->private_data;
6535 : :
6536 : 0 : io_uring_cancel_files(ctx, data);
6537 : :
6538 : : /*
6539 : : * If the task is going away, cancel work it may have pending
6540 : : */
6541 [ # # # # ]: 0 : if (fatal_signal_pending(current) || (current->flags & PF_EXITING))
6542 : 0 : io_wq_cancel_pid(ctx->io_wq, task_pid_vnr(current));
6543 : :
6544 : 0 : return 0;
6545 : : }
6546 : :
6547 : : static void *io_uring_validate_mmap_request(struct file *file,
6548 : : loff_t pgoff, size_t sz)
6549 : : {
6550 : : struct io_ring_ctx *ctx = file->private_data;
6551 : : loff_t offset = pgoff << PAGE_SHIFT;
6552 : : struct page *page;
6553 : : void *ptr;
6554 : :
6555 : : switch (offset) {
6556 : : case IORING_OFF_SQ_RING:
6557 : : case IORING_OFF_CQ_RING:
6558 : : ptr = ctx->rings;
6559 : : break;
6560 : : case IORING_OFF_SQES:
6561 : : ptr = ctx->sq_sqes;
6562 : : break;
6563 : : default:
6564 : : return ERR_PTR(-EINVAL);
6565 : : }
6566 : :
6567 : : page = virt_to_head_page(ptr);
6568 : : if (sz > page_size(page))
6569 : : return ERR_PTR(-EINVAL);
6570 : :
6571 : : return ptr;
6572 : : }
6573 : :
6574 : : #ifdef CONFIG_MMU
6575 : :
6576 : 0 : static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
6577 : : {
6578 : 0 : size_t sz = vma->vm_end - vma->vm_start;
6579 : 0 : unsigned long pfn;
6580 : 0 : void *ptr;
6581 : :
6582 : 0 : ptr = io_uring_validate_mmap_request(file, vma->vm_pgoff, sz);
6583 [ # # ]: 0 : if (IS_ERR(ptr))
6584 : 0 : return PTR_ERR(ptr);
6585 : :
6586 [ # # ]: 0 : pfn = virt_to_phys(ptr) >> PAGE_SHIFT;
6587 : 0 : return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
6588 : : }
6589 : :
6590 : : #else /* !CONFIG_MMU */
6591 : :
6592 : : static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
6593 : : {
6594 : : return vma->vm_flags & (VM_SHARED | VM_MAYSHARE) ? 0 : -EINVAL;
6595 : : }
6596 : :
6597 : : static unsigned int io_uring_nommu_mmap_capabilities(struct file *file)
6598 : : {
6599 : : return NOMMU_MAP_DIRECT | NOMMU_MAP_READ | NOMMU_MAP_WRITE;
6600 : : }
6601 : :
6602 : : static unsigned long io_uring_nommu_get_unmapped_area(struct file *file,
6603 : : unsigned long addr, unsigned long len,
6604 : : unsigned long pgoff, unsigned long flags)
6605 : : {
6606 : : void *ptr;
6607 : :
6608 : : ptr = io_uring_validate_mmap_request(file, pgoff, len);
6609 : : if (IS_ERR(ptr))
6610 : : return PTR_ERR(ptr);
6611 : :
6612 : : return (unsigned long) ptr;
6613 : : }
6614 : :
6615 : : #endif /* !CONFIG_MMU */
6616 : :
6617 : 0 : SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,
6618 : : u32, min_complete, u32, flags, const sigset_t __user *, sig,
6619 : : size_t, sigsz)
6620 : : {
6621 : 0 : struct io_ring_ctx *ctx;
6622 : 0 : long ret = -EBADF;
6623 : 0 : int submitted = 0;
6624 : 0 : struct fd f;
6625 : :
6626 [ # # ]: 0 : if (flags & ~(IORING_ENTER_GETEVENTS | IORING_ENTER_SQ_WAKEUP))
6627 : : return -EINVAL;
6628 : :
6629 : 0 : f = fdget(fd);
6630 [ # # ]: 0 : if (!f.file)
6631 : : return -EBADF;
6632 : :
6633 : 0 : ret = -EOPNOTSUPP;
6634 [ # # ]: 0 : if (f.file->f_op != &io_uring_fops)
6635 : 0 : goto out_fput;
6636 : :
6637 : 0 : ret = -ENXIO;
6638 : 0 : ctx = f.file->private_data;
6639 [ # # ]: 0 : if (!percpu_ref_tryget(&ctx->refs))
6640 : 0 : goto out_fput;
6641 : :
6642 : : /*
6643 : : * For SQ polling, the thread will do all submissions and completions.
6644 : : * Just return the requested submit count, and wake the thread if
6645 : : * we were asked to.
6646 : : */
6647 : 0 : ret = 0;
6648 [ # # ]: 0 : if (ctx->flags & IORING_SETUP_SQPOLL) {
6649 [ # # ]: 0 : if (!list_empty_careful(&ctx->cq_overflow_list))
6650 : 0 : io_cqring_overflow_flush(ctx, false);
6651 [ # # ]: 0 : if (flags & IORING_ENTER_SQ_WAKEUP)
6652 : 0 : wake_up(&ctx->sqo_wait);
6653 : 0 : submitted = to_submit;
6654 [ # # ]: 0 : } else if (to_submit) {
6655 : 0 : struct mm_struct *cur_mm;
6656 : :
6657 : 0 : mutex_lock(&ctx->uring_lock);
6658 : : /* already have mm, so io_submit_sqes() won't try to grab it */
6659 : 0 : cur_mm = ctx->sqo_mm;
6660 : 0 : submitted = io_submit_sqes(ctx, to_submit, f.file, fd,
6661 : : &cur_mm, false);
6662 : 0 : mutex_unlock(&ctx->uring_lock);
6663 : :
6664 [ # # ]: 0 : if (submitted != to_submit)
6665 : 0 : goto out;
6666 : : }
6667 [ # # ]: 0 : if (flags & IORING_ENTER_GETEVENTS) {
6668 : 0 : unsigned nr_events = 0;
6669 : :
6670 : 0 : min_complete = min(min_complete, ctx->cq_entries);
6671 : :
6672 [ # # ]: 0 : if (ctx->flags & IORING_SETUP_IOPOLL) {
6673 : 0 : ret = io_iopoll_check(ctx, &nr_events, min_complete);
6674 : : } else {
6675 : 0 : ret = io_cqring_wait(ctx, min_complete, sig, sigsz);
6676 : : }
6677 : : }
6678 : :
6679 : 0 : out:
6680 : 0 : percpu_ref_put(&ctx->refs);
6681 : 0 : out_fput:
6682 [ # # ]: 0 : fdput(f);
6683 [ # # ]: 0 : return submitted ? submitted : ret;
6684 : : }
6685 : :
6686 : : #ifdef CONFIG_PROC_FS
6687 : 0 : static int io_uring_show_cred(int id, void *p, void *data)
6688 : : {
6689 : 0 : const struct cred *cred = p;
6690 : 0 : struct seq_file *m = data;
6691 : 0 : struct user_namespace *uns = seq_user_ns(m);
6692 : 0 : struct group_info *gi;
6693 : 0 : kernel_cap_t cap;
6694 : 0 : unsigned __capi;
6695 : 0 : int g;
6696 : :
6697 : 0 : seq_printf(m, "%5d\n", id);
6698 [ # # ]: 0 : seq_put_decimal_ull(m, "\tUid:\t", from_kuid_munged(uns, cred->uid));
6699 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->euid));
6700 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->suid));
6701 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kuid_munged(uns, cred->fsuid));
6702 [ # # ]: 0 : seq_put_decimal_ull(m, "\n\tGid:\t", from_kgid_munged(uns, cred->gid));
6703 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->egid));
6704 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->sgid));
6705 [ # # ]: 0 : seq_put_decimal_ull(m, "\t\t", from_kgid_munged(uns, cred->fsgid));
6706 : 0 : seq_puts(m, "\n\tGroups:\t");
6707 : 0 : gi = cred->group_info;
6708 [ # # ]: 0 : for (g = 0; g < gi->ngroups; g++) {
6709 [ # # # # ]: 0 : seq_put_decimal_ull(m, g ? " " : "",
6710 : : from_kgid_munged(uns, gi->gid[g]));
6711 : : }
6712 : 0 : seq_puts(m, "\n\tCapEff:\t");
6713 : 0 : cap = cred->cap_effective;
6714 [ # # ]: 0 : CAP_FOR_EACH_U32(__capi)
6715 : 0 : seq_put_hex_ll(m, NULL, cap.cap[CAP_LAST_U32 - __capi], 8);
6716 : 0 : seq_putc(m, '\n');
6717 : 0 : return 0;
6718 : : }
6719 : :
6720 : 0 : static void __io_uring_show_fdinfo(struct io_ring_ctx *ctx, struct seq_file *m)
6721 : : {
6722 : 0 : int i;
6723 : :
6724 : 0 : mutex_lock(&ctx->uring_lock);
6725 : 0 : seq_printf(m, "UserFiles:\t%u\n", ctx->nr_user_files);
6726 [ # # ]: 0 : for (i = 0; i < ctx->nr_user_files; i++) {
6727 : 0 : struct fixed_file_table *table;
6728 : 0 : struct file *f;
6729 : :
6730 : 0 : table = &ctx->file_data->table[i >> IORING_FILE_TABLE_SHIFT];
6731 : 0 : f = table->files[i & IORING_FILE_TABLE_MASK];
6732 [ # # ]: 0 : if (f)
6733 [ # # ]: 0 : seq_printf(m, "%5u: %s\n", i, file_dentry(f)->d_iname);
6734 : : else
6735 : 0 : seq_printf(m, "%5u: <none>\n", i);
6736 : : }
6737 : 0 : seq_printf(m, "UserBufs:\t%u\n", ctx->nr_user_bufs);
6738 [ # # ]: 0 : for (i = 0; i < ctx->nr_user_bufs; i++) {
6739 : 0 : struct io_mapped_ubuf *buf = &ctx->user_bufs[i];
6740 : :
6741 : 0 : seq_printf(m, "%5u: 0x%llx/%u\n", i, buf->ubuf,
6742 : 0 : (unsigned int) buf->len);
6743 : : }
6744 [ # # # # ]: 0 : if (!idr_is_empty(&ctx->personality_idr)) {
6745 : 0 : seq_printf(m, "Personalities:\n");
6746 : 0 : idr_for_each(&ctx->personality_idr, io_uring_show_cred, m);
6747 : : }
6748 : 0 : mutex_unlock(&ctx->uring_lock);
6749 : 0 : }
6750 : :
6751 : 0 : static void io_uring_show_fdinfo(struct seq_file *m, struct file *f)
6752 : : {
6753 : 0 : struct io_ring_ctx *ctx = f->private_data;
6754 : :
6755 [ # # ]: 0 : if (percpu_ref_tryget(&ctx->refs)) {
6756 : 0 : __io_uring_show_fdinfo(ctx, m);
6757 : 0 : percpu_ref_put(&ctx->refs);
6758 : : }
6759 : 0 : }
6760 : : #endif
6761 : :
6762 : : static const struct file_operations io_uring_fops = {
6763 : : .release = io_uring_release,
6764 : : .flush = io_uring_flush,
6765 : : .mmap = io_uring_mmap,
6766 : : #ifndef CONFIG_MMU
6767 : : .get_unmapped_area = io_uring_nommu_get_unmapped_area,
6768 : : .mmap_capabilities = io_uring_nommu_mmap_capabilities,
6769 : : #endif
6770 : : .poll = io_uring_poll,
6771 : : .fasync = io_uring_fasync,
6772 : : #ifdef CONFIG_PROC_FS
6773 : : .show_fdinfo = io_uring_show_fdinfo,
6774 : : #endif
6775 : : };
6776 : :
6777 : : static int io_allocate_scq_urings(struct io_ring_ctx *ctx,
6778 : : struct io_uring_params *p)
6779 : : {
6780 : : struct io_rings *rings;
6781 : : size_t size, sq_array_offset;
6782 : :
6783 : : size = rings_size(p->sq_entries, p->cq_entries, &sq_array_offset);
6784 : : if (size == SIZE_MAX)
6785 : : return -EOVERFLOW;
6786 : :
6787 : : rings = io_mem_alloc(size);
6788 : : if (!rings)
6789 : : return -ENOMEM;
6790 : :
6791 : : ctx->rings = rings;
6792 : : ctx->sq_array = (u32 *)((char *)rings + sq_array_offset);
6793 : : rings->sq_ring_mask = p->sq_entries - 1;
6794 : : rings->cq_ring_mask = p->cq_entries - 1;
6795 : : rings->sq_ring_entries = p->sq_entries;
6796 : : rings->cq_ring_entries = p->cq_entries;
6797 : : ctx->sq_mask = rings->sq_ring_mask;
6798 : : ctx->cq_mask = rings->cq_ring_mask;
6799 : : ctx->sq_entries = rings->sq_ring_entries;
6800 : : ctx->cq_entries = rings->cq_ring_entries;
6801 : :
6802 : : size = array_size(sizeof(struct io_uring_sqe), p->sq_entries);
6803 : : if (size == SIZE_MAX) {
6804 : : io_mem_free(ctx->rings);
6805 : : ctx->rings = NULL;
6806 : : return -EOVERFLOW;
6807 : : }
6808 : :
6809 : : ctx->sq_sqes = io_mem_alloc(size);
6810 : : if (!ctx->sq_sqes) {
6811 : : io_mem_free(ctx->rings);
6812 : : ctx->rings = NULL;
6813 : : return -ENOMEM;
6814 : : }
6815 : :
6816 : : return 0;
6817 : : }
6818 : :
6819 : : /*
6820 : : * Allocate an anonymous fd, this is what constitutes the application
6821 : : * visible backing of an io_uring instance. The application mmaps this
6822 : : * fd to gain access to the SQ/CQ ring details. If UNIX sockets are enabled,
6823 : : * we have to tie this fd to a socket for file garbage collection purposes.
6824 : : */
6825 : 0 : static int io_uring_get_fd(struct io_ring_ctx *ctx)
6826 : : {
6827 : 0 : struct file *file;
6828 : 0 : int ret;
6829 : :
6830 : : #if defined(CONFIG_UNIX)
6831 : 0 : ret = sock_create_kern(&init_net, PF_UNIX, SOCK_RAW, IPPROTO_IP,
6832 : : &ctx->ring_sock);
6833 [ # # ]: 0 : if (ret)
6834 : : return ret;
6835 : : #endif
6836 : :
6837 : 0 : ret = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
6838 [ # # ]: 0 : if (ret < 0)
6839 : 0 : goto err;
6840 : :
6841 : 0 : file = anon_inode_getfile("[io_uring]", &io_uring_fops, ctx,
6842 : : O_RDWR | O_CLOEXEC);
6843 [ # # ]: 0 : if (IS_ERR(file)) {
6844 : 0 : put_unused_fd(ret);
6845 : 0 : ret = PTR_ERR(file);
6846 : 0 : goto err;
6847 : : }
6848 : :
6849 : : #if defined(CONFIG_UNIX)
6850 : 0 : ctx->ring_sock->file = file;
6851 : : #endif
6852 : 0 : fd_install(ret, file);
6853 : 0 : return ret;
6854 : 0 : err:
6855 : : #if defined(CONFIG_UNIX)
6856 : 0 : sock_release(ctx->ring_sock);
6857 : 0 : ctx->ring_sock = NULL;
6858 : : #endif
6859 : 0 : return ret;
6860 : : }
6861 : :
6862 : 0 : static int io_uring_create(unsigned entries, struct io_uring_params *p)
6863 : : {
6864 : 0 : struct user_struct *user = NULL;
6865 : 0 : struct io_ring_ctx *ctx;
6866 : 0 : bool account_mem;
6867 : 0 : int ret;
6868 : :
6869 [ # # ]: 0 : if (!entries)
6870 : : return -EINVAL;
6871 [ # # ]: 0 : if (entries > IORING_MAX_ENTRIES) {
6872 [ # # ]: 0 : if (!(p->flags & IORING_SETUP_CLAMP))
6873 : : return -EINVAL;
6874 : : entries = IORING_MAX_ENTRIES;
6875 : : }
6876 : :
6877 : : /*
6878 : : * Use twice as many entries for the CQ ring. It's possible for the
6879 : : * application to drive a higher depth than the size of the SQ ring,
6880 : : * since the sqes are only used at submission time. This allows for
6881 : : * some flexibility in overcommitting a bit. If the application has
6882 : : * set IORING_SETUP_CQSIZE, it will have passed in the desired number
6883 : : * of CQ ring entries manually.
6884 : : */
6885 [ # # # # : 0 : p->sq_entries = roundup_pow_of_two(entries);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
6886 [ # # ]: 0 : if (p->flags & IORING_SETUP_CQSIZE) {
6887 : : /*
6888 : : * If IORING_SETUP_CQSIZE is set, we do the same roundup
6889 : : * to a power-of-two, if it isn't already. We do NOT impose
6890 : : * any cq vs sq ring sizing.
6891 : : */
6892 [ # # ]: 0 : if (p->cq_entries < p->sq_entries)
6893 : : return -EINVAL;
6894 [ # # ]: 0 : if (p->cq_entries > IORING_MAX_CQ_ENTRIES) {
6895 [ # # ]: 0 : if (!(p->flags & IORING_SETUP_CLAMP))
6896 : : return -EINVAL;
6897 : 0 : p->cq_entries = IORING_MAX_CQ_ENTRIES;
6898 : : }
6899 [ # # # # : 0 : p->cq_entries = roundup_pow_of_two(p->cq_entries);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
6900 : : } else {
6901 : 0 : p->cq_entries = 2 * p->sq_entries;
6902 : : }
6903 : :
6904 : 0 : user = get_uid(current_user());
6905 : 0 : account_mem = !capable(CAP_IPC_LOCK);
6906 : :
6907 [ # # ]: 0 : if (account_mem) {
6908 : 0 : ret = io_account_mem(user,
6909 : : ring_pages(p->sq_entries, p->cq_entries));
6910 [ # # ]: 0 : if (ret) {
6911 : 0 : free_uid(user);
6912 : 0 : return ret;
6913 : : }
6914 : : }
6915 : :
6916 : 0 : ctx = io_ring_ctx_alloc(p);
6917 [ # # ]: 0 : if (!ctx) {
6918 [ # # ]: 0 : if (account_mem)
6919 : 0 : io_unaccount_mem(user, ring_pages(p->sq_entries,
6920 : : p->cq_entries));
6921 : 0 : free_uid(user);
6922 : 0 : return -ENOMEM;
6923 : : }
6924 [ # # ]: 0 : ctx->compat = in_compat_syscall();
6925 : 0 : ctx->account_mem = account_mem;
6926 : 0 : ctx->user = user;
6927 [ # # ]: 0 : ctx->creds = get_current_cred();
6928 : :
6929 : 0 : ret = io_allocate_scq_urings(ctx, p);
6930 [ # # ]: 0 : if (ret)
6931 : 0 : goto err;
6932 : :
6933 : 0 : ret = io_sq_offload_start(ctx, p);
6934 [ # # ]: 0 : if (ret)
6935 : 0 : goto err;
6936 : :
6937 : 0 : memset(&p->sq_off, 0, sizeof(p->sq_off));
6938 : 0 : p->sq_off.head = offsetof(struct io_rings, sq.head);
6939 : 0 : p->sq_off.tail = offsetof(struct io_rings, sq.tail);
6940 : 0 : p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask);
6941 : 0 : p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries);
6942 : 0 : p->sq_off.flags = offsetof(struct io_rings, sq_flags);
6943 : 0 : p->sq_off.dropped = offsetof(struct io_rings, sq_dropped);
6944 : 0 : p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings;
6945 : :
6946 : 0 : memset(&p->cq_off, 0, sizeof(p->cq_off));
6947 : 0 : p->cq_off.head = offsetof(struct io_rings, cq.head);
6948 : 0 : p->cq_off.tail = offsetof(struct io_rings, cq.tail);
6949 : 0 : p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask);
6950 : 0 : p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries);
6951 : 0 : p->cq_off.overflow = offsetof(struct io_rings, cq_overflow);
6952 : 0 : p->cq_off.cqes = offsetof(struct io_rings, cqes);
6953 : :
6954 : : /*
6955 : : * Install ring fd as the very last thing, so we don't risk someone
6956 : : * having closed it before we finish setup
6957 : : */
6958 : 0 : ret = io_uring_get_fd(ctx);
6959 [ # # ]: 0 : if (ret < 0)
6960 : 0 : goto err;
6961 : :
6962 : 0 : p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP |
6963 : : IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
6964 : : IORING_FEAT_CUR_PERSONALITY;
6965 : 0 : trace_io_uring_create(ret, ctx, p->sq_entries, p->cq_entries, p->flags);
6966 : 0 : return ret;
6967 : 0 : err:
6968 : 0 : io_ring_ctx_wait_and_kill(ctx);
6969 : 0 : return ret;
6970 : : }
6971 : :
6972 : : /*
6973 : : * Sets up an aio uring context, and returns the fd. Applications asks for a
6974 : : * ring size, we return the actual sq/cq ring sizes (among other things) in the
6975 : : * params structure passed in.
6976 : : */
6977 : 0 : static long io_uring_setup(u32 entries, struct io_uring_params __user *params)
6978 : : {
6979 : 0 : struct io_uring_params p;
6980 : 0 : long ret;
6981 : 0 : int i;
6982 : :
6983 [ # # ]: 0 : if (copy_from_user(&p, params, sizeof(p)))
6984 : : return -EFAULT;
6985 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(p.resv); i++) {
6986 [ # # ]: 0 : if (p.resv[i])
6987 : : return -EINVAL;
6988 : : }
6989 : :
6990 [ # # ]: 0 : if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
6991 : : IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE |
6992 : : IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ))
6993 : : return -EINVAL;
6994 : :
6995 : 0 : ret = io_uring_create(entries, &p);
6996 [ # # ]: 0 : if (ret < 0)
6997 : : return ret;
6998 : :
6999 [ # # ]: 0 : if (copy_to_user(params, &p, sizeof(p)))
7000 : 0 : return -EFAULT;
7001 : :
7002 : : return ret;
7003 : : }
7004 : :
7005 : 0 : SYSCALL_DEFINE2(io_uring_setup, u32, entries,
7006 : : struct io_uring_params __user *, params)
7007 : : {
7008 : 0 : return io_uring_setup(entries, params);
7009 : : }
7010 : :
7011 : : static int io_probe(struct io_ring_ctx *ctx, void __user *arg, unsigned nr_args)
7012 : : {
7013 : : struct io_uring_probe *p;
7014 : : size_t size;
7015 : : int i, ret;
7016 : :
7017 : : size = struct_size(p, ops, nr_args);
7018 : : if (size == SIZE_MAX)
7019 : : return -EOVERFLOW;
7020 : : p = kzalloc(size, GFP_KERNEL);
7021 : : if (!p)
7022 : : return -ENOMEM;
7023 : :
7024 : : ret = -EFAULT;
7025 : : if (copy_from_user(p, arg, size))
7026 : : goto out;
7027 : : ret = -EINVAL;
7028 : : if (memchr_inv(p, 0, size))
7029 : : goto out;
7030 : :
7031 : : p->last_op = IORING_OP_LAST - 1;
7032 : : if (nr_args > IORING_OP_LAST)
7033 : : nr_args = IORING_OP_LAST;
7034 : :
7035 : : for (i = 0; i < nr_args; i++) {
7036 : : p->ops[i].op = i;
7037 : : if (!io_op_defs[i].not_supported)
7038 : : p->ops[i].flags = IO_URING_OP_SUPPORTED;
7039 : : }
7040 : : p->ops_len = i;
7041 : :
7042 : : ret = 0;
7043 : : if (copy_to_user(arg, p, size))
7044 : : ret = -EFAULT;
7045 : : out:
7046 : : kfree(p);
7047 : : return ret;
7048 : : }
7049 : :
7050 : 0 : static int io_register_personality(struct io_ring_ctx *ctx)
7051 : : {
7052 [ # # ]: 0 : const struct cred *creds = get_current_cred();
7053 : 0 : int id;
7054 : :
7055 : 0 : id = idr_alloc_cyclic(&ctx->personality_idr, (void *) creds, 1,
7056 : : USHRT_MAX, GFP_KERNEL);
7057 [ # # ]: 0 : if (id < 0)
7058 : 0 : put_cred(creds);
7059 : 0 : return id;
7060 : : }
7061 : :
7062 : 0 : static int io_unregister_personality(struct io_ring_ctx *ctx, unsigned id)
7063 : : {
7064 : 0 : const struct cred *old_creds;
7065 : :
7066 : 0 : old_creds = idr_remove(&ctx->personality_idr, id);
7067 [ # # ]: 0 : if (old_creds) {
7068 : 0 : put_cred(old_creds);
7069 : 0 : return 0;
7070 : : }
7071 : :
7072 : : return -EINVAL;
7073 : : }
7074 : :
7075 : 0 : static bool io_register_op_must_quiesce(int op)
7076 : : {
7077 : 0 : switch (op) {
7078 : : case IORING_UNREGISTER_FILES:
7079 : : case IORING_REGISTER_FILES_UPDATE:
7080 : : case IORING_REGISTER_PROBE:
7081 : : case IORING_REGISTER_PERSONALITY:
7082 : : case IORING_UNREGISTER_PERSONALITY:
7083 : : return false;
7084 : : default:
7085 : 0 : return true;
7086 : : }
7087 : : }
7088 : :
7089 : 0 : static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
7090 : : void __user *arg, unsigned nr_args)
7091 : : __releases(ctx->uring_lock)
7092 : : __acquires(ctx->uring_lock)
7093 : : {
7094 : 0 : int ret;
7095 : :
7096 : : /*
7097 : : * We're inside the ring mutex, if the ref is already dying, then
7098 : : * someone else killed the ctx or is already going through
7099 : : * io_uring_register().
7100 : : */
7101 [ # # ]: 0 : if (percpu_ref_is_dying(&ctx->refs))
7102 : : return -ENXIO;
7103 : :
7104 [ # # ]: 0 : if (io_register_op_must_quiesce(opcode)) {
7105 : 0 : percpu_ref_kill(&ctx->refs);
7106 : :
7107 : : /*
7108 : : * Drop uring mutex before waiting for references to exit. If
7109 : : * another thread is currently inside io_uring_enter() it might
7110 : : * need to grab the uring_lock to make progress. If we hold it
7111 : : * here across the drain wait, then we can deadlock. It's safe
7112 : : * to drop the mutex here, since no new references will come in
7113 : : * after we've killed the percpu ref.
7114 : : */
7115 : 0 : mutex_unlock(&ctx->uring_lock);
7116 : 0 : ret = wait_for_completion_interruptible(&ctx->completions[0]);
7117 : 0 : mutex_lock(&ctx->uring_lock);
7118 [ # # ]: 0 : if (ret) {
7119 : 0 : percpu_ref_resurrect(&ctx->refs);
7120 : 0 : ret = -EINTR;
7121 : 0 : goto out;
7122 : : }
7123 : : }
7124 : :
7125 [ # # # # : 0 : switch (opcode) {
# # # # #
# # ]
7126 : 0 : case IORING_REGISTER_BUFFERS:
7127 : 0 : ret = io_sqe_buffer_register(ctx, arg, nr_args);
7128 : 0 : break;
7129 : 0 : case IORING_UNREGISTER_BUFFERS:
7130 : 0 : ret = -EINVAL;
7131 [ # # ]: 0 : if (arg || nr_args)
7132 : : break;
7133 : 0 : ret = io_sqe_buffer_unregister(ctx);
7134 : 0 : break;
7135 : 0 : case IORING_REGISTER_FILES:
7136 : 0 : ret = io_sqe_files_register(ctx, arg, nr_args);
7137 : 0 : break;
7138 : 0 : case IORING_UNREGISTER_FILES:
7139 : 0 : ret = -EINVAL;
7140 [ # # ]: 0 : if (arg || nr_args)
7141 : : break;
7142 : 0 : ret = io_sqe_files_unregister(ctx);
7143 : 0 : break;
7144 : 0 : case IORING_REGISTER_FILES_UPDATE:
7145 : 0 : ret = io_sqe_files_update(ctx, arg, nr_args);
7146 : 0 : break;
7147 : 0 : case IORING_REGISTER_EVENTFD:
7148 : : case IORING_REGISTER_EVENTFD_ASYNC:
7149 : 0 : ret = -EINVAL;
7150 [ # # ]: 0 : if (nr_args != 1)
7151 : : break;
7152 : 0 : ret = io_eventfd_register(ctx, arg);
7153 [ # # ]: 0 : if (ret)
7154 : : break;
7155 [ # # ]: 0 : if (opcode == IORING_REGISTER_EVENTFD_ASYNC)
7156 : 0 : ctx->eventfd_async = 1;
7157 : : else
7158 : 0 : ctx->eventfd_async = 0;
7159 : : break;
7160 : 0 : case IORING_UNREGISTER_EVENTFD:
7161 : 0 : ret = -EINVAL;
7162 [ # # ]: 0 : if (arg || nr_args)
7163 : : break;
7164 [ # # ]: 0 : ret = io_eventfd_unregister(ctx);
7165 : : break;
7166 : 0 : case IORING_REGISTER_PROBE:
7167 : 0 : ret = -EINVAL;
7168 [ # # ]: 0 : if (!arg || nr_args > 256)
7169 : : break;
7170 : 0 : ret = io_probe(ctx, arg, nr_args);
7171 : 0 : break;
7172 : 0 : case IORING_REGISTER_PERSONALITY:
7173 : 0 : ret = -EINVAL;
7174 [ # # ]: 0 : if (arg || nr_args)
7175 : : break;
7176 : 0 : ret = io_register_personality(ctx);
7177 : 0 : break;
7178 : 0 : case IORING_UNREGISTER_PERSONALITY:
7179 : 0 : ret = -EINVAL;
7180 [ # # ]: 0 : if (arg)
7181 : : break;
7182 : 0 : ret = io_unregister_personality(ctx, nr_args);
7183 : : break;
7184 : : default:
7185 : : ret = -EINVAL;
7186 : : break;
7187 : : }
7188 : :
7189 [ # # ]: 0 : if (io_register_op_must_quiesce(opcode)) {
7190 : : /* bring the ctx back to life */
7191 : 0 : percpu_ref_reinit(&ctx->refs);
7192 : 0 : out:
7193 : 0 : reinit_completion(&ctx->completions[0]);
7194 : : }
7195 : : return ret;
7196 : : }
7197 : :
7198 : 0 : SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
7199 : : void __user *, arg, unsigned int, nr_args)
7200 : : {
7201 : 0 : struct io_ring_ctx *ctx;
7202 : 0 : long ret = -EBADF;
7203 : 0 : struct fd f;
7204 : :
7205 : 0 : f = fdget(fd);
7206 [ # # ]: 0 : if (!f.file)
7207 : : return -EBADF;
7208 : :
7209 : 0 : ret = -EOPNOTSUPP;
7210 [ # # ]: 0 : if (f.file->f_op != &io_uring_fops)
7211 : 0 : goto out_fput;
7212 : :
7213 : 0 : ctx = f.file->private_data;
7214 : :
7215 : 0 : mutex_lock(&ctx->uring_lock);
7216 : 0 : ret = __io_uring_register(ctx, opcode, arg, nr_args);
7217 : 0 : mutex_unlock(&ctx->uring_lock);
7218 : 0 : trace_io_uring_register(ctx, opcode, ctx->nr_user_files, ctx->nr_user_bufs,
7219 : 0 : ctx->cq_ev_fd != NULL, ret);
7220 : 0 : out_fput:
7221 [ # # ]: 0 : fdput(f);
7222 : : return ret;
7223 : : }
7224 : :
7225 : 21 : static int __init io_uring_init(void)
7226 : : {
7227 : : #define __BUILD_BUG_VERIFY_ELEMENT(stype, eoffset, etype, ename) do { \
7228 : : BUILD_BUG_ON(offsetof(stype, ename) != eoffset); \
7229 : : BUILD_BUG_ON(sizeof(etype) != sizeof_field(stype, ename)); \
7230 : : } while (0)
7231 : :
7232 : : #define BUILD_BUG_SQE_ELEM(eoffset, etype, ename) \
7233 : : __BUILD_BUG_VERIFY_ELEMENT(struct io_uring_sqe, eoffset, etype, ename)
7234 : 21 : BUILD_BUG_ON(sizeof(struct io_uring_sqe) != 64);
7235 : 21 : BUILD_BUG_SQE_ELEM(0, __u8, opcode);
7236 : 21 : BUILD_BUG_SQE_ELEM(1, __u8, flags);
7237 : 21 : BUILD_BUG_SQE_ELEM(2, __u16, ioprio);
7238 : 21 : BUILD_BUG_SQE_ELEM(4, __s32, fd);
7239 : 21 : BUILD_BUG_SQE_ELEM(8, __u64, off);
7240 : 21 : BUILD_BUG_SQE_ELEM(8, __u64, addr2);
7241 : 21 : BUILD_BUG_SQE_ELEM(16, __u64, addr);
7242 : 21 : BUILD_BUG_SQE_ELEM(24, __u32, len);
7243 : 21 : BUILD_BUG_SQE_ELEM(28, __kernel_rwf_t, rw_flags);
7244 : 21 : BUILD_BUG_SQE_ELEM(28, /* compat */ int, rw_flags);
7245 : 21 : BUILD_BUG_SQE_ELEM(28, /* compat */ __u32, rw_flags);
7246 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, fsync_flags);
7247 : 21 : BUILD_BUG_SQE_ELEM(28, __u16, poll_events);
7248 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, sync_range_flags);
7249 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, msg_flags);
7250 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, timeout_flags);
7251 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, accept_flags);
7252 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, cancel_flags);
7253 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, open_flags);
7254 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, statx_flags);
7255 : 21 : BUILD_BUG_SQE_ELEM(28, __u32, fadvise_advice);
7256 : 21 : BUILD_BUG_SQE_ELEM(32, __u64, user_data);
7257 : 21 : BUILD_BUG_SQE_ELEM(40, __u16, buf_index);
7258 : 21 : BUILD_BUG_SQE_ELEM(42, __u16, personality);
7259 : :
7260 : 21 : BUILD_BUG_ON(ARRAY_SIZE(io_op_defs) != IORING_OP_LAST);
7261 : 21 : req_cachep = KMEM_CACHE(io_kiocb, SLAB_HWCACHE_ALIGN | SLAB_PANIC);
7262 : 21 : return 0;
7263 : : };
7264 : : __initcall(io_uring_init);
|
