dax: advance the iomap_iter on zero range

Update the DAX zero range iomap iter handler to advance the iter
directly. Advance by the full length in the hole/unwritten case, or
otherwise advance incrementally in the zeroing loop. In either case,
return 0 or an error code for success or failure.

Signed-off-by: Brian Foster <bfoster@redhat.com>
Link: https://lore.kernel.org/r/20250224144757.237706-7-bfoster@redhat.com
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/dax.c b/fs/dax.c
index 139e299e53e628ac60665679d4765ecc166ed777..f4d8c8c1008675f59d24e4efcfcd44ee311686a9 100644 (file)
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -1358,13 +1358,12 @@ static s64 dax_zero_iter(struct iomap_iter *iter, bool *did_zero)
 {
        const struct iomap *iomap = &iter->iomap;
        const struct iomap *srcmap = iomap_iter_srcmap(iter);
-       loff_t pos = iter->pos;
        u64 length = iomap_length(iter);
-       s64 written = 0;
+       s64 ret;
 
        /* already zeroed?  we're done. */
        if (srcmap->type == IOMAP_HOLE || srcmap->type == IOMAP_UNWRITTEN)
-               return length;
+               return iomap_iter_advance(iter, &length);
 
        /*
         * invalidate the pages whose sharing state is to be changed
@@ -1372,33 +1371,35 @@ static s64 dax_zero_iter(struct iomap_iter *iter, bool *did_zero)
         */
        if (iomap->flags & IOMAP_F_SHARED)
                invalidate_inode_pages2_range(iter->inode->i_mapping,
-                                             pos >> PAGE_SHIFT,
-                                             (pos + length - 1) >> PAGE_SHIFT);
+                               iter->pos >> PAGE_SHIFT,
+                               (iter->pos + length - 1) >> PAGE_SHIFT);
 
        do {
+               loff_t pos = iter->pos;
                unsigned offset = offset_in_page(pos);
-               unsigned size = min_t(u64, PAGE_SIZE - offset, length);
                pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);
-               long rc;
                int id;
 
+               length = min_t(u64, PAGE_SIZE - offset, length);
+
                id = dax_read_lock();
-               if (IS_ALIGNED(pos, PAGE_SIZE) && size == PAGE_SIZE)
-                       rc = dax_zero_page_range(iomap->dax_dev, pgoff, 1);
+               if (IS_ALIGNED(pos, PAGE_SIZE) && length == PAGE_SIZE)
+                       ret = dax_zero_page_range(iomap->dax_dev, pgoff, 1);
                else
-                       rc = dax_memzero(iter, pos, size);
+                       ret = dax_memzero(iter, pos, length);
                dax_read_unlock(id);
 
-               if (rc < 0)
-                       return rc;
-               pos += size;
-               length -= size;
-               written += size;
+               if (ret < 0)
+                       return ret;
+
+               ret = iomap_iter_advance(iter, &length);
+               if (ret)
+                       return ret;
        } while (length > 0);
 
        if (did_zero)
                *did_zero = true;
-       return written;
+       return ret;
 }
 
 int dax_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,