f2fs: avoid f2fs_map_blocks() for consecutive holes in readpages

For consecutive large hole mapping across {d,id,did}nodes , we don't
need to call f2fs_map_blocks() to check one hole block per one time,
instead, we can use map.m_next_pgofs as a hint of next potential valid
block, so that we can skip calling f2fs_map_blocks the range of
[cur_pgofs + 1, .m_next_pgofs).

1) regular case

touch /mnt/f2fs/file
truncate -s $((1024*1024*1024)) /mnt/f2fs/file
time dd if=/mnt/f2fs/file of=/dev/null bs=1M count=1024

Before:
real    0m0.706s
user    0m0.000s
sys     0m0.706s

After:
real    0m0.620s
user    0m0.008s
sys     0m0.611s

2) large folio case

touch /mnt/f2fs/file
truncate -s $((1024*1024*1024)) /mnt/f2fs/file
f2fs_io setflags immutable /mnt/f2fs/file
sync
echo 3 > /proc/sys/vm/drop_caches
time dd if=/mnt/f2fs/file of=/dev/null bs=1M count=1024

Before:
real    0m0.438s
user    0m0.004s
sys     0m0.433s

After:
real    0m0.368s
user    0m0.004s
sys     0m0.364s

Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ef44b8421cd7a8dd7894e38bbf3c1fab1735b1b3..3c2af0ef62bbe9ac604e7e0b626613d9ac8ea0ed 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2164,10 +2164,13 @@ static int f2fs_read_single_page(struct inode *inode, struct folio *folio,
        /*
         * Map blocks using the previous result first.
         */
-       if ((map->m_flags & F2FS_MAP_MAPPED) &&
-                       block_in_file > map->m_lblk &&
+       if (map->m_flags & F2FS_MAP_MAPPED) {
+               if (block_in_file > map->m_lblk &&
                        block_in_file < (map->m_lblk + map->m_len))
+                       goto got_it;
+       } else if (block_in_file < *map->m_next_pgofs) {
                goto got_it;
+       }
 
        /*
         * Then do more f2fs_map_blocks() calls until we are
@@ -2442,7 +2445,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
        struct bio *bio = NULL;
        sector_t last_block_in_bio = 0;
        struct f2fs_map_blocks map = {0, };
-       pgoff_t index, offset;
+       pgoff_t index, offset, next_pgofs = 0;
        unsigned max_nr_pages = rac ? readahead_count(rac) :
                                folio_nr_pages(folio);
        unsigned nrpages;
@@ -2475,16 +2478,21 @@ next_folio:
                /*
                 * Map blocks using the previous result first.
                 */
-               if ((map.m_flags & F2FS_MAP_MAPPED) &&
-                               index > map.m_lblk &&
+               if (map.m_flags & F2FS_MAP_MAPPED) {
+                       if (index > map.m_lblk &&
                                index < (map.m_lblk + map.m_len))
+                               goto got_it;
+               } else if (index < next_pgofs) {
+                       /* hole case */
                        goto got_it;
+               }
 
                /*
                 * Then do more f2fs_map_blocks() calls until we are
                 * done with this page.
                 */
                memset(&map, 0, sizeof(map));
+               map.m_next_pgofs = &next_pgofs;
                map.m_seg_type = NO_CHECK_TYPE;
                map.m_lblk = index;
                map.m_len = max_nr_pages;
@@ -2611,6 +2619,7 @@ static int f2fs_mpage_readpages(struct inode *inode,
        pgoff_t nc_cluster_idx = NULL_CLUSTER;
        pgoff_t index;
 #endif
+       pgoff_t next_pgofs = 0;
        unsigned nr_pages = rac ? readahead_count(rac) : 1;
        struct address_space *mapping = rac ? rac->mapping : folio->mapping;
        unsigned max_nr_pages = nr_pages;
@@ -2631,7 +2640,7 @@ static int f2fs_mpage_readpages(struct inode *inode,
        map.m_lblk = 0;
        map.m_len = 0;
        map.m_flags = 0;
-       map.m_next_pgofs = NULL;
+       map.m_next_pgofs = &next_pgofs;
        map.m_next_extent = NULL;
        map.m_seg_type = NO_CHECK_TYPE;
        map.m_may_create = false;