1 // SPDX-License-Identifier: GPL-2.0
5 #include "alloc_foreground.h"
8 #include "fs-io-direct.h"
9 #include "fs-io-pagecache.h"
13 #include <linux/kthread.h>
14 #include <linux/pagemap.h>
15 #include <linux/prefetch.h>
16 #include <linux/task_io_accounting_ops.h>
25 struct bch_read_bio rbio;
28 static void bio_check_or_release(struct bio *bio, bool check_dirty)
31 bio_check_pages_dirty(bio);
33 bio_release_pages(bio, false);
38 static void bch2_dio_read_complete(struct closure *cl)
40 struct dio_read *dio = container_of(cl, struct dio_read, cl);
42 dio->req->ki_complete(dio->req, dio->ret);
43 bio_check_or_release(&dio->rbio.bio, dio->should_dirty);
46 static void bch2_direct_IO_read_endio(struct bio *bio)
48 struct dio_read *dio = bio->bi_private;
51 dio->ret = blk_status_to_errno(bio->bi_status);
53 closure_put(&dio->cl);
56 static void bch2_direct_IO_read_split_endio(struct bio *bio)
58 struct dio_read *dio = bio->bi_private;
59 bool should_dirty = dio->should_dirty;
61 bch2_direct_IO_read_endio(bio);
62 bio_check_or_release(bio, should_dirty);
65 static int bch2_direct_IO_read(struct kiocb *req, struct iov_iter *iter)
67 struct file *file = req->ki_filp;
68 struct bch_inode_info *inode = file_bch_inode(file);
69 struct bch_fs *c = inode->v.i_sb->s_fs_info;
70 struct bch_io_opts opts;
73 loff_t offset = req->ki_pos;
74 bool sync = is_sync_kiocb(req);
78 bch2_inode_opts_get(&opts, c, &inode->ei_inode);
80 if ((offset|iter->count) & (block_bytes(c) - 1))
83 ret = min_t(loff_t, iter->count,
84 max_t(loff_t, 0, i_size_read(&inode->v) - offset));
89 shorten = iov_iter_count(iter) - round_up(ret, block_bytes(c));
90 iter->count -= shorten;
92 bio = bio_alloc_bioset(NULL,
93 bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS),
98 bio->bi_end_io = bch2_direct_IO_read_endio;
100 dio = container_of(bio, struct dio_read, rbio.bio);
101 closure_init(&dio->cl, NULL);
104 * this is a _really_ horrible hack just to avoid an atomic sub at the
108 set_closure_fn(&dio->cl, bch2_dio_read_complete, NULL);
109 atomic_set(&dio->cl.remaining,
110 CLOSURE_REMAINING_INITIALIZER -
114 atomic_set(&dio->cl.remaining,
115 CLOSURE_REMAINING_INITIALIZER + 1);
121 * This is one of the sketchier things I've encountered: we have to skip
122 * the dirtying of requests that are internal from the kernel (i.e. from
123 * loopback), because we'll deadlock on page_lock.
125 dio->should_dirty = iter_is_iovec(iter);
128 while (iter->count) {
129 bio = bio_alloc_bioset(NULL,
130 bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS),
134 bio->bi_end_io = bch2_direct_IO_read_split_endio;
136 bio->bi_opf = REQ_OP_READ|REQ_SYNC;
137 bio->bi_iter.bi_sector = offset >> 9;
138 bio->bi_private = dio;
140 ret = bio_iov_iter_get_pages(bio, iter);
142 /* XXX: fault inject this path */
143 bio->bi_status = BLK_STS_RESOURCE;
148 offset += bio->bi_iter.bi_size;
150 if (dio->should_dirty)
151 bio_set_pages_dirty(bio);
154 closure_get(&dio->cl);
156 bch2_read(c, rbio_init(bio, opts), inode_inum(inode));
159 iter->count += shorten;
162 closure_sync(&dio->cl);
163 closure_debug_destroy(&dio->cl);
165 bio_check_or_release(&dio->rbio.bio, dio->should_dirty);
172 ssize_t bch2_read_iter(struct kiocb *iocb, struct iov_iter *iter)
174 struct file *file = iocb->ki_filp;
175 struct bch_inode_info *inode = file_bch_inode(file);
176 struct address_space *mapping = file->f_mapping;
177 size_t count = iov_iter_count(iter);
181 return 0; /* skip atime */
183 if (iocb->ki_flags & IOCB_DIRECT) {
184 struct blk_plug plug;
186 if (unlikely(mapping->nrpages)) {
187 ret = filemap_write_and_wait_range(mapping,
189 iocb->ki_pos + count - 1);
196 blk_start_plug(&plug);
197 ret = bch2_direct_IO_read(iocb, iter);
198 blk_finish_plug(&plug);
203 bch2_pagecache_add_get(inode);
204 ret = generic_file_read_iter(iocb, iter);
205 bch2_pagecache_add_put(inode);
208 return bch2_err_class(ret);
211 /* O_DIRECT writes */
215 struct address_space *mapping;
216 struct bch_inode_info *inode;
217 struct mm_struct *mm;
223 struct quota_res quota_res;
226 struct iov_iter iter;
227 struct iovec inline_vecs[2];
230 struct bch_write_op op;
233 static bool bch2_check_range_allocated(struct bch_fs *c, subvol_inum inum,
234 u64 offset, u64 size,
235 unsigned nr_replicas, bool compressed)
237 struct btree_trans *trans = bch2_trans_get(c);
238 struct btree_iter iter;
240 u64 end = offset + size;
245 bch2_trans_begin(trans);
247 err = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
251 for_each_btree_key_norestart(trans, iter, BTREE_ID_extents,
252 SPOS(inum.inum, offset, snapshot),
253 BTREE_ITER_SLOTS, k, err) {
254 if (bkey_ge(bkey_start_pos(k.k), POS(inum.inum, end)))
257 if (k.k->p.snapshot != snapshot ||
258 nr_replicas > bch2_bkey_replicas(c, k) ||
259 (!compressed && bch2_bkey_sectors_compressed(k))) {
265 offset = iter.pos.offset;
266 bch2_trans_iter_exit(trans, &iter);
268 if (bch2_err_matches(err, BCH_ERR_transaction_restart))
270 bch2_trans_put(trans);
272 return err ? false : ret;
275 static noinline bool bch2_dio_write_check_allocated(struct dio_write *dio)
277 struct bch_fs *c = dio->op.c;
278 struct bch_inode_info *inode = dio->inode;
279 struct bio *bio = &dio->op.wbio.bio;
281 return bch2_check_range_allocated(c, inode_inum(inode),
282 dio->op.pos.offset, bio_sectors(bio),
283 dio->op.opts.data_replicas,
284 dio->op.opts.compression != 0);
287 static void bch2_dio_write_loop_async(struct bch_write_op *);
288 static __always_inline long bch2_dio_write_done(struct dio_write *dio);
291 * We're going to return -EIOCBQUEUED, but we haven't finished consuming the
292 * iov_iter yet, so we need to stash a copy of the iovec: it might be on the
293 * caller's stack, we're not guaranteed that it will live for the duration of
296 static noinline int bch2_dio_write_copy_iov(struct dio_write *dio)
298 struct iovec *iov = dio->inline_vecs;
301 * iov_iter has a single embedded iovec - nothing to do:
303 if (iter_is_ubuf(&dio->iter))
307 * We don't currently handle non-iovec iov_iters here - return an error,
308 * and we'll fall back to doing the IO synchronously:
310 if (!iter_is_iovec(&dio->iter))
313 if (dio->iter.nr_segs > ARRAY_SIZE(dio->inline_vecs)) {
314 iov = kmalloc_array(dio->iter.nr_segs, sizeof(*iov),
319 dio->free_iov = true;
322 memcpy(iov, dio->iter.__iov, dio->iter.nr_segs * sizeof(*iov));
323 dio->iter.__iov = iov;
327 static void bch2_dio_write_flush_done(struct closure *cl)
329 struct dio_write *dio = container_of(cl, struct dio_write, op.cl);
330 struct bch_fs *c = dio->op.c;
332 closure_debug_destroy(cl);
334 dio->op.error = bch2_journal_error(&c->journal);
336 bch2_dio_write_done(dio);
339 static noinline void bch2_dio_write_flush(struct dio_write *dio)
341 struct bch_fs *c = dio->op.c;
342 struct bch_inode_unpacked inode;
347 closure_init(&dio->op.cl, NULL);
349 if (!dio->op.error) {
350 ret = bch2_inode_find_by_inum(c, inode_inum(dio->inode), &inode);
354 bch2_journal_flush_seq_async(&c->journal, inode.bi_journal_seq,
356 bch2_inode_flush_nocow_writes_async(c, dio->inode, &dio->op.cl);
361 closure_sync(&dio->op.cl);
362 closure_debug_destroy(&dio->op.cl);
364 continue_at(&dio->op.cl, bch2_dio_write_flush_done, NULL);
368 static __always_inline long bch2_dio_write_done(struct dio_write *dio)
370 struct kiocb *req = dio->req;
371 struct bch_inode_info *inode = dio->inode;
372 bool sync = dio->sync;
375 if (unlikely(dio->flush)) {
376 bch2_dio_write_flush(dio);
381 bch2_pagecache_block_put(inode);
384 kfree(dio->iter.__iov);
386 ret = dio->op.error ?: ((long) dio->written << 9);
387 bio_put(&dio->op.wbio.bio);
389 /* inode->i_dio_count is our ref on inode and thus bch_fs */
390 inode_dio_end(&inode->v);
393 ret = bch2_err_class(ret);
396 req->ki_complete(req, ret);
402 static __always_inline void bch2_dio_write_end(struct dio_write *dio)
404 struct bch_fs *c = dio->op.c;
405 struct kiocb *req = dio->req;
406 struct bch_inode_info *inode = dio->inode;
407 struct bio *bio = &dio->op.wbio.bio;
409 req->ki_pos += (u64) dio->op.written << 9;
410 dio->written += dio->op.written;
412 if (dio->extending) {
413 spin_lock(&inode->v.i_lock);
414 if (req->ki_pos > inode->v.i_size)
415 i_size_write(&inode->v, req->ki_pos);
416 spin_unlock(&inode->v.i_lock);
419 if (dio->op.i_sectors_delta || dio->quota_res.sectors) {
420 mutex_lock(&inode->ei_quota_lock);
421 __bch2_i_sectors_acct(c, inode, &dio->quota_res, dio->op.i_sectors_delta);
422 __bch2_quota_reservation_put(c, inode, &dio->quota_res);
423 mutex_unlock(&inode->ei_quota_lock);
426 bio_release_pages(bio, false);
428 if (unlikely(dio->op.error))
429 set_bit(EI_INODE_ERROR, &inode->ei_flags);
432 static __always_inline long bch2_dio_write_loop(struct dio_write *dio)
434 struct bch_fs *c = dio->op.c;
435 struct kiocb *req = dio->req;
436 struct address_space *mapping = dio->mapping;
437 struct bch_inode_info *inode = dio->inode;
438 struct bch_io_opts opts;
439 struct bio *bio = &dio->op.wbio.bio;
440 unsigned unaligned, iter_count;
441 bool sync = dio->sync, dropped_locks;
444 bch2_inode_opts_get(&opts, c, &inode->ei_inode);
447 iter_count = dio->iter.count;
449 EBUG_ON(current->faults_disabled_mapping);
450 current->faults_disabled_mapping = mapping;
452 ret = bio_iov_iter_get_pages(bio, &dio->iter);
454 dropped_locks = fdm_dropped_locks();
456 current->faults_disabled_mapping = NULL;
459 * If the fault handler returned an error but also signalled
460 * that it dropped & retook ei_pagecache_lock, we just need to
461 * re-shoot down the page cache and retry:
463 if (dropped_locks && ret)
466 if (unlikely(ret < 0))
469 if (unlikely(dropped_locks)) {
470 ret = bch2_write_invalidate_inode_pages_range(mapping,
472 req->ki_pos + iter_count - 1);
476 if (!bio->bi_iter.bi_size)
480 unaligned = bio->bi_iter.bi_size & (block_bytes(c) - 1);
481 bio->bi_iter.bi_size -= unaligned;
482 iov_iter_revert(&dio->iter, unaligned);
484 if (!bio->bi_iter.bi_size) {
486 * bio_iov_iter_get_pages was only able to get <
487 * blocksize worth of pages:
493 bch2_write_op_init(&dio->op, c, opts);
494 dio->op.end_io = sync
496 : bch2_dio_write_loop_async;
497 dio->op.target = dio->op.opts.foreground_target;
498 dio->op.write_point = writepoint_hashed((unsigned long) current);
499 dio->op.nr_replicas = dio->op.opts.data_replicas;
500 dio->op.subvol = inode->ei_subvol;
501 dio->op.pos = POS(inode->v.i_ino, (u64) req->ki_pos >> 9);
502 dio->op.devs_need_flush = &inode->ei_devs_need_flush;
505 dio->op.flags |= BCH_WRITE_SYNC;
506 dio->op.flags |= BCH_WRITE_CHECK_ENOSPC;
508 ret = bch2_quota_reservation_add(c, inode, &dio->quota_res,
509 bio_sectors(bio), true);
513 ret = bch2_disk_reservation_get(c, &dio->op.res, bio_sectors(bio),
514 dio->op.opts.data_replicas, 0);
516 !bch2_dio_write_check_allocated(dio))
519 task_io_account_write(bio->bi_iter.bi_size);
521 if (unlikely(dio->iter.count) &&
524 bch2_dio_write_copy_iov(dio))
525 dio->sync = sync = true;
528 closure_call(&dio->op.cl, bch2_write, NULL, NULL);
533 bch2_dio_write_end(dio);
535 if (likely(!dio->iter.count) || dio->op.error)
538 bio_reset(bio, NULL, REQ_OP_WRITE);
541 return bch2_dio_write_done(dio);
545 bio_release_pages(bio, false);
547 bch2_quota_reservation_put(c, inode, &dio->quota_res);
551 static noinline __cold void bch2_dio_write_continue(struct dio_write *dio)
553 struct mm_struct *mm = dio->mm;
555 bio_reset(&dio->op.wbio.bio, NULL, REQ_OP_WRITE);
559 bch2_dio_write_loop(dio);
561 kthread_unuse_mm(mm);
564 static void bch2_dio_write_loop_async(struct bch_write_op *op)
566 struct dio_write *dio = container_of(op, struct dio_write, op);
568 bch2_dio_write_end(dio);
570 if (likely(!dio->iter.count) || dio->op.error)
571 bch2_dio_write_done(dio);
573 bch2_dio_write_continue(dio);
576 ssize_t bch2_direct_write(struct kiocb *req, struct iov_iter *iter)
578 struct file *file = req->ki_filp;
579 struct address_space *mapping = file->f_mapping;
580 struct bch_inode_info *inode = file_bch_inode(file);
581 struct bch_fs *c = inode->v.i_sb->s_fs_info;
582 struct dio_write *dio;
584 bool locked = true, extending;
588 prefetch((void *) &c->opts + 64);
589 prefetch(&inode->ei_inode);
590 prefetch((void *) &inode->ei_inode + 64);
592 inode_lock(&inode->v);
594 ret = generic_write_checks(req, iter);
595 if (unlikely(ret <= 0))
598 ret = file_remove_privs(file);
602 ret = file_update_time(file);
606 if (unlikely((req->ki_pos|iter->count) & (block_bytes(c) - 1)))
609 inode_dio_begin(&inode->v);
610 bch2_pagecache_block_get(inode);
612 extending = req->ki_pos + iter->count > inode->v.i_size;
614 inode_unlock(&inode->v);
618 bio = bio_alloc_bioset(NULL,
619 bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS),
622 &c->dio_write_bioset);
623 dio = container_of(bio, struct dio_write, op.wbio.bio);
625 dio->mapping = mapping;
627 dio->mm = current->mm;
629 dio->extending = extending;
630 dio->sync = is_sync_kiocb(req) || extending;
631 dio->flush = iocb_is_dsync(req) && !c->opts.journal_flush_disabled;
632 dio->free_iov = false;
633 dio->quota_res.sectors = 0;
638 if (unlikely(mapping->nrpages)) {
639 ret = bch2_write_invalidate_inode_pages_range(mapping,
641 req->ki_pos + iter->count - 1);
646 ret = bch2_dio_write_loop(dio);
649 inode_unlock(&inode->v);
652 bch2_pagecache_block_put(inode);
654 inode_dio_end(&inode->v);
658 void bch2_fs_fs_io_direct_exit(struct bch_fs *c)
660 bioset_exit(&c->dio_write_bioset);
661 bioset_exit(&c->dio_read_bioset);
664 int bch2_fs_fs_io_direct_init(struct bch_fs *c)
666 if (bioset_init(&c->dio_read_bioset,
667 4, offsetof(struct dio_read, rbio.bio),
669 return -BCH_ERR_ENOMEM_dio_read_bioset_init;
671 if (bioset_init(&c->dio_write_bioset,
672 4, offsetof(struct dio_write, op.wbio.bio),
674 return -BCH_ERR_ENOMEM_dio_write_bioset_init;
679 #endif /* NO_BCACHEFS_FS */