[PATCH v1 6/9] iomap: optimize reads for non-block-aligned writes

[Joanne Koong <joannelkoong@gmail.com>]

If a write is block-aligned (i.e., write offset and length are both
block-aligned), no reads should be necessary.

If the write starts or ends at a non-block-aligned offset, the write
should only need to read in at most two blocks, the starting block and
the ending block. Any intermediary blocks should be skipped since they
will be completely overwritten.

Currently for non-block-aligned writes, the entire range gets read in
including intermediary blocks.

Optimize the logic to read in only the necessary blocks.

Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
---
 fs/iomap/buffered-io.c | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 0ad8c8a218f3..372e14f7ab57 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -686,6 +686,7 @@ static int __iomap_write_begin(const struct iomap_iter *iter,
 	loff_t block_size = i_blocksize(iter->inode);
 	loff_t block_start = round_down(pos, block_size);
 	loff_t block_end = round_up(pos + len, block_size);
+	unsigned int block_bits = iter->inode->i_blkbits;
 	unsigned int nr_blocks = i_blocks_per_folio(iter->inode, folio);
 	size_t from = offset_in_folio(folio, pos), to = from + len;
 	size_t poff, plen;
@@ -714,13 +715,37 @@ static int __iomap_write_begin(const struct iomap_iter *iter,
 		if (plen == 0)
 			break;
 
-		/*
-		 * If the read range will be entirely overwritten by the write,
-		 * we can skip having to zero/read it in.
-		 */
-		if (!(iter->flags & IOMAP_UNSHARE) &&
-		    (from <= poff && to >= poff + plen))
-			continue;
+		if (!(iter->flags & IOMAP_UNSHARE)) {
+			/*
+			 * If the read range will be entirely overwritten by the
+			 * write, we can skip having to zero/read it in.
+			 */
+			if (from <= poff && to >= poff + plen)
+				continue;
+
+			/*
+			 * If the write starts at a non-block-aligned offset
+			 * (from > poff), read only the first block. Any
+			 * intermediate blocks will be skipped in the next
+			 * iteration.
+			 *
+			 * Exception: skip this optimization if the write spans
+			 * only two blocks and ends at a non-block-aligned
+			 * offset.
+			 */
+			if (from > poff) {
+			       if ((plen >> block_bits) > 2 ||
+						to >= poff + plen)
+					plen = block_size;
+			} else if (to < poff + plen) {
+				/*
+				 * Else if the write ends at an offset into the
+				 * last block, read in just the last block.
+				 */
+				poff = poff + plen - block_size;
+				plen = block_size;
+			}
+		}
 
 		if (iomap_block_needs_zeroing(iter, block_start)) {
 			if (WARN_ON_ONCE(iter->flags & IOMAP_UNSHARE))
-- 
2.47.3