xref: /linux/io_uring/rw.c (revision d53276d2928345f68a3eb7722a849fb4a0aa2ad0)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/kernel.h>
3 #include <linux/errno.h>
4 #include <linux/fs.h>
5 #include <linux/file.h>
6 #include <linux/blk-mq.h>
7 #include <linux/mm.h>
8 #include <linux/slab.h>
9 #include <linux/fsnotify.h>
10 #include <linux/poll.h>
11 #include <linux/nospec.h>
12 #include <linux/compat.h>
13 #include <linux/io_uring/cmd.h>
14 #include <linux/indirect_call_wrapper.h>
15 
16 #include <uapi/linux/io_uring.h>
17 
18 #include "io_uring.h"
19 #include "opdef.h"
20 #include "kbuf.h"
21 #include "alloc_cache.h"
22 #include "rsrc.h"
23 #include "poll.h"
24 #include "rw.h"
25 
26 static void io_complete_rw(struct kiocb *kiocb, long res);
27 static void io_complete_rw_iopoll(struct kiocb *kiocb, long res);
28 
29 struct io_rw {
30 	/* NOTE: kiocb has the file as the first member, so don't do it here */
31 	struct kiocb			kiocb;
32 	u64				addr;
33 	u32				len;
34 	rwf_t				flags;
35 };
36 
io_file_supports_nowait(struct io_kiocb * req,__poll_t mask)37 static bool io_file_supports_nowait(struct io_kiocb *req, __poll_t mask)
38 {
39 	/* If FMODE_NOWAIT is set for a file, we're golden */
40 	if (req->flags & REQ_F_SUPPORT_NOWAIT)
41 		return true;
42 	/* No FMODE_NOWAIT, if we can poll, check the status */
43 	if (io_file_can_poll(req)) {
44 		struct poll_table_struct pt = { ._key = mask };
45 
46 		return vfs_poll(req->file, &pt) & mask;
47 	}
48 	/* No FMODE_NOWAIT support, and file isn't pollable. Tough luck. */
49 	return false;
50 }
51 
52 #ifdef CONFIG_COMPAT
io_iov_compat_buffer_select_prep(struct io_rw * rw)53 static int io_iov_compat_buffer_select_prep(struct io_rw *rw)
54 {
55 	struct compat_iovec __user *uiov;
56 	compat_ssize_t clen;
57 
58 	uiov = u64_to_user_ptr(rw->addr);
59 	if (!access_ok(uiov, sizeof(*uiov)))
60 		return -EFAULT;
61 	if (__get_user(clen, &uiov->iov_len))
62 		return -EFAULT;
63 	if (clen < 0)
64 		return -EINVAL;
65 
66 	rw->len = clen;
67 	return 0;
68 }
69 #endif
70 
io_iov_buffer_select_prep(struct io_kiocb * req)71 static int io_iov_buffer_select_prep(struct io_kiocb *req)
72 {
73 	struct iovec __user *uiov;
74 	struct iovec iov;
75 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
76 
77 	if (rw->len != 1)
78 		return -EINVAL;
79 
80 #ifdef CONFIG_COMPAT
81 	if (req->ctx->compat)
82 		return io_iov_compat_buffer_select_prep(rw);
83 #endif
84 
85 	uiov = u64_to_user_ptr(rw->addr);
86 	if (copy_from_user(&iov, uiov, sizeof(*uiov)))
87 		return -EFAULT;
88 	rw->len = iov.iov_len;
89 	return 0;
90 }
91 
__io_import_iovec(int ddir,struct io_kiocb * req,struct io_async_rw * io,unsigned int issue_flags)92 static int __io_import_iovec(int ddir, struct io_kiocb *req,
93 			     struct io_async_rw *io,
94 			     unsigned int issue_flags)
95 {
96 	const struct io_issue_def *def = &io_issue_defs[req->opcode];
97 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
98 	struct iovec *iov;
99 	void __user *buf;
100 	int nr_segs, ret;
101 	size_t sqe_len;
102 
103 	buf = u64_to_user_ptr(rw->addr);
104 	sqe_len = rw->len;
105 
106 	if (!def->vectored || req->flags & REQ_F_BUFFER_SELECT) {
107 		if (io_do_buffer_select(req)) {
108 			buf = io_buffer_select(req, &sqe_len, issue_flags);
109 			if (!buf)
110 				return -ENOBUFS;
111 			rw->addr = (unsigned long) buf;
112 			rw->len = sqe_len;
113 		}
114 
115 		return import_ubuf(ddir, buf, sqe_len, &io->iter);
116 	}
117 
118 	if (io->free_iovec) {
119 		nr_segs = io->free_iov_nr;
120 		iov = io->free_iovec;
121 	} else {
122 		iov = &io->fast_iov;
123 		nr_segs = 1;
124 	}
125 	ret = __import_iovec(ddir, buf, sqe_len, nr_segs, &iov, &io->iter,
126 				req->ctx->compat);
127 	if (unlikely(ret < 0))
128 		return ret;
129 	if (iov) {
130 		req->flags |= REQ_F_NEED_CLEANUP;
131 		io->free_iov_nr = io->iter.nr_segs;
132 		kfree(io->free_iovec);
133 		io->free_iovec = iov;
134 	}
135 	return 0;
136 }
137 
io_import_iovec(int rw,struct io_kiocb * req,struct io_async_rw * io,unsigned int issue_flags)138 static inline int io_import_iovec(int rw, struct io_kiocb *req,
139 				  struct io_async_rw *io,
140 				  unsigned int issue_flags)
141 {
142 	int ret;
143 
144 	ret = __io_import_iovec(rw, req, io, issue_flags);
145 	if (unlikely(ret < 0))
146 		return ret;
147 
148 	iov_iter_save_state(&io->iter, &io->iter_state);
149 	return 0;
150 }
151 
io_rw_recycle(struct io_kiocb * req,unsigned int issue_flags)152 static void io_rw_recycle(struct io_kiocb *req, unsigned int issue_flags)
153 {
154 	struct io_async_rw *rw = req->async_data;
155 
156 	if (unlikely(issue_flags & IO_URING_F_UNLOCKED))
157 		return;
158 
159 	io_alloc_cache_kasan(&rw->free_iovec, &rw->free_iov_nr);
160 	if (io_alloc_cache_put(&req->ctx->rw_cache, rw)) {
161 		req->async_data = NULL;
162 		req->flags &= ~REQ_F_ASYNC_DATA;
163 	}
164 }
165 
io_req_rw_cleanup(struct io_kiocb * req,unsigned int issue_flags)166 static void io_req_rw_cleanup(struct io_kiocb *req, unsigned int issue_flags)
167 {
168 	/*
169 	 * Disable quick recycling for anything that's gone through io-wq.
170 	 * In theory, this should be fine to cleanup. However, some read or
171 	 * write iter handling touches the iovec AFTER having called into the
172 	 * handler, eg to reexpand or revert. This means we can have:
173 	 *
174 	 * task			io-wq
175 	 *   issue
176 	 *     punt to io-wq
177 	 *			issue
178 	 *			  blkdev_write_iter()
179 	 *			    ->ki_complete()
180 	 *			      io_complete_rw()
181 	 *			        queue tw complete
182 	 *  run tw
183 	 *    req_rw_cleanup
184 	 *			iov_iter_count() <- look at iov_iter again
185 	 *
186 	 * which can lead to a UAF. This is only possible for io-wq offload
187 	 * as the cleanup can run in parallel. As io-wq is not the fast path,
188 	 * just leave cleanup to the end.
189 	 *
190 	 * This is really a bug in the core code that does this, any issue
191 	 * path should assume that a successful (or -EIOCBQUEUED) return can
192 	 * mean that the underlying data can be gone at any time. But that
193 	 * should be fixed seperately, and then this check could be killed.
194 	 */
195 	if (!(req->flags & (REQ_F_REISSUE | REQ_F_REFCOUNT))) {
196 		req->flags &= ~REQ_F_NEED_CLEANUP;
197 		io_rw_recycle(req, issue_flags);
198 	}
199 }
200 
io_rw_alloc_async(struct io_kiocb * req)201 static int io_rw_alloc_async(struct io_kiocb *req)
202 {
203 	struct io_ring_ctx *ctx = req->ctx;
204 	struct io_async_rw *rw;
205 
206 	rw = io_uring_alloc_async_data(&ctx->rw_cache, req);
207 	if (!rw)
208 		return -ENOMEM;
209 	if (rw->free_iovec)
210 		req->flags |= REQ_F_NEED_CLEANUP;
211 	rw->bytes_done = 0;
212 	return 0;
213 }
214 
io_prep_rw_setup(struct io_kiocb * req,int ddir,bool do_import)215 static int io_prep_rw_setup(struct io_kiocb *req, int ddir, bool do_import)
216 {
217 	struct io_async_rw *rw;
218 
219 	if (io_rw_alloc_async(req))
220 		return -ENOMEM;
221 
222 	if (!do_import || io_do_buffer_select(req))
223 		return 0;
224 
225 	rw = req->async_data;
226 	return io_import_iovec(ddir, req, rw, 0);
227 }
228 
io_meta_save_state(struct io_async_rw * io)229 static inline void io_meta_save_state(struct io_async_rw *io)
230 {
231 	io->meta_state.seed = io->meta.seed;
232 	iov_iter_save_state(&io->meta.iter, &io->meta_state.iter_meta);
233 }
234 
io_meta_restore(struct io_async_rw * io,struct kiocb * kiocb)235 static inline void io_meta_restore(struct io_async_rw *io, struct kiocb *kiocb)
236 {
237 	if (kiocb->ki_flags & IOCB_HAS_METADATA) {
238 		io->meta.seed = io->meta_state.seed;
239 		iov_iter_restore(&io->meta.iter, &io->meta_state.iter_meta);
240 	}
241 }
242 
io_prep_rw_pi(struct io_kiocb * req,struct io_rw * rw,int ddir,u64 attr_ptr,u64 attr_type_mask)243 static int io_prep_rw_pi(struct io_kiocb *req, struct io_rw *rw, int ddir,
244 			 u64 attr_ptr, u64 attr_type_mask)
245 {
246 	struct io_uring_attr_pi pi_attr;
247 	struct io_async_rw *io;
248 	int ret;
249 
250 	if (copy_from_user(&pi_attr, u64_to_user_ptr(attr_ptr),
251 	    sizeof(pi_attr)))
252 		return -EFAULT;
253 
254 	if (pi_attr.rsvd)
255 		return -EINVAL;
256 
257 	io = req->async_data;
258 	io->meta.flags = pi_attr.flags;
259 	io->meta.app_tag = pi_attr.app_tag;
260 	io->meta.seed = pi_attr.seed;
261 	ret = import_ubuf(ddir, u64_to_user_ptr(pi_attr.addr),
262 			  pi_attr.len, &io->meta.iter);
263 	if (unlikely(ret < 0))
264 		return ret;
265 	req->flags |= REQ_F_HAS_METADATA;
266 	io_meta_save_state(io);
267 	return ret;
268 }
269 
io_prep_rw(struct io_kiocb * req,const struct io_uring_sqe * sqe,int ddir,bool do_import)270 static int io_prep_rw(struct io_kiocb *req, const struct io_uring_sqe *sqe,
271 		      int ddir, bool do_import)
272 {
273 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
274 	unsigned ioprio;
275 	u64 attr_type_mask;
276 	int ret;
277 
278 	rw->kiocb.ki_pos = READ_ONCE(sqe->off);
279 	/* used for fixed read/write too - just read unconditionally */
280 	req->buf_index = READ_ONCE(sqe->buf_index);
281 
282 	ioprio = READ_ONCE(sqe->ioprio);
283 	if (ioprio) {
284 		ret = ioprio_check_cap(ioprio);
285 		if (ret)
286 			return ret;
287 
288 		rw->kiocb.ki_ioprio = ioprio;
289 	} else {
290 		rw->kiocb.ki_ioprio = get_current_ioprio();
291 	}
292 	rw->kiocb.dio_complete = NULL;
293 	rw->kiocb.ki_flags = 0;
294 
295 	if (req->ctx->flags & IORING_SETUP_IOPOLL)
296 		rw->kiocb.ki_complete = io_complete_rw_iopoll;
297 	else
298 		rw->kiocb.ki_complete = io_complete_rw;
299 
300 	rw->addr = READ_ONCE(sqe->addr);
301 	rw->len = READ_ONCE(sqe->len);
302 	rw->flags = READ_ONCE(sqe->rw_flags);
303 	ret = io_prep_rw_setup(req, ddir, do_import);
304 
305 	if (unlikely(ret))
306 		return ret;
307 
308 	attr_type_mask = READ_ONCE(sqe->attr_type_mask);
309 	if (attr_type_mask) {
310 		u64 attr_ptr;
311 
312 		/* only PI attribute is supported currently */
313 		if (attr_type_mask != IORING_RW_ATTR_FLAG_PI)
314 			return -EINVAL;
315 
316 		attr_ptr = READ_ONCE(sqe->attr_ptr);
317 		ret = io_prep_rw_pi(req, rw, ddir, attr_ptr, attr_type_mask);
318 	}
319 	return ret;
320 }
321 
io_prep_read(struct io_kiocb * req,const struct io_uring_sqe * sqe)322 int io_prep_read(struct io_kiocb *req, const struct io_uring_sqe *sqe)
323 {
324 	return io_prep_rw(req, sqe, ITER_DEST, true);
325 }
326 
io_prep_write(struct io_kiocb * req,const struct io_uring_sqe * sqe)327 int io_prep_write(struct io_kiocb *req, const struct io_uring_sqe *sqe)
328 {
329 	return io_prep_rw(req, sqe, ITER_SOURCE, true);
330 }
331 
io_prep_rwv(struct io_kiocb * req,const struct io_uring_sqe * sqe,int ddir)332 static int io_prep_rwv(struct io_kiocb *req, const struct io_uring_sqe *sqe,
333 		       int ddir)
334 {
335 	const bool do_import = !(req->flags & REQ_F_BUFFER_SELECT);
336 	int ret;
337 
338 	ret = io_prep_rw(req, sqe, ddir, do_import);
339 	if (unlikely(ret))
340 		return ret;
341 	if (do_import)
342 		return 0;
343 
344 	/*
345 	 * Have to do this validation here, as this is in io_read() rw->len
346 	 * might have chanaged due to buffer selection
347 	 */
348 	return io_iov_buffer_select_prep(req);
349 }
350 
io_prep_readv(struct io_kiocb * req,const struct io_uring_sqe * sqe)351 int io_prep_readv(struct io_kiocb *req, const struct io_uring_sqe *sqe)
352 {
353 	return io_prep_rwv(req, sqe, ITER_DEST);
354 }
355 
io_prep_writev(struct io_kiocb * req,const struct io_uring_sqe * sqe)356 int io_prep_writev(struct io_kiocb *req, const struct io_uring_sqe *sqe)
357 {
358 	return io_prep_rwv(req, sqe, ITER_SOURCE);
359 }
360 
io_prep_rw_fixed(struct io_kiocb * req,const struct io_uring_sqe * sqe,int ddir)361 static int io_prep_rw_fixed(struct io_kiocb *req, const struct io_uring_sqe *sqe,
362 			    int ddir)
363 {
364 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
365 	struct io_ring_ctx *ctx = req->ctx;
366 	struct io_rsrc_node *node;
367 	struct io_async_rw *io;
368 	int ret;
369 
370 	ret = io_prep_rw(req, sqe, ddir, false);
371 	if (unlikely(ret))
372 		return ret;
373 
374 	node = io_rsrc_node_lookup(&ctx->buf_table, req->buf_index);
375 	if (!node)
376 		return -EFAULT;
377 	io_req_assign_buf_node(req, node);
378 
379 	io = req->async_data;
380 	ret = io_import_fixed(ddir, &io->iter, node->buf, rw->addr, rw->len);
381 	iov_iter_save_state(&io->iter, &io->iter_state);
382 	return ret;
383 }
384 
io_prep_read_fixed(struct io_kiocb * req,const struct io_uring_sqe * sqe)385 int io_prep_read_fixed(struct io_kiocb *req, const struct io_uring_sqe *sqe)
386 {
387 	return io_prep_rw_fixed(req, sqe, ITER_DEST);
388 }
389 
io_prep_write_fixed(struct io_kiocb * req,const struct io_uring_sqe * sqe)390 int io_prep_write_fixed(struct io_kiocb *req, const struct io_uring_sqe *sqe)
391 {
392 	return io_prep_rw_fixed(req, sqe, ITER_SOURCE);
393 }
394 
395 /*
396  * Multishot read is prepared just like a normal read/write request, only
397  * difference is that we set the MULTISHOT flag.
398  */
io_read_mshot_prep(struct io_kiocb * req,const struct io_uring_sqe * sqe)399 int io_read_mshot_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
400 {
401 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
402 	int ret;
403 
404 	/* must be used with provided buffers */
405 	if (!(req->flags & REQ_F_BUFFER_SELECT))
406 		return -EINVAL;
407 
408 	ret = io_prep_rw(req, sqe, ITER_DEST, false);
409 	if (unlikely(ret))
410 		return ret;
411 
412 	if (rw->addr || rw->len)
413 		return -EINVAL;
414 
415 	req->flags |= REQ_F_APOLL_MULTISHOT;
416 	return 0;
417 }
418 
io_readv_writev_cleanup(struct io_kiocb * req)419 void io_readv_writev_cleanup(struct io_kiocb *req)
420 {
421 	lockdep_assert_held(&req->ctx->uring_lock);
422 	io_rw_recycle(req, 0);
423 }
424 
io_kiocb_update_pos(struct io_kiocb * req)425 static inline loff_t *io_kiocb_update_pos(struct io_kiocb *req)
426 {
427 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
428 
429 	if (rw->kiocb.ki_pos != -1)
430 		return &rw->kiocb.ki_pos;
431 
432 	if (!(req->file->f_mode & FMODE_STREAM)) {
433 		req->flags |= REQ_F_CUR_POS;
434 		rw->kiocb.ki_pos = req->file->f_pos;
435 		return &rw->kiocb.ki_pos;
436 	}
437 
438 	rw->kiocb.ki_pos = 0;
439 	return NULL;
440 }
441 
io_rw_should_reissue(struct io_kiocb * req)442 static bool io_rw_should_reissue(struct io_kiocb *req)
443 {
444 #ifdef CONFIG_BLOCK
445 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
446 	umode_t mode = file_inode(req->file)->i_mode;
447 	struct io_async_rw *io = req->async_data;
448 	struct io_ring_ctx *ctx = req->ctx;
449 
450 	if (!S_ISBLK(mode) && !S_ISREG(mode))
451 		return false;
452 	if ((req->flags & REQ_F_NOWAIT) || (io_wq_current_is_worker() &&
453 	    !(ctx->flags & IORING_SETUP_IOPOLL)))
454 		return false;
455 	/*
456 	 * If ref is dying, we might be running poll reap from the exit work.
457 	 * Don't attempt to reissue from that path, just let it fail with
458 	 * -EAGAIN.
459 	 */
460 	if (percpu_ref_is_dying(&ctx->refs))
461 		return false;
462 
463 	io_meta_restore(io, &rw->kiocb);
464 	iov_iter_restore(&io->iter, &io->iter_state);
465 	return true;
466 #else
467 	return false;
468 #endif
469 }
470 
io_req_end_write(struct io_kiocb * req)471 static void io_req_end_write(struct io_kiocb *req)
472 {
473 	if (req->flags & REQ_F_ISREG) {
474 		struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
475 
476 		kiocb_end_write(&rw->kiocb);
477 	}
478 }
479 
480 /*
481  * Trigger the notifications after having done some IO, and finish the write
482  * accounting, if any.
483  */
io_req_io_end(struct io_kiocb * req)484 static void io_req_io_end(struct io_kiocb *req)
485 {
486 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
487 
488 	if (rw->kiocb.ki_flags & IOCB_WRITE) {
489 		io_req_end_write(req);
490 		fsnotify_modify(req->file);
491 	} else {
492 		fsnotify_access(req->file);
493 	}
494 }
495 
__io_complete_rw_common(struct io_kiocb * req,long res)496 static void __io_complete_rw_common(struct io_kiocb *req, long res)
497 {
498 	if (res == req->cqe.res)
499 		return;
500 	if (res == -EAGAIN && io_rw_should_reissue(req)) {
501 		req->flags |= REQ_F_REISSUE | REQ_F_BL_NO_RECYCLE;
502 	} else {
503 		req_set_fail(req);
504 		req->cqe.res = res;
505 	}
506 }
507 
io_fixup_rw_res(struct io_kiocb * req,long res)508 static inline int io_fixup_rw_res(struct io_kiocb *req, long res)
509 {
510 	struct io_async_rw *io = req->async_data;
511 
512 	/* add previously done IO, if any */
513 	if (req_has_async_data(req) && io->bytes_done > 0) {
514 		if (res < 0)
515 			res = io->bytes_done;
516 		else
517 			res += io->bytes_done;
518 	}
519 	return res;
520 }
521 
io_req_rw_complete(struct io_kiocb * req,struct io_tw_state * ts)522 void io_req_rw_complete(struct io_kiocb *req, struct io_tw_state *ts)
523 {
524 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
525 	struct kiocb *kiocb = &rw->kiocb;
526 
527 	if ((kiocb->ki_flags & IOCB_DIO_CALLER_COMP) && kiocb->dio_complete) {
528 		long res = kiocb->dio_complete(rw->kiocb.private);
529 
530 		io_req_set_res(req, io_fixup_rw_res(req, res), 0);
531 	}
532 
533 	io_req_io_end(req);
534 
535 	if (req->flags & (REQ_F_BUFFER_SELECTED|REQ_F_BUFFER_RING))
536 		req->cqe.flags |= io_put_kbuf(req, req->cqe.res, 0);
537 
538 	io_req_rw_cleanup(req, 0);
539 	io_req_task_complete(req, ts);
540 }
541 
io_complete_rw(struct kiocb * kiocb,long res)542 static void io_complete_rw(struct kiocb *kiocb, long res)
543 {
544 	struct io_rw *rw = container_of(kiocb, struct io_rw, kiocb);
545 	struct io_kiocb *req = cmd_to_io_kiocb(rw);
546 
547 	if (!kiocb->dio_complete || !(kiocb->ki_flags & IOCB_DIO_CALLER_COMP)) {
548 		__io_complete_rw_common(req, res);
549 		io_req_set_res(req, io_fixup_rw_res(req, res), 0);
550 	}
551 	req->io_task_work.func = io_req_rw_complete;
552 	__io_req_task_work_add(req, IOU_F_TWQ_LAZY_WAKE);
553 }
554 
io_complete_rw_iopoll(struct kiocb * kiocb,long res)555 static void io_complete_rw_iopoll(struct kiocb *kiocb, long res)
556 {
557 	struct io_rw *rw = container_of(kiocb, struct io_rw, kiocb);
558 	struct io_kiocb *req = cmd_to_io_kiocb(rw);
559 
560 	if (kiocb->ki_flags & IOCB_WRITE)
561 		io_req_end_write(req);
562 	if (unlikely(res != req->cqe.res)) {
563 		if (res == -EAGAIN && io_rw_should_reissue(req))
564 			req->flags |= REQ_F_REISSUE | REQ_F_BL_NO_RECYCLE;
565 		else
566 			req->cqe.res = res;
567 	}
568 
569 	/* order with io_iopoll_complete() checking ->iopoll_completed */
570 	smp_store_release(&req->iopoll_completed, 1);
571 }
572 
io_rw_done(struct io_kiocb * req,ssize_t ret)573 static inline void io_rw_done(struct io_kiocb *req, ssize_t ret)
574 {
575 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
576 
577 	/* IO was queued async, completion will happen later */
578 	if (ret == -EIOCBQUEUED)
579 		return;
580 
581 	/* transform internal restart error codes */
582 	if (unlikely(ret < 0)) {
583 		switch (ret) {
584 		case -ERESTARTSYS:
585 		case -ERESTARTNOINTR:
586 		case -ERESTARTNOHAND:
587 		case -ERESTART_RESTARTBLOCK:
588 			/*
589 			 * We can't just restart the syscall, since previously
590 			 * submitted sqes may already be in progress. Just fail
591 			 * this IO with EINTR.
592 			 */
593 			ret = -EINTR;
594 			break;
595 		}
596 	}
597 
598 	if (req->ctx->flags & IORING_SETUP_IOPOLL)
599 		io_complete_rw_iopoll(&rw->kiocb, ret);
600 	else
601 		io_complete_rw(&rw->kiocb, ret);
602 }
603 
kiocb_done(struct io_kiocb * req,ssize_t ret,unsigned int issue_flags)604 static int kiocb_done(struct io_kiocb *req, ssize_t ret,
605 		       unsigned int issue_flags)
606 {
607 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
608 	unsigned final_ret = io_fixup_rw_res(req, ret);
609 
610 	if (ret >= 0 && req->flags & REQ_F_CUR_POS)
611 		req->file->f_pos = rw->kiocb.ki_pos;
612 	if (ret >= 0 && !(req->ctx->flags & IORING_SETUP_IOPOLL)) {
613 		__io_complete_rw_common(req, ret);
614 		/*
615 		 * Safe to call io_end from here as we're inline
616 		 * from the submission path.
617 		 */
618 		io_req_io_end(req);
619 		io_req_set_res(req, final_ret, io_put_kbuf(req, ret, issue_flags));
620 		io_req_rw_cleanup(req, issue_flags);
621 		return IOU_OK;
622 	} else {
623 		io_rw_done(req, ret);
624 	}
625 
626 	return IOU_ISSUE_SKIP_COMPLETE;
627 }
628 
io_kiocb_ppos(struct kiocb * kiocb)629 static inline loff_t *io_kiocb_ppos(struct kiocb *kiocb)
630 {
631 	return (kiocb->ki_filp->f_mode & FMODE_STREAM) ? NULL : &kiocb->ki_pos;
632 }
633 
634 /*
635  * For files that don't have ->read_iter() and ->write_iter(), handle them
636  * by looping over ->read() or ->write() manually.
637  */
loop_rw_iter(int ddir,struct io_rw * rw,struct iov_iter * iter)638 static ssize_t loop_rw_iter(int ddir, struct io_rw *rw, struct iov_iter *iter)
639 {
640 	struct kiocb *kiocb = &rw->kiocb;
641 	struct file *file = kiocb->ki_filp;
642 	ssize_t ret = 0;
643 	loff_t *ppos;
644 
645 	/*
646 	 * Don't support polled IO through this interface, and we can't
647 	 * support non-blocking either. For the latter, this just causes
648 	 * the kiocb to be handled from an async context.
649 	 */
650 	if (kiocb->ki_flags & IOCB_HIPRI)
651 		return -EOPNOTSUPP;
652 	if ((kiocb->ki_flags & IOCB_NOWAIT) &&
653 	    !(kiocb->ki_filp->f_flags & O_NONBLOCK))
654 		return -EAGAIN;
655 
656 	ppos = io_kiocb_ppos(kiocb);
657 
658 	while (iov_iter_count(iter)) {
659 		void __user *addr;
660 		size_t len;
661 		ssize_t nr;
662 
663 		if (iter_is_ubuf(iter)) {
664 			addr = iter->ubuf + iter->iov_offset;
665 			len = iov_iter_count(iter);
666 		} else if (!iov_iter_is_bvec(iter)) {
667 			addr = iter_iov_addr(iter);
668 			len = iter_iov_len(iter);
669 		} else {
670 			addr = u64_to_user_ptr(rw->addr);
671 			len = rw->len;
672 		}
673 
674 		if (ddir == READ)
675 			nr = file->f_op->read(file, addr, len, ppos);
676 		else
677 			nr = file->f_op->write(file, addr, len, ppos);
678 
679 		if (nr < 0) {
680 			if (!ret)
681 				ret = nr;
682 			break;
683 		}
684 		ret += nr;
685 		if (!iov_iter_is_bvec(iter)) {
686 			iov_iter_advance(iter, nr);
687 		} else {
688 			rw->addr += nr;
689 			rw->len -= nr;
690 			if (!rw->len)
691 				break;
692 		}
693 		if (nr != len)
694 			break;
695 	}
696 
697 	return ret;
698 }
699 
700 /*
701  * This is our waitqueue callback handler, registered through __folio_lock_async()
702  * when we initially tried to do the IO with the iocb armed our waitqueue.
703  * This gets called when the page is unlocked, and we generally expect that to
704  * happen when the page IO is completed and the page is now uptodate. This will
705  * queue a task_work based retry of the operation, attempting to copy the data
706  * again. If the latter fails because the page was NOT uptodate, then we will
707  * do a thread based blocking retry of the operation. That's the unexpected
708  * slow path.
709  */
io_async_buf_func(struct wait_queue_entry * wait,unsigned mode,int sync,void * arg)710 static int io_async_buf_func(struct wait_queue_entry *wait, unsigned mode,
711 			     int sync, void *arg)
712 {
713 	struct wait_page_queue *wpq;
714 	struct io_kiocb *req = wait->private;
715 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
716 	struct wait_page_key *key = arg;
717 
718 	wpq = container_of(wait, struct wait_page_queue, wait);
719 
720 	if (!wake_page_match(wpq, key))
721 		return 0;
722 
723 	rw->kiocb.ki_flags &= ~IOCB_WAITQ;
724 	list_del_init(&wait->entry);
725 	io_req_task_queue(req);
726 	return 1;
727 }
728 
729 /*
730  * This controls whether a given IO request should be armed for async page
731  * based retry. If we return false here, the request is handed to the async
732  * worker threads for retry. If we're doing buffered reads on a regular file,
733  * we prepare a private wait_page_queue entry and retry the operation. This
734  * will either succeed because the page is now uptodate and unlocked, or it
735  * will register a callback when the page is unlocked at IO completion. Through
736  * that callback, io_uring uses task_work to setup a retry of the operation.
737  * That retry will attempt the buffered read again. The retry will generally
738  * succeed, or in rare cases where it fails, we then fall back to using the
739  * async worker threads for a blocking retry.
740  */
io_rw_should_retry(struct io_kiocb * req)741 static bool io_rw_should_retry(struct io_kiocb *req)
742 {
743 	struct io_async_rw *io = req->async_data;
744 	struct wait_page_queue *wait = &io->wpq;
745 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
746 	struct kiocb *kiocb = &rw->kiocb;
747 
748 	/*
749 	 * Never retry for NOWAIT or a request with metadata, we just complete
750 	 * with -EAGAIN.
751 	 */
752 	if (req->flags & (REQ_F_NOWAIT | REQ_F_HAS_METADATA))
753 		return false;
754 
755 	/* Only for buffered IO */
756 	if (kiocb->ki_flags & (IOCB_DIRECT | IOCB_HIPRI))
757 		return false;
758 
759 	/*
760 	 * just use poll if we can, and don't attempt if the fs doesn't
761 	 * support callback based unlocks
762 	 */
763 	if (io_file_can_poll(req) ||
764 	    !(req->file->f_op->fop_flags & FOP_BUFFER_RASYNC))
765 		return false;
766 
767 	wait->wait.func = io_async_buf_func;
768 	wait->wait.private = req;
769 	wait->wait.flags = 0;
770 	INIT_LIST_HEAD(&wait->wait.entry);
771 	kiocb->ki_flags |= IOCB_WAITQ;
772 	kiocb->ki_flags &= ~IOCB_NOWAIT;
773 	kiocb->ki_waitq = wait;
774 	return true;
775 }
776 
io_iter_do_read(struct io_rw * rw,struct iov_iter * iter)777 static inline int io_iter_do_read(struct io_rw *rw, struct iov_iter *iter)
778 {
779 	struct file *file = rw->kiocb.ki_filp;
780 
781 	if (likely(file->f_op->read_iter))
782 		return file->f_op->read_iter(&rw->kiocb, iter);
783 	else if (file->f_op->read)
784 		return loop_rw_iter(READ, rw, iter);
785 	else
786 		return -EINVAL;
787 }
788 
need_complete_io(struct io_kiocb * req)789 static bool need_complete_io(struct io_kiocb *req)
790 {
791 	return req->flags & REQ_F_ISREG ||
792 		S_ISBLK(file_inode(req->file)->i_mode);
793 }
794 
io_rw_init_file(struct io_kiocb * req,fmode_t mode,int rw_type)795 static int io_rw_init_file(struct io_kiocb *req, fmode_t mode, int rw_type)
796 {
797 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
798 	struct kiocb *kiocb = &rw->kiocb;
799 	struct io_ring_ctx *ctx = req->ctx;
800 	struct file *file = req->file;
801 	int ret;
802 
803 	if (unlikely(!(file->f_mode & mode)))
804 		return -EBADF;
805 
806 	if (!(req->flags & REQ_F_FIXED_FILE))
807 		req->flags |= io_file_get_flags(file);
808 
809 	kiocb->ki_flags = file->f_iocb_flags;
810 	ret = kiocb_set_rw_flags(kiocb, rw->flags, rw_type);
811 	if (unlikely(ret))
812 		return ret;
813 	kiocb->ki_flags |= IOCB_ALLOC_CACHE;
814 
815 	/*
816 	 * If the file is marked O_NONBLOCK, still allow retry for it if it
817 	 * supports async. Otherwise it's impossible to use O_NONBLOCK files
818 	 * reliably. If not, or it IOCB_NOWAIT is set, don't retry.
819 	 */
820 	if (kiocb->ki_flags & IOCB_NOWAIT ||
821 	    ((file->f_flags & O_NONBLOCK && !(req->flags & REQ_F_SUPPORT_NOWAIT))))
822 		req->flags |= REQ_F_NOWAIT;
823 
824 	if (ctx->flags & IORING_SETUP_IOPOLL) {
825 		if (!(kiocb->ki_flags & IOCB_DIRECT) || !file->f_op->iopoll)
826 			return -EOPNOTSUPP;
827 		kiocb->private = NULL;
828 		kiocb->ki_flags |= IOCB_HIPRI;
829 		req->iopoll_completed = 0;
830 		if (ctx->flags & IORING_SETUP_HYBRID_IOPOLL) {
831 			/* make sure every req only blocks once*/
832 			req->flags &= ~REQ_F_IOPOLL_STATE;
833 			req->iopoll_start = ktime_get_ns();
834 		}
835 	} else {
836 		if (kiocb->ki_flags & IOCB_HIPRI)
837 			return -EINVAL;
838 	}
839 
840 	if (req->flags & REQ_F_HAS_METADATA) {
841 		struct io_async_rw *io = req->async_data;
842 
843 		/*
844 		 * We have a union of meta fields with wpq used for buffered-io
845 		 * in io_async_rw, so fail it here.
846 		 */
847 		if (!(req->file->f_flags & O_DIRECT))
848 			return -EOPNOTSUPP;
849 		kiocb->ki_flags |= IOCB_HAS_METADATA;
850 		kiocb->private = &io->meta;
851 	}
852 
853 	return 0;
854 }
855 
__io_read(struct io_kiocb * req,unsigned int issue_flags)856 static int __io_read(struct io_kiocb *req, unsigned int issue_flags)
857 {
858 	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
859 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
860 	struct io_async_rw *io = req->async_data;
861 	struct kiocb *kiocb = &rw->kiocb;
862 	ssize_t ret;
863 	loff_t *ppos;
864 
865 	if (io_do_buffer_select(req)) {
866 		ret = io_import_iovec(ITER_DEST, req, io, issue_flags);
867 		if (unlikely(ret < 0))
868 			return ret;
869 	}
870 	ret = io_rw_init_file(req, FMODE_READ, READ);
871 	if (unlikely(ret))
872 		return ret;
873 	req->cqe.res = iov_iter_count(&io->iter);
874 
875 	if (force_nonblock) {
876 		/* If the file doesn't support async, just async punt */
877 		if (unlikely(!io_file_supports_nowait(req, EPOLLIN)))
878 			return -EAGAIN;
879 		kiocb->ki_flags |= IOCB_NOWAIT;
880 	} else {
881 		/* Ensure we clear previously set non-block flag */
882 		kiocb->ki_flags &= ~IOCB_NOWAIT;
883 	}
884 
885 	ppos = io_kiocb_update_pos(req);
886 
887 	ret = rw_verify_area(READ, req->file, ppos, req->cqe.res);
888 	if (unlikely(ret))
889 		return ret;
890 
891 	ret = io_iter_do_read(rw, &io->iter);
892 
893 	/*
894 	 * Some file systems like to return -EOPNOTSUPP for an IOCB_NOWAIT
895 	 * issue, even though they should be returning -EAGAIN. To be safe,
896 	 * retry from blocking context for either.
897 	 */
898 	if (ret == -EOPNOTSUPP && force_nonblock)
899 		ret = -EAGAIN;
900 
901 	if (ret == -EAGAIN) {
902 		/* If we can poll, just do that. */
903 		if (io_file_can_poll(req))
904 			return -EAGAIN;
905 		/* IOPOLL retry should happen for io-wq threads */
906 		if (!force_nonblock && !(req->ctx->flags & IORING_SETUP_IOPOLL))
907 			goto done;
908 		/* no retry on NONBLOCK nor RWF_NOWAIT */
909 		if (req->flags & REQ_F_NOWAIT)
910 			goto done;
911 		ret = 0;
912 	} else if (ret == -EIOCBQUEUED) {
913 		return IOU_ISSUE_SKIP_COMPLETE;
914 	} else if (ret == req->cqe.res || ret <= 0 || !force_nonblock ||
915 		   (req->flags & REQ_F_NOWAIT) || !need_complete_io(req) ||
916 		   (issue_flags & IO_URING_F_MULTISHOT)) {
917 		/* read all, failed, already did sync or don't want to retry */
918 		goto done;
919 	}
920 
921 	/*
922 	 * Don't depend on the iter state matching what was consumed, or being
923 	 * untouched in case of error. Restore it and we'll advance it
924 	 * manually if we need to.
925 	 */
926 	iov_iter_restore(&io->iter, &io->iter_state);
927 	io_meta_restore(io, kiocb);
928 
929 	do {
930 		/*
931 		 * We end up here because of a partial read, either from
932 		 * above or inside this loop. Advance the iter by the bytes
933 		 * that were consumed.
934 		 */
935 		iov_iter_advance(&io->iter, ret);
936 		if (!iov_iter_count(&io->iter))
937 			break;
938 		io->bytes_done += ret;
939 		iov_iter_save_state(&io->iter, &io->iter_state);
940 
941 		/* if we can retry, do so with the callbacks armed */
942 		if (!io_rw_should_retry(req)) {
943 			kiocb->ki_flags &= ~IOCB_WAITQ;
944 			return -EAGAIN;
945 		}
946 
947 		req->cqe.res = iov_iter_count(&io->iter);
948 		/*
949 		 * Now retry read with the IOCB_WAITQ parts set in the iocb. If
950 		 * we get -EIOCBQUEUED, then we'll get a notification when the
951 		 * desired page gets unlocked. We can also get a partial read
952 		 * here, and if we do, then just retry at the new offset.
953 		 */
954 		ret = io_iter_do_read(rw, &io->iter);
955 		if (ret == -EIOCBQUEUED)
956 			return IOU_ISSUE_SKIP_COMPLETE;
957 		/* we got some bytes, but not all. retry. */
958 		kiocb->ki_flags &= ~IOCB_WAITQ;
959 		iov_iter_restore(&io->iter, &io->iter_state);
960 	} while (ret > 0);
961 done:
962 	/* it's faster to check here then delegate to kfree */
963 	return ret;
964 }
965 
io_read(struct io_kiocb * req,unsigned int issue_flags)966 int io_read(struct io_kiocb *req, unsigned int issue_flags)
967 {
968 	int ret;
969 
970 	ret = __io_read(req, issue_flags);
971 	if (ret >= 0)
972 		return kiocb_done(req, ret, issue_flags);
973 
974 	return ret;
975 }
976 
io_read_mshot(struct io_kiocb * req,unsigned int issue_flags)977 int io_read_mshot(struct io_kiocb *req, unsigned int issue_flags)
978 {
979 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
980 	unsigned int cflags = 0;
981 	int ret;
982 
983 	/*
984 	 * Multishot MUST be used on a pollable file
985 	 */
986 	if (!io_file_can_poll(req))
987 		return -EBADFD;
988 
989 	/* make it sync, multishot doesn't support async execution */
990 	rw->kiocb.ki_complete = NULL;
991 	ret = __io_read(req, issue_flags);
992 
993 	/*
994 	 * If we get -EAGAIN, recycle our buffer and just let normal poll
995 	 * handling arm it.
996 	 */
997 	if (ret == -EAGAIN) {
998 		/*
999 		 * Reset rw->len to 0 again to avoid clamping future mshot
1000 		 * reads, in case the buffer size varies.
1001 		 */
1002 		if (io_kbuf_recycle(req, issue_flags))
1003 			rw->len = 0;
1004 		if (issue_flags & IO_URING_F_MULTISHOT)
1005 			return IOU_ISSUE_SKIP_COMPLETE;
1006 		return -EAGAIN;
1007 	} else if (ret <= 0) {
1008 		io_kbuf_recycle(req, issue_flags);
1009 		if (ret < 0)
1010 			req_set_fail(req);
1011 	} else if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
1012 		cflags = io_put_kbuf(req, ret, issue_flags);
1013 	} else {
1014 		/*
1015 		 * Any successful return value will keep the multishot read
1016 		 * armed, if it's still set. Put our buffer and post a CQE. If
1017 		 * we fail to post a CQE, or multishot is no longer set, then
1018 		 * jump to the termination path. This request is then done.
1019 		 */
1020 		cflags = io_put_kbuf(req, ret, issue_flags);
1021 		rw->len = 0; /* similarly to above, reset len to 0 */
1022 
1023 		if (io_req_post_cqe(req, ret, cflags | IORING_CQE_F_MORE)) {
1024 			if (issue_flags & IO_URING_F_MULTISHOT) {
1025 				/*
1026 				 * Force retry, as we might have more data to
1027 				 * be read and otherwise it won't get retried
1028 				 * until (if ever) another poll is triggered.
1029 				 */
1030 				io_poll_multishot_retry(req);
1031 				return IOU_ISSUE_SKIP_COMPLETE;
1032 			}
1033 			return -EAGAIN;
1034 		}
1035 	}
1036 
1037 	/*
1038 	 * Either an error, or we've hit overflow posting the CQE. For any
1039 	 * multishot request, hitting overflow will terminate it.
1040 	 */
1041 	io_req_set_res(req, ret, cflags);
1042 	io_req_rw_cleanup(req, issue_flags);
1043 	if (issue_flags & IO_URING_F_MULTISHOT)
1044 		return IOU_STOP_MULTISHOT;
1045 	return IOU_OK;
1046 }
1047 
io_kiocb_start_write(struct io_kiocb * req,struct kiocb * kiocb)1048 static bool io_kiocb_start_write(struct io_kiocb *req, struct kiocb *kiocb)
1049 {
1050 	struct inode *inode;
1051 	bool ret;
1052 
1053 	if (!(req->flags & REQ_F_ISREG))
1054 		return true;
1055 	if (!(kiocb->ki_flags & IOCB_NOWAIT)) {
1056 		kiocb_start_write(kiocb);
1057 		return true;
1058 	}
1059 
1060 	inode = file_inode(kiocb->ki_filp);
1061 	ret = sb_start_write_trylock(inode->i_sb);
1062 	if (ret)
1063 		__sb_writers_release(inode->i_sb, SB_FREEZE_WRITE);
1064 	return ret;
1065 }
1066 
io_write(struct io_kiocb * req,unsigned int issue_flags)1067 int io_write(struct io_kiocb *req, unsigned int issue_flags)
1068 {
1069 	bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
1070 	struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
1071 	struct io_async_rw *io = req->async_data;
1072 	struct kiocb *kiocb = &rw->kiocb;
1073 	ssize_t ret, ret2;
1074 	loff_t *ppos;
1075 
1076 	ret = io_rw_init_file(req, FMODE_WRITE, WRITE);
1077 	if (unlikely(ret))
1078 		return ret;
1079 	req->cqe.res = iov_iter_count(&io->iter);
1080 
1081 	if (force_nonblock) {
1082 		/* If the file doesn't support async, just async punt */
1083 		if (unlikely(!io_file_supports_nowait(req, EPOLLOUT)))
1084 			goto ret_eagain;
1085 
1086 		/* Check if we can support NOWAIT. */
1087 		if (!(kiocb->ki_flags & IOCB_DIRECT) &&
1088 		    !(req->file->f_op->fop_flags & FOP_BUFFER_WASYNC) &&
1089 		    (req->flags & REQ_F_ISREG))
1090 			goto ret_eagain;
1091 
1092 		kiocb->ki_flags |= IOCB_NOWAIT;
1093 	} else {
1094 		/* Ensure we clear previously set non-block flag */
1095 		kiocb->ki_flags &= ~IOCB_NOWAIT;
1096 	}
1097 
1098 	ppos = io_kiocb_update_pos(req);
1099 
1100 	ret = rw_verify_area(WRITE, req->file, ppos, req->cqe.res);
1101 	if (unlikely(ret))
1102 		return ret;
1103 
1104 	if (unlikely(!io_kiocb_start_write(req, kiocb)))
1105 		return -EAGAIN;
1106 	kiocb->ki_flags |= IOCB_WRITE;
1107 
1108 	if (likely(req->file->f_op->write_iter))
1109 		ret2 = req->file->f_op->write_iter(kiocb, &io->iter);
1110 	else if (req->file->f_op->write)
1111 		ret2 = loop_rw_iter(WRITE, rw, &io->iter);
1112 	else
1113 		ret2 = -EINVAL;
1114 
1115 	/*
1116 	 * Raw bdev writes will return -EOPNOTSUPP for IOCB_NOWAIT. Just
1117 	 * retry them without IOCB_NOWAIT.
1118 	 */
1119 	if (ret2 == -EOPNOTSUPP && (kiocb->ki_flags & IOCB_NOWAIT))
1120 		ret2 = -EAGAIN;
1121 	/* no retry on NONBLOCK nor RWF_NOWAIT */
1122 	if (ret2 == -EAGAIN && (req->flags & REQ_F_NOWAIT))
1123 		goto done;
1124 	if (!force_nonblock || ret2 != -EAGAIN) {
1125 		/* IOPOLL retry should happen for io-wq threads */
1126 		if (ret2 == -EAGAIN && (req->ctx->flags & IORING_SETUP_IOPOLL))
1127 			goto ret_eagain;
1128 
1129 		if (ret2 != req->cqe.res && ret2 >= 0 && need_complete_io(req)) {
1130 			trace_io_uring_short_write(req->ctx, kiocb->ki_pos - ret2,
1131 						req->cqe.res, ret2);
1132 
1133 			/* This is a partial write. The file pos has already been
1134 			 * updated, setup the async struct to complete the request
1135 			 * in the worker. Also update bytes_done to account for
1136 			 * the bytes already written.
1137 			 */
1138 			iov_iter_save_state(&io->iter, &io->iter_state);
1139 			io->bytes_done += ret2;
1140 
1141 			if (kiocb->ki_flags & IOCB_WRITE)
1142 				io_req_end_write(req);
1143 			return -EAGAIN;
1144 		}
1145 done:
1146 		return kiocb_done(req, ret2, issue_flags);
1147 	} else {
1148 ret_eagain:
1149 		iov_iter_restore(&io->iter, &io->iter_state);
1150 		io_meta_restore(io, kiocb);
1151 		if (kiocb->ki_flags & IOCB_WRITE)
1152 			io_req_end_write(req);
1153 		return -EAGAIN;
1154 	}
1155 }
1156 
io_rw_fail(struct io_kiocb * req)1157 void io_rw_fail(struct io_kiocb *req)
1158 {
1159 	int res;
1160 
1161 	res = io_fixup_rw_res(req, req->cqe.res);
1162 	io_req_set_res(req, res, req->cqe.flags);
1163 }
1164 
io_uring_classic_poll(struct io_kiocb * req,struct io_comp_batch * iob,unsigned int poll_flags)1165 static int io_uring_classic_poll(struct io_kiocb *req, struct io_comp_batch *iob,
1166 				unsigned int poll_flags)
1167 {
1168 	struct file *file = req->file;
1169 
1170 	if (req->opcode == IORING_OP_URING_CMD) {
1171 		struct io_uring_cmd *ioucmd;
1172 
1173 		ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);
1174 		return file->f_op->uring_cmd_iopoll(ioucmd, iob, poll_flags);
1175 	} else {
1176 		struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);
1177 
1178 		return file->f_op->iopoll(&rw->kiocb, iob, poll_flags);
1179 	}
1180 }
1181 
io_hybrid_iopoll_delay(struct io_ring_ctx * ctx,struct io_kiocb * req)1182 static u64 io_hybrid_iopoll_delay(struct io_ring_ctx *ctx, struct io_kiocb *req)
1183 {
1184 	struct hrtimer_sleeper timer;
1185 	enum hrtimer_mode mode;
1186 	ktime_t kt;
1187 	u64 sleep_time;
1188 
1189 	if (req->flags & REQ_F_IOPOLL_STATE)
1190 		return 0;
1191 
1192 	if (ctx->hybrid_poll_time == LLONG_MAX)
1193 		return 0;
1194 
1195 	/* Using half the running time to do schedule */
1196 	sleep_time = ctx->hybrid_poll_time / 2;
1197 
1198 	kt = ktime_set(0, sleep_time);
1199 	req->flags |= REQ_F_IOPOLL_STATE;
1200 
1201 	mode = HRTIMER_MODE_REL;
1202 	hrtimer_setup_sleeper_on_stack(&timer, CLOCK_MONOTONIC, mode);
1203 	hrtimer_set_expires(&timer.timer, kt);
1204 	set_current_state(TASK_INTERRUPTIBLE);
1205 	hrtimer_sleeper_start_expires(&timer, mode);
1206 
1207 	if (timer.task)
1208 		io_schedule();
1209 
1210 	hrtimer_cancel(&timer.timer);
1211 	__set_current_state(TASK_RUNNING);
1212 	destroy_hrtimer_on_stack(&timer.timer);
1213 	return sleep_time;
1214 }
1215 
io_uring_hybrid_poll(struct io_kiocb * req,struct io_comp_batch * iob,unsigned int poll_flags)1216 static int io_uring_hybrid_poll(struct io_kiocb *req,
1217 				struct io_comp_batch *iob, unsigned int poll_flags)
1218 {
1219 	struct io_ring_ctx *ctx = req->ctx;
1220 	u64 runtime, sleep_time;
1221 	int ret;
1222 
1223 	sleep_time = io_hybrid_iopoll_delay(ctx, req);
1224 	ret = io_uring_classic_poll(req, iob, poll_flags);
1225 	runtime = ktime_get_ns() - req->iopoll_start - sleep_time;
1226 
1227 	/*
1228 	 * Use minimum sleep time if we're polling devices with different
1229 	 * latencies. We could get more completions from the faster ones.
1230 	 */
1231 	if (ctx->hybrid_poll_time > runtime)
1232 		ctx->hybrid_poll_time = runtime;
1233 
1234 	return ret;
1235 }
1236 
io_do_iopoll(struct io_ring_ctx * ctx,bool force_nonspin)1237 int io_do_iopoll(struct io_ring_ctx *ctx, bool force_nonspin)
1238 {
1239 	struct io_wq_work_node *pos, *start, *prev;
1240 	unsigned int poll_flags = 0;
1241 	DEFINE_IO_COMP_BATCH(iob);
1242 	int nr_events = 0;
1243 
1244 	/*
1245 	 * Only spin for completions if we don't have multiple devices hanging
1246 	 * off our complete list.
1247 	 */
1248 	if (ctx->poll_multi_queue || force_nonspin)
1249 		poll_flags |= BLK_POLL_ONESHOT;
1250 
1251 	wq_list_for_each(pos, start, &ctx->iopoll_list) {
1252 		struct io_kiocb *req = container_of(pos, struct io_kiocb, comp_list);
1253 		int ret;
1254 
1255 		/*
1256 		 * Move completed and retryable entries to our local lists.
1257 		 * If we find a request that requires polling, break out
1258 		 * and complete those lists first, if we have entries there.
1259 		 */
1260 		if (READ_ONCE(req->iopoll_completed))
1261 			break;
1262 
1263 		if (ctx->flags & IORING_SETUP_HYBRID_IOPOLL)
1264 			ret = io_uring_hybrid_poll(req, &iob, poll_flags);
1265 		else
1266 			ret = io_uring_classic_poll(req, &iob, poll_flags);
1267 
1268 		if (unlikely(ret < 0))
1269 			return ret;
1270 		else if (ret)
1271 			poll_flags |= BLK_POLL_ONESHOT;
1272 
1273 		/* iopoll may have completed current req */
1274 		if (!rq_list_empty(&iob.req_list) ||
1275 		    READ_ONCE(req->iopoll_completed))
1276 			break;
1277 	}
1278 
1279 	if (!rq_list_empty(&iob.req_list))
1280 		iob.complete(&iob);
1281 	else if (!pos)
1282 		return 0;
1283 
1284 	prev = start;
1285 	wq_list_for_each_resume(pos, prev) {
1286 		struct io_kiocb *req = container_of(pos, struct io_kiocb, comp_list);
1287 
1288 		/* order with io_complete_rw_iopoll(), e.g. ->result updates */
1289 		if (!smp_load_acquire(&req->iopoll_completed))
1290 			break;
1291 		nr_events++;
1292 		req->cqe.flags = io_put_kbuf(req, req->cqe.res, 0);
1293 		if (req->opcode != IORING_OP_URING_CMD)
1294 			io_req_rw_cleanup(req, 0);
1295 	}
1296 	if (unlikely(!nr_events))
1297 		return 0;
1298 
1299 	pos = start ? start->next : ctx->iopoll_list.first;
1300 	wq_list_cut(&ctx->iopoll_list, prev, start);
1301 
1302 	if (WARN_ON_ONCE(!wq_list_empty(&ctx->submit_state.compl_reqs)))
1303 		return 0;
1304 	ctx->submit_state.compl_reqs.first = pos;
1305 	__io_submit_flush_completions(ctx);
1306 	return nr_events;
1307 }
1308 
io_rw_cache_free(const void * entry)1309 void io_rw_cache_free(const void *entry)
1310 {
1311 	struct io_async_rw *rw = (struct io_async_rw *) entry;
1312 
1313 	if (rw->free_iovec)
1314 		kfree(rw->free_iovec);
1315 	kfree(rw);
1316 }
1317