iomap: optional zero range dirty folio processing

The only way zero range can currently process unwritten mappings
with dirty pagecache is to check whether the range is dirty before
mapping lookup and then flush when at least one underlying mapping
is unwritten. This ordering is required to prevent iomap lookup from
racing with folio writeback and reclaim.

Since zero range can skip ranges of unwritten mappings that are
clean in cache, this operation can be improved by allowing the
filesystem to provide a set of dirty folios that require zeroing. In
turn, rather than flush or iterate file offsets, zero range can
iterate on folios in the batch and advance over clean or uncached
ranges in between.

Add a folio_batch in struct iomap and provide a helper for
filesystems to populate the batch at lookup time. Update the folio
lookup path to return the next folio in the batch, if provided, and
advance the iter if the folio starts beyond the current offset.

Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index b5e85cd24360ccb9fc52ffc04bd4110380401d13..1cabd9b0249ed47c041b728cb6c65b828bc7b6c2 100644 (file)
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -772,6 +772,28 @@ static struct folio *__iomap_get_folio(struct iomap_iter *iter,
        if (!mapping_large_folio_support(iter->inode->i_mapping))
                len = min_t(size_t, len, PAGE_SIZE - offset_in_page(pos));
 
+       if (iter->fbatch) {
+               struct folio *folio = folio_batch_next(iter->fbatch);
+
+               if (!folio)
+                       return NULL;
+
+               /*
+                * The folio mapping generally shouldn't have changed based on
+                * fs locks, but be consistent with filemap lookup and retry
+                * the iter if it does.
+                */
+               folio_lock(folio);
+               if (unlikely(folio->mapping != iter->inode->i_mapping)) {
+                       iter->iomap.flags |= IOMAP_F_STALE;
+                       folio_unlock(folio);
+                       return NULL;
+               }
+
+               folio_get(folio);
+               return folio;
+       }
+
        if (write_ops && write_ops->get_folio)
                return write_ops->get_folio(iter, pos, len);
        return iomap_get_folio(iter, pos, len);
@@ -832,6 +854,8 @@ static int iomap_write_begin(struct iomap_iter *iter,
        int status = 0;
 
        len = min_not_zero(len, *plen);
+       *foliop = NULL;
+       *plen = 0;
 
        if (fatal_signal_pending(current))
                return -EINTR;
@@ -840,6 +864,15 @@ static int iomap_write_begin(struct iomap_iter *iter,
        if (IS_ERR(folio))
                return PTR_ERR(folio);
 
+       /*
+        * No folio means we're done with a batch. We still have range to
+        * process so return and let the caller iterate and refill the batch.
+        */
+       if (!folio) {
+               WARN_ON_ONCE(!iter->fbatch);
+               return 0;
+       }
+
        /*
         * Now we have a locked folio, before we do anything with it we need to
         * check that the iomap we have cached is not stale. The inode extent
@@ -860,6 +893,22 @@ static int iomap_write_begin(struct iomap_iter *iter,
                }
        }
 
+       /*
+        * The folios in a batch may not be contiguous. If we've skipped
+        * forward, advance the iter to the pos of the current folio. If the
+        * folio starts beyond the end of the mapping, it may have been trimmed
+        * since the lookup for whatever reason. Return a NULL folio to
+        * terminate the op.
+        */
+       if (folio_pos(folio) > iter->pos) {
+               len = min_t(u64, folio_pos(folio) - iter->pos,
+                                iomap_length(iter));
+               status = iomap_iter_advance(iter, len);
+               len = iomap_length(iter);
+               if (status || !len)
+                       goto out_unlock;
+       }
+
        pos = iomap_trim_folio_range(iter, folio, poffset, &len);
 
        if (srcmap->type == IOMAP_INLINE)
@@ -1406,6 +1455,12 @@ static int iomap_zero_iter(struct iomap_iter *iter, bool *did_zero,
                if (iter->iomap.flags & IOMAP_F_STALE)
                        break;
 
+               /* a NULL folio means we're done with a folio batch */
+               if (!folio) {
+                       status = iomap_iter_advance_full(iter);
+                       break;
+               }
+
                /* warn about zeroing folios beyond eof that won't write back */
                WARN_ON_ONCE(folio_pos(folio) > iter->inode->i_size);
 
@@ -1430,6 +1485,26 @@ static int iomap_zero_iter(struct iomap_iter *iter, bool *did_zero,
        return status;
 }
 
+loff_t
+iomap_fill_dirty_folios(
+       struct iomap_iter       *iter,
+       loff_t                  offset,
+       loff_t                  length)
+{
+       struct address_space    *mapping = iter->inode->i_mapping;
+       pgoff_t                 start = offset >> PAGE_SHIFT;
+       pgoff_t                 end = (offset + length - 1) >> PAGE_SHIFT;
+
+       iter->fbatch = kmalloc(sizeof(struct folio_batch), GFP_KERNEL);
+       if (!iter->fbatch)
+               return offset + length;
+       folio_batch_init(iter->fbatch);
+
+       filemap_get_folios_dirty(mapping, &start, end, iter->fbatch);
+       return (start << PAGE_SHIFT);
+}
+EXPORT_SYMBOL_GPL(iomap_fill_dirty_folios);
+
 int
 iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,
                const struct iomap_ops *ops,
@@ -1459,7 +1534,7 @@ iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,
         * flushing on partial eof zeroing, special case it to zero the
         * unaligned start portion if already dirty in pagecache.
         */
-       if (off &&
+       if (!iter.fbatch && off &&
            filemap_range_needs_writeback(mapping, pos, pos + plen - 1)) {
                iter.len = plen;
                while ((ret = iomap_iter(&iter, ops)) > 0)
@@ -1476,13 +1551,18 @@ iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,
         * if dirty and the fs returns a mapping that might convert on
         * writeback.
         */
-       range_dirty = filemap_range_needs_writeback(inode->i_mapping,
-                                       iter.pos, iter.pos + iter.len - 1);
+       range_dirty = filemap_range_needs_writeback(mapping, iter.pos,
+                                       iter.pos + iter.len - 1);
        while ((ret = iomap_iter(&iter, ops)) > 0) {
                const struct iomap *srcmap = iomap_iter_srcmap(&iter);
 
-               if (srcmap->type == IOMAP_HOLE ||
-                   srcmap->type == IOMAP_UNWRITTEN) {
+               if (WARN_ON_ONCE(iter.fbatch &&
+                                srcmap->type != IOMAP_UNWRITTEN))
+                       return -EIO;
+
+               if (!iter.fbatch &&
+                   (srcmap->type == IOMAP_HOLE ||
+                    srcmap->type == IOMAP_UNWRITTEN)) {
                        s64 status;
 
                        if (range_dirty) {

diff --git a/fs/iomap/iter.c b/fs/iomap/iter.c
index 91d2024e00da4e0d440f82426c1ae1718c104963..8692e5e41c6df6fe789849b740ce7c982682cacc 100644 (file)
--- a/fs/iomap/iter.c
+++ b/fs/iomap/iter.c
@@ -8,6 +8,12 @@
 
 static inline void iomap_iter_reset_iomap(struct iomap_iter *iter)
 {
+       if (iter->fbatch) {
+               folio_batch_release(iter->fbatch);
+               kfree(iter->fbatch);
+               iter->fbatch = NULL;
+       }
+
        iter->status = 0;
        memset(&iter->iomap, 0, sizeof(iter->iomap));
        memset(&iter->srcmap, 0, sizeof(iter->srcmap));

diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index 6d864b446b6e6231b4ab206f61456c78f11ac1be..65d1231148830a972c3a3fdef32b58fcaa2236aa 100644 (file)
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -9,6 +9,7 @@
 #include <linux/types.h>
 #include <linux/mm_types.h>
 #include <linux/blkdev.h>
+#include <linux/pagevec.h>
 
 struct address_space;
 struct fiemap_extent_info;
@@ -242,6 +243,7 @@ struct iomap_iter {
        unsigned flags;
        struct iomap iomap;
        struct iomap srcmap;
+       struct folio_batch *fbatch;
        void *private;
 };
 
@@ -350,6 +352,8 @@ bool iomap_dirty_folio(struct address_space *mapping, struct folio *folio);
 int iomap_file_unshare(struct inode *inode, loff_t pos, loff_t len,
                const struct iomap_ops *ops,
                const struct iomap_write_ops *write_ops);
+loff_t iomap_fill_dirty_folios(struct iomap_iter *iter, loff_t offset,
+               loff_t length);
 int iomap_zero_range(struct inode *inode, loff_t pos, loff_t len,
                bool *did_zero, const struct iomap_ops *ops,
                const struct iomap_write_ops *write_ops, void *private);