Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Copyright (C) 2010 Red Hat, Inc.
4 : : * Copyright (c) 2016-2018 Christoph Hellwig.
5 : : */
6 : : #include <linux/module.h>
7 : : #include <linux/compiler.h>
8 : : #include <linux/fs.h>
9 : : #include <linux/iomap.h>
10 : : #include <linux/backing-dev.h>
11 : : #include <linux/uio.h>
12 : : #include <linux/task_io_accounting_ops.h>
13 : :
14 : : #include "../internal.h"
15 : :
16 : : /*
17 : : * Private flags for iomap_dio, must not overlap with the public ones in
18 : : * iomap.h:
19 : : */
20 : : #define IOMAP_DIO_WRITE_FUA (1 << 28)
21 : : #define IOMAP_DIO_NEED_SYNC (1 << 29)
22 : : #define IOMAP_DIO_WRITE (1 << 30)
23 : : #define IOMAP_DIO_DIRTY (1 << 31)
24 : :
25 : : struct iomap_dio {
26 : : struct kiocb *iocb;
27 : : const struct iomap_dio_ops *dops;
28 : : loff_t i_size;
29 : : loff_t size;
30 : : atomic_t ref;
31 : : unsigned flags;
32 : : int error;
33 : : bool wait_for_completion;
34 : :
35 : : union {
36 : : /* used during submission and for synchronous completion: */
37 : : struct {
38 : : struct iov_iter *iter;
39 : : struct task_struct *waiter;
40 : : struct request_queue *last_queue;
41 : : blk_qc_t cookie;
42 : : } submit;
43 : :
44 : : /* used for aio completion: */
45 : : struct {
46 : : struct work_struct work;
47 : : } aio;
48 : : };
49 : : };
50 : :
51 : 0 : int iomap_dio_iopoll(struct kiocb *kiocb, bool spin)
52 : : {
53 : : struct request_queue *q = READ_ONCE(kiocb->private);
54 : :
55 : 0 : if (!q)
56 : : return 0;
57 : 0 : return blk_poll(q, READ_ONCE(kiocb->ki_cookie), spin);
58 : : }
59 : : EXPORT_SYMBOL_GPL(iomap_dio_iopoll);
60 : :
61 : 0 : static void iomap_dio_submit_bio(struct iomap_dio *dio, struct iomap *iomap,
62 : : struct bio *bio)
63 : : {
64 : 0 : atomic_inc(&dio->ref);
65 : :
66 : 0 : if (dio->iocb->ki_flags & IOCB_HIPRI)
67 : : bio_set_polled(bio, dio->iocb);
68 : :
69 : 0 : dio->submit.last_queue = bdev_get_queue(iomap->bdev);
70 : 0 : dio->submit.cookie = submit_bio(bio);
71 : 0 : }
72 : :
73 : 0 : static ssize_t iomap_dio_complete(struct iomap_dio *dio)
74 : : {
75 : 0 : const struct iomap_dio_ops *dops = dio->dops;
76 : 0 : struct kiocb *iocb = dio->iocb;
77 : 0 : struct inode *inode = file_inode(iocb->ki_filp);
78 : 0 : loff_t offset = iocb->ki_pos;
79 : 0 : ssize_t ret = dio->error;
80 : :
81 : 0 : if (dops && dops->end_io)
82 : 0 : ret = dops->end_io(iocb, dio->size, ret, dio->flags);
83 : :
84 : 0 : if (likely(!ret)) {
85 : 0 : ret = dio->size;
86 : : /* check for short read */
87 : 0 : if (offset + ret > dio->i_size &&
88 : 0 : !(dio->flags & IOMAP_DIO_WRITE))
89 : 0 : ret = dio->i_size - offset;
90 : 0 : iocb->ki_pos += ret;
91 : : }
92 : :
93 : : /*
94 : : * Try again to invalidate clean pages which might have been cached by
95 : : * non-direct readahead, or faulted in by get_user_pages() if the source
96 : : * of the write was an mmap'ed region of the file we're writing. Either
97 : : * one is a pretty crazy thing to do, so we don't support it 100%. If
98 : : * this invalidation fails, tough, the write still worked...
99 : : *
100 : : * And this page cache invalidation has to be after ->end_io(), as some
101 : : * filesystems convert unwritten extents to real allocations in
102 : : * ->end_io() when necessary, otherwise a racing buffer read would cache
103 : : * zeros from unwritten extents.
104 : : */
105 : 0 : if (!dio->error &&
106 : 0 : (dio->flags & IOMAP_DIO_WRITE) && inode->i_mapping->nrpages) {
107 : : int err;
108 : 0 : err = invalidate_inode_pages2_range(inode->i_mapping,
109 : 0 : offset >> PAGE_SHIFT,
110 : 0 : (offset + dio->size - 1) >> PAGE_SHIFT);
111 : 0 : if (err)
112 : 0 : dio_warn_stale_pagecache(iocb->ki_filp);
113 : : }
114 : :
115 : : /*
116 : : * If this is a DSYNC write, make sure we push it to stable storage now
117 : : * that we've written data.
118 : : */
119 : 0 : if (ret > 0 && (dio->flags & IOMAP_DIO_NEED_SYNC))
120 : 0 : ret = generic_write_sync(iocb, ret);
121 : :
122 : 0 : inode_dio_end(file_inode(iocb->ki_filp));
123 : 0 : kfree(dio);
124 : :
125 : 0 : return ret;
126 : : }
127 : :
128 : 0 : static void iomap_dio_complete_work(struct work_struct *work)
129 : : {
130 : 0 : struct iomap_dio *dio = container_of(work, struct iomap_dio, aio.work);
131 : 0 : struct kiocb *iocb = dio->iocb;
132 : :
133 : 0 : iocb->ki_complete(iocb, iomap_dio_complete(dio), 0);
134 : 0 : }
135 : :
136 : : /*
137 : : * Set an error in the dio if none is set yet. We have to use cmpxchg
138 : : * as the submission context and the completion context(s) can race to
139 : : * update the error.
140 : : */
141 : : static inline void iomap_dio_set_error(struct iomap_dio *dio, int ret)
142 : : {
143 : 0 : cmpxchg(&dio->error, 0, ret);
144 : : }
145 : :
146 : 0 : static void iomap_dio_bio_end_io(struct bio *bio)
147 : : {
148 : 0 : struct iomap_dio *dio = bio->bi_private;
149 : 0 : bool should_dirty = (dio->flags & IOMAP_DIO_DIRTY);
150 : :
151 : 0 : if (bio->bi_status)
152 : 0 : iomap_dio_set_error(dio, blk_status_to_errno(bio->bi_status));
153 : :
154 : 0 : if (atomic_dec_and_test(&dio->ref)) {
155 : 0 : if (dio->wait_for_completion) {
156 : 0 : struct task_struct *waiter = dio->submit.waiter;
157 : : WRITE_ONCE(dio->submit.waiter, NULL);
158 : 0 : blk_wake_io_task(waiter);
159 : 0 : } else if (dio->flags & IOMAP_DIO_WRITE) {
160 : 0 : struct inode *inode = file_inode(dio->iocb->ki_filp);
161 : :
162 : 0 : INIT_WORK(&dio->aio.work, iomap_dio_complete_work);
163 : 0 : queue_work(inode->i_sb->s_dio_done_wq, &dio->aio.work);
164 : : } else {
165 : 0 : iomap_dio_complete_work(&dio->aio.work);
166 : : }
167 : : }
168 : :
169 : 0 : if (should_dirty) {
170 : 0 : bio_check_pages_dirty(bio);
171 : : } else {
172 : 0 : bio_release_pages(bio, false);
173 : 0 : bio_put(bio);
174 : : }
175 : 0 : }
176 : :
177 : : static void
178 : 0 : iomap_dio_zero(struct iomap_dio *dio, struct iomap *iomap, loff_t pos,
179 : : unsigned len)
180 : : {
181 : 0 : struct page *page = ZERO_PAGE(0);
182 : : int flags = REQ_SYNC | REQ_IDLE;
183 : : struct bio *bio;
184 : :
185 : : bio = bio_alloc(GFP_KERNEL, 1);
186 : 0 : bio_set_dev(bio, iomap->bdev);
187 : 0 : bio->bi_iter.bi_sector = iomap_sector(iomap, pos);
188 : 0 : bio->bi_private = dio;
189 : 0 : bio->bi_end_io = iomap_dio_bio_end_io;
190 : :
191 : 0 : get_page(page);
192 : 0 : __bio_add_page(bio, page, len, 0);
193 : : bio_set_op_attrs(bio, REQ_OP_WRITE, flags);
194 : 0 : iomap_dio_submit_bio(dio, iomap, bio);
195 : 0 : }
196 : :
197 : : static loff_t
198 : 0 : iomap_dio_bio_actor(struct inode *inode, loff_t pos, loff_t length,
199 : : struct iomap_dio *dio, struct iomap *iomap)
200 : : {
201 : 0 : unsigned int blkbits = blksize_bits(bdev_logical_block_size(iomap->bdev));
202 : : unsigned int fs_block_size = i_blocksize(inode), pad;
203 : 0 : unsigned int align = iov_iter_alignment(dio->submit.iter);
204 : : struct iov_iter iter;
205 : : struct bio *bio;
206 : : bool need_zeroout = false;
207 : : bool use_fua = false;
208 : : int nr_pages, ret = 0;
209 : : size_t copied = 0;
210 : :
211 : 0 : if ((pos | length | align) & ((1 << blkbits) - 1))
212 : : return -EINVAL;
213 : :
214 : 0 : if (iomap->type == IOMAP_UNWRITTEN) {
215 : 0 : dio->flags |= IOMAP_DIO_UNWRITTEN;
216 : : need_zeroout = true;
217 : : }
218 : :
219 : 0 : if (iomap->flags & IOMAP_F_SHARED)
220 : 0 : dio->flags |= IOMAP_DIO_COW;
221 : :
222 : 0 : if (iomap->flags & IOMAP_F_NEW) {
223 : : need_zeroout = true;
224 : 0 : } else if (iomap->type == IOMAP_MAPPED) {
225 : : /*
226 : : * Use a FUA write if we need datasync semantics, this is a pure
227 : : * data IO that doesn't require any metadata updates (including
228 : : * after IO completion such as unwritten extent conversion) and
229 : : * the underlying device supports FUA. This allows us to avoid
230 : : * cache flushes on IO completion.
231 : : */
232 : 0 : if (!(iomap->flags & (IOMAP_F_SHARED|IOMAP_F_DIRTY)) &&
233 : 0 : (dio->flags & IOMAP_DIO_WRITE_FUA) &&
234 : 0 : blk_queue_fua(bdev_get_queue(iomap->bdev)))
235 : : use_fua = true;
236 : : }
237 : :
238 : : /*
239 : : * Operate on a partial iter trimmed to the extent we were called for.
240 : : * We'll update the iter in the dio once we're done with this extent.
241 : : */
242 : 0 : iter = *dio->submit.iter;
243 : 0 : iov_iter_truncate(&iter, length);
244 : :
245 : 0 : nr_pages = iov_iter_npages(&iter, BIO_MAX_PAGES);
246 : 0 : if (nr_pages <= 0)
247 : 0 : return nr_pages;
248 : :
249 : 0 : if (need_zeroout) {
250 : : /* zero out from the start of the block to the write offset */
251 : 0 : pad = pos & (fs_block_size - 1);
252 : 0 : if (pad)
253 : 0 : iomap_dio_zero(dio, iomap, pos - pad, pad);
254 : : }
255 : :
256 : : do {
257 : : size_t n;
258 : 0 : if (dio->error) {
259 : 0 : iov_iter_revert(dio->submit.iter, copied);
260 : 0 : return 0;
261 : : }
262 : :
263 : 0 : bio = bio_alloc(GFP_KERNEL, nr_pages);
264 : 0 : bio_set_dev(bio, iomap->bdev);
265 : 0 : bio->bi_iter.bi_sector = iomap_sector(iomap, pos);
266 : 0 : bio->bi_write_hint = dio->iocb->ki_hint;
267 : 0 : bio->bi_ioprio = dio->iocb->ki_ioprio;
268 : 0 : bio->bi_private = dio;
269 : 0 : bio->bi_end_io = iomap_dio_bio_end_io;
270 : :
271 : 0 : ret = bio_iov_iter_get_pages(bio, &iter);
272 : 0 : if (unlikely(ret)) {
273 : : /*
274 : : * We have to stop part way through an IO. We must fall
275 : : * through to the sub-block tail zeroing here, otherwise
276 : : * this short IO may expose stale data in the tail of
277 : : * the block we haven't written data to.
278 : : */
279 : 0 : bio_put(bio);
280 : 0 : goto zero_tail;
281 : : }
282 : :
283 : 0 : n = bio->bi_iter.bi_size;
284 : 0 : if (dio->flags & IOMAP_DIO_WRITE) {
285 : 0 : bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
286 : 0 : if (use_fua)
287 : 0 : bio->bi_opf |= REQ_FUA;
288 : : else
289 : 0 : dio->flags &= ~IOMAP_DIO_WRITE_FUA;
290 : : task_io_account_write(n);
291 : : } else {
292 : 0 : bio->bi_opf = REQ_OP_READ;
293 : 0 : if (dio->flags & IOMAP_DIO_DIRTY)
294 : 0 : bio_set_pages_dirty(bio);
295 : : }
296 : :
297 : 0 : iov_iter_advance(dio->submit.iter, n);
298 : :
299 : 0 : dio->size += n;
300 : 0 : pos += n;
301 : 0 : copied += n;
302 : :
303 : 0 : nr_pages = iov_iter_npages(&iter, BIO_MAX_PAGES);
304 : 0 : iomap_dio_submit_bio(dio, iomap, bio);
305 : 0 : } while (nr_pages);
306 : :
307 : : /*
308 : : * We need to zeroout the tail of a sub-block write if the extent type
309 : : * requires zeroing or the write extends beyond EOF. If we don't zero
310 : : * the block tail in the latter case, we can expose stale data via mmap
311 : : * reads of the EOF block.
312 : : */
313 : : zero_tail:
314 : 0 : if (need_zeroout ||
315 : 0 : ((dio->flags & IOMAP_DIO_WRITE) && pos >= i_size_read(inode))) {
316 : : /* zero out from the end of the write to the end of the block */
317 : 0 : pad = pos & (fs_block_size - 1);
318 : 0 : if (pad)
319 : 0 : iomap_dio_zero(dio, iomap, pos, fs_block_size - pad);
320 : : }
321 : 0 : if (copied)
322 : 0 : return copied;
323 : 0 : return ret;
324 : : }
325 : :
326 : : static loff_t
327 : : iomap_dio_hole_actor(loff_t length, struct iomap_dio *dio)
328 : : {
329 : 0 : length = iov_iter_zero(length, dio->submit.iter);
330 : 0 : dio->size += length;
331 : : return length;
332 : : }
333 : :
334 : : static loff_t
335 : 0 : iomap_dio_inline_actor(struct inode *inode, loff_t pos, loff_t length,
336 : : struct iomap_dio *dio, struct iomap *iomap)
337 : : {
338 : 0 : struct iov_iter *iter = dio->submit.iter;
339 : : size_t copied;
340 : :
341 : 0 : BUG_ON(pos + length > PAGE_SIZE - offset_in_page(iomap->inline_data));
342 : :
343 : 0 : if (dio->flags & IOMAP_DIO_WRITE) {
344 : 0 : loff_t size = inode->i_size;
345 : :
346 : 0 : if (pos > size)
347 : 0 : memset(iomap->inline_data + size, 0, pos - size);
348 : 0 : copied = copy_from_iter(iomap->inline_data + pos, length, iter);
349 : 0 : if (copied) {
350 : 0 : if (pos + copied > size)
351 : : i_size_write(inode, pos + copied);
352 : : mark_inode_dirty(inode);
353 : : }
354 : : } else {
355 : 0 : copied = copy_to_iter(iomap->inline_data + pos, length, iter);
356 : : }
357 : 0 : dio->size += copied;
358 : 0 : return copied;
359 : : }
360 : :
361 : : static loff_t
362 : 0 : iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
363 : : void *data, struct iomap *iomap)
364 : : {
365 : : struct iomap_dio *dio = data;
366 : :
367 : 0 : switch (iomap->type) {
368 : : case IOMAP_HOLE:
369 : 0 : if (WARN_ON_ONCE(dio->flags & IOMAP_DIO_WRITE))
370 : : return -EIO;
371 : 0 : return iomap_dio_hole_actor(length, dio);
372 : : case IOMAP_UNWRITTEN:
373 : 0 : if (!(dio->flags & IOMAP_DIO_WRITE))
374 : 0 : return iomap_dio_hole_actor(length, dio);
375 : 0 : return iomap_dio_bio_actor(inode, pos, length, dio, iomap);
376 : : case IOMAP_MAPPED:
377 : 0 : return iomap_dio_bio_actor(inode, pos, length, dio, iomap);
378 : : case IOMAP_INLINE:
379 : 0 : return iomap_dio_inline_actor(inode, pos, length, dio, iomap);
380 : : default:
381 : 0 : WARN_ON_ONCE(1);
382 : : return -EIO;
383 : : }
384 : : }
385 : :
386 : : /*
387 : : * iomap_dio_rw() always completes O_[D]SYNC writes regardless of whether the IO
388 : : * is being issued as AIO or not. This allows us to optimise pure data writes
389 : : * to use REQ_FUA rather than requiring generic_write_sync() to issue a
390 : : * REQ_FLUSH post write. This is slightly tricky because a single request here
391 : : * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
392 : : * may be pure data writes. In that case, we still need to do a full data sync
393 : : * completion.
394 : : */
395 : : ssize_t
396 : 0 : iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
397 : : const struct iomap_ops *ops, const struct iomap_dio_ops *dops)
398 : : {
399 : 0 : struct address_space *mapping = iocb->ki_filp->f_mapping;
400 : : struct inode *inode = file_inode(iocb->ki_filp);
401 : : size_t count = iov_iter_count(iter);
402 : 0 : loff_t pos = iocb->ki_pos, start = pos;
403 : 0 : loff_t end = iocb->ki_pos + count - 1, ret = 0;
404 : : unsigned int flags = IOMAP_DIRECT;
405 : : bool wait_for_completion = is_sync_kiocb(iocb);
406 : : struct blk_plug plug;
407 : : struct iomap_dio *dio;
408 : :
409 : : lockdep_assert_held(&inode->i_rwsem);
410 : :
411 : 0 : if (!count)
412 : : return 0;
413 : :
414 : : dio = kmalloc(sizeof(*dio), GFP_KERNEL);
415 : 0 : if (!dio)
416 : : return -ENOMEM;
417 : :
418 : 0 : dio->iocb = iocb;
419 : : atomic_set(&dio->ref, 1);
420 : 0 : dio->size = 0;
421 : 0 : dio->i_size = i_size_read(inode);
422 : 0 : dio->dops = dops;
423 : 0 : dio->error = 0;
424 : 0 : dio->flags = 0;
425 : :
426 : 0 : dio->submit.iter = iter;
427 : 0 : dio->submit.waiter = current;
428 : 0 : dio->submit.cookie = BLK_QC_T_NONE;
429 : 0 : dio->submit.last_queue = NULL;
430 : :
431 : 0 : if (iov_iter_rw(iter) == READ) {
432 : 0 : if (pos >= dio->i_size)
433 : : goto out_free_dio;
434 : :
435 : 0 : if (iter_is_iovec(iter) && iov_iter_rw(iter) == READ)
436 : 0 : dio->flags |= IOMAP_DIO_DIRTY;
437 : : } else {
438 : : flags |= IOMAP_WRITE;
439 : 0 : dio->flags |= IOMAP_DIO_WRITE;
440 : :
441 : : /* for data sync or sync, we need sync completion processing */
442 : 0 : if (iocb->ki_flags & IOCB_DSYNC)
443 : 0 : dio->flags |= IOMAP_DIO_NEED_SYNC;
444 : :
445 : : /*
446 : : * For datasync only writes, we optimistically try using FUA for
447 : : * this IO. Any non-FUA write that occurs will clear this flag,
448 : : * hence we know before completion whether a cache flush is
449 : : * necessary.
450 : : */
451 : 0 : if ((iocb->ki_flags & (IOCB_DSYNC | IOCB_SYNC)) == IOCB_DSYNC)
452 : 0 : dio->flags |= IOMAP_DIO_WRITE_FUA;
453 : : }
454 : :
455 : 0 : if (iocb->ki_flags & IOCB_NOWAIT) {
456 : 0 : if (filemap_range_has_page(mapping, start, end)) {
457 : : ret = -EAGAIN;
458 : : goto out_free_dio;
459 : : }
460 : 0 : flags |= IOMAP_NOWAIT;
461 : : }
462 : :
463 : 0 : ret = filemap_write_and_wait_range(mapping, start, end);
464 : 0 : if (ret)
465 : : goto out_free_dio;
466 : :
467 : : /*
468 : : * Try to invalidate cache pages for the range we're direct
469 : : * writing. If this invalidation fails, tough, the write will
470 : : * still work, but racing two incompatible write paths is a
471 : : * pretty crazy thing to do, so we don't support it 100%.
472 : : */
473 : 0 : ret = invalidate_inode_pages2_range(mapping,
474 : 0 : start >> PAGE_SHIFT, end >> PAGE_SHIFT);
475 : 0 : if (ret)
476 : 0 : dio_warn_stale_pagecache(iocb->ki_filp);
477 : : ret = 0;
478 : :
479 : 0 : if (iov_iter_rw(iter) == WRITE && !wait_for_completion &&
480 : 0 : !inode->i_sb->s_dio_done_wq) {
481 : 0 : ret = sb_init_dio_done_wq(inode->i_sb);
482 : 0 : if (ret < 0)
483 : : goto out_free_dio;
484 : : }
485 : :
486 : : inode_dio_begin(inode);
487 : :
488 : 0 : blk_start_plug(&plug);
489 : : do {
490 : 0 : ret = iomap_apply(inode, pos, count, flags, ops, dio,
491 : : iomap_dio_actor);
492 : 0 : if (ret <= 0) {
493 : : /* magic error code to fall back to buffered I/O */
494 : 0 : if (ret == -ENOTBLK) {
495 : : wait_for_completion = true;
496 : : ret = 0;
497 : : }
498 : : break;
499 : : }
500 : 0 : pos += ret;
501 : :
502 : 0 : if (iov_iter_rw(iter) == READ && pos >= dio->i_size) {
503 : : /*
504 : : * We only report that we've read data up to i_size.
505 : : * Revert iter to a state corresponding to that as
506 : : * some callers (such as splice code) rely on it.
507 : : */
508 : 0 : iov_iter_revert(iter, pos - dio->i_size);
509 : 0 : break;
510 : : }
511 : 0 : } while ((count = iov_iter_count(iter)) > 0);
512 : 0 : blk_finish_plug(&plug);
513 : :
514 : 0 : if (ret < 0)
515 : : iomap_dio_set_error(dio, ret);
516 : :
517 : : /*
518 : : * If all the writes we issued were FUA, we don't need to flush the
519 : : * cache on IO completion. Clear the sync flag for this case.
520 : : */
521 : 0 : if (dio->flags & IOMAP_DIO_WRITE_FUA)
522 : 0 : dio->flags &= ~IOMAP_DIO_NEED_SYNC;
523 : :
524 : 0 : WRITE_ONCE(iocb->ki_cookie, dio->submit.cookie);
525 : 0 : WRITE_ONCE(iocb->private, dio->submit.last_queue);
526 : :
527 : : /*
528 : : * We are about to drop our additional submission reference, which
529 : : * might be the last reference to the dio. There are three three
530 : : * different ways we can progress here:
531 : : *
532 : : * (a) If this is the last reference we will always complete and free
533 : : * the dio ourselves.
534 : : * (b) If this is not the last reference, and we serve an asynchronous
535 : : * iocb, we must never touch the dio after the decrement, the
536 : : * I/O completion handler will complete and free it.
537 : : * (c) If this is not the last reference, but we serve a synchronous
538 : : * iocb, the I/O completion handler will wake us up on the drop
539 : : * of the final reference, and we will complete and free it here
540 : : * after we got woken by the I/O completion handler.
541 : : */
542 : 0 : dio->wait_for_completion = wait_for_completion;
543 : 0 : if (!atomic_dec_and_test(&dio->ref)) {
544 : 0 : if (!wait_for_completion)
545 : : return -EIOCBQUEUED;
546 : :
547 : : for (;;) {
548 : 0 : set_current_state(TASK_UNINTERRUPTIBLE);
549 : 0 : if (!READ_ONCE(dio->submit.waiter))
550 : : break;
551 : :
552 : 0 : if (!(iocb->ki_flags & IOCB_HIPRI) ||
553 : 0 : !dio->submit.last_queue ||
554 : 0 : !blk_poll(dio->submit.last_queue,
555 : : dio->submit.cookie, true))
556 : 0 : io_schedule();
557 : : }
558 : 0 : __set_current_state(TASK_RUNNING);
559 : : }
560 : :
561 : 0 : return iomap_dio_complete(dio);
562 : :
563 : : out_free_dio:
564 : 0 : kfree(dio);
565 : 0 : return ret;
566 : : }
567 : : EXPORT_SYMBOL_GPL(iomap_dio_rw);
|
