f2fs: add parameter @len to f2fs_invalidate_blocks()

New function can process some consecutive blocks at a time.

Function f2fs_invalidate_blocks()->down_write() and up_write()
are very time-consuming, so if f2fs_invalidate_blocks() can
process consecutive blocks at one time, it will save a lot of time.

Signed-off-by: Yi Sun <yi.sun@unisoc.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index be3e6f4d33a2de1f595543280bab36e8de2c5790..c5e42eec8ac9aebfa3694fa65a3831807785b036 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1380,7 +1380,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
                        if (blkaddr == COMPRESS_ADDR)
                                fio.compr_blocks++;
                        if (__is_valid_data_blkaddr(blkaddr))
-                               f2fs_invalidate_blocks(sbi, blkaddr);
+                               f2fs_invalidate_blocks(sbi, blkaddr, 1);
                        f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR);
                        goto unlock_continue;
                }
@@ -1390,7 +1390,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
 
                if (i > cc->valid_nr_cpages) {
                        if (__is_valid_data_blkaddr(blkaddr)) {
-                               f2fs_invalidate_blocks(sbi, blkaddr);
+                               f2fs_invalidate_blocks(sbi, blkaddr, 1);
                                f2fs_update_data_blkaddr(&dn, NEW_ADDR);
                        }
                        goto unlock_continue;

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index f265c26d00382eb829b7f2b83f2f5ec4a5ea783a..4bfe162eefd36abca58768518ff804b1a28a1c0c 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3724,7 +3724,8 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
 int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
 int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
 void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
-void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
+void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
+                                               unsigned int len);
 bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
 int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
 void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index aa9679b3d8e4f5246c298220e6e12ef1c3ed53c3..81764b10840b265c197dd69de22661ca26b9d5c7 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -652,7 +652,7 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                                valid_blocks++;
                }
 
-               f2fs_invalidate_blocks(sbi, blkaddr);
+               f2fs_invalidate_blocks(sbi, blkaddr, 1);
 
                if (!released || blkaddr != COMPRESS_ADDR)
                        nr_free++;
@@ -750,7 +750,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
                unsigned int i;
 
                for (i = 0; i < ei.len; i++)
-                       f2fs_invalidate_blocks(sbi, ei.blk + i);
+                       f2fs_invalidate_blocks(sbi, ei.blk + i, 1);
 
                dec_valid_block_count(sbi, inode, ei.len);
                f2fs_update_time(sbi, REQ_TIME);
@@ -1323,7 +1323,7 @@ static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
                ret = f2fs_get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
                if (ret) {
                        dec_valid_block_count(sbi, inode, 1);
-                       f2fs_invalidate_blocks(sbi, *blkaddr);
+                       f2fs_invalidate_blocks(sbi, *blkaddr, 1);
                } else {
                        f2fs_update_data_blkaddr(&dn, *blkaddr);
                }
@@ -1575,7 +1575,7 @@ static int f2fs_do_zero_range(struct dnode_of_data *dn, pgoff_t start,
                        break;
                }
 
-               f2fs_invalidate_blocks(sbi, dn->data_blkaddr);
+               f2fs_invalidate_blocks(sbi, dn->data_blkaddr, 1);
                f2fs_set_data_blkaddr(dn, NEW_ADDR);
        }
 

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 00f340c91fcbe7ad570831446d9685e32de46850..f88392fc4ba959418d12948ba3ab3b216c9d6a7b 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -917,7 +917,7 @@ static int truncate_node(struct dnode_of_data *dn)
        }
 
        /* Deallocate node address */
-       f2fs_invalidate_blocks(sbi, ni.blk_addr);
+       f2fs_invalidate_blocks(sbi, ni.blk_addr, 1);
        dec_valid_node_count(sbi, dn->inode, dn->nid == dn->inode->i_ino);
        set_node_addr(sbi, &ni, NULL_ADDR, false);
 
@@ -2765,7 +2765,7 @@ int f2fs_recover_xattr_data(struct inode *inode, struct page *page)
        if (err)
                return err;
 
-       f2fs_invalidate_blocks(sbi, ni.blk_addr);
+       f2fs_invalidate_blocks(sbi, ni.blk_addr, 1);
        dec_valid_node_count(sbi, inode, false);
        set_node_addr(sbi, &ni, NULL_ADDR, false);
 

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 67d2859831e4683e712566ab23d957e5c5f13705..813254dcc00e7eaf1f2ec18c33e4c6e71698589e 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -245,7 +245,7 @@ retry:
                if (!__is_valid_data_blkaddr(new_addr)) {
                        if (new_addr == NULL_ADDR)
                                dec_valid_block_count(sbi, inode, 1);
-                       f2fs_invalidate_blocks(sbi, dn.data_blkaddr);
+                       f2fs_invalidate_blocks(sbi, dn.data_blkaddr, 1);
                        f2fs_update_data_blkaddr(&dn, new_addr);
                } else {
                        f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
@@ -2567,25 +2567,43 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
                get_sec_entry(sbi, segno)->valid_blocks += del;
 }
 
-void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)
+void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
+                               unsigned int len)
 {
        unsigned int segno = GET_SEGNO(sbi, addr);
        struct sit_info *sit_i = SIT_I(sbi);
+       block_t addr_start = addr, addr_end = addr + len - 1;
+       unsigned int seg_num = GET_SEGNO(sbi, addr_end) - segno + 1;
+       unsigned int i = 1, max_blocks = sbi->blocks_per_seg, cnt;
 
        f2fs_bug_on(sbi, addr == NULL_ADDR);
        if (addr == NEW_ADDR || addr == COMPRESS_ADDR)
                return;
 
-       f2fs_invalidate_internal_cache(sbi, addr, 1);
+       f2fs_invalidate_internal_cache(sbi, addr, len);
 
        /* add it into sit main buffer */
        down_write(&sit_i->sentry_lock);
 
-       update_segment_mtime(sbi, addr, 0);
-       update_sit_entry(sbi, addr, -1);
+       if (seg_num == 1)
+               cnt = len;
+       else
+               cnt = max_blocks - GET_BLKOFF_FROM_SEG0(sbi, addr);
 
-       /* add it into dirty seglist */
-       locate_dirty_segment(sbi, segno);
+       do {
+               update_segment_mtime(sbi, addr_start, 0);
+               update_sit_entry(sbi, addr_start, -cnt);
+
+               /* add it into dirty seglist */
+               locate_dirty_segment(sbi, segno);
+
+               /* update @addr_start and @cnt and @segno */
+               addr_start = START_BLOCK(sbi, ++segno);
+               if (++i == seg_num)
+                       cnt = GET_BLKOFF_FROM_SEG0(sbi, addr_end) + 1;
+               else
+                       cnt = max_blocks;
+       } while (i <= seg_num);
 
        up_write(&sit_i->sentry_lock);
 }