f2fs: introduce universal lookup/update interface for extent cache

In this patch, we do these jobs:
1. rename {check,update}_extent_cache to {lookup,update}_extent_info;
2. introduce universal lookup/update interface of extent cache:
f2fs_{lookup,update}_extent_cache including above two real functions, then
export them to function callers.

So after above cleanup, we can add new rb-tree based extent cache into exported
interfaces.

v2:
 o remove "f2fs_" for inner function {lookup,update}_extent_info suggested by
   Jaegeuk Kim.

Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index bce0372a90d4246dfd7ce4313a73580f202d5126..3dbaa475fce4c6438fcea76b886c8324e2bf1ce8 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -263,20 +263,20 @@ static void f2fs_map_bh(struct super_block *sb, pgoff_t pgofs,
                bh_result->b_size = UINT_MAX;
 }
 
-static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
-                                       struct extent_info *ei)
+static bool lookup_extent_info(struct inode *inode, pgoff_t pgofs,
+                                                       struct extent_info *ei)
 {
        struct f2fs_inode_info *fi = F2FS_I(inode);
        pgoff_t start_fofs, end_fofs;
        block_t start_blkaddr;
 
        if (is_inode_flag_set(fi, FI_NO_EXTENT))
-               return 0;
+               return false;
 
        read_lock(&fi->ext_lock);
        if (fi->ext.len == 0) {
                read_unlock(&fi->ext_lock);
-               return 0;
+               return false;
        }
 
        stat_inc_total_hit(inode->i_sb);
@@ -289,29 +289,22 @@ static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
                *ei = fi->ext;
                stat_inc_read_hit(inode->i_sb);
                read_unlock(&fi->ext_lock);
-               return 1;
+               return true;
        }
        read_unlock(&fi->ext_lock);
-       return 0;
+       return false;
 }
 
-void update_extent_cache(struct dnode_of_data *dn)
+static bool update_extent_info(struct inode *inode, pgoff_t fofs,
+                                                               block_t blkaddr)
 {
-       struct f2fs_inode_info *fi = F2FS_I(dn->inode);
-       pgoff_t fofs, start_fofs, end_fofs;
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       pgoff_t start_fofs, end_fofs;
        block_t start_blkaddr, end_blkaddr;
        int need_update = true;
 
-       f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR);
-
-       /* Update the page address in the parent node */
-       __set_data_blkaddr(dn);
-
        if (is_inode_flag_set(fi, FI_NO_EXTENT))
-               return;
-
-       fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
-                                                       dn->ofs_in_node;
+               return false;
 
        write_lock(&fi->ext_lock);
 
@@ -326,16 +319,16 @@ void update_extent_cache(struct dnode_of_data *dn)
 
        /* Initial extent */
        if (fi->ext.len == 0) {
-               if (dn->data_blkaddr != NULL_ADDR) {
+               if (blkaddr != NULL_ADDR) {
                        fi->ext.fofs = fofs;
-                       fi->ext.blk = dn->data_blkaddr;
+                       fi->ext.blk = blkaddr;
                        fi->ext.len = 1;
                }
                goto end_update;
        }
 
        /* Front merge */
-       if (fofs == start_fofs - 1 && dn->data_blkaddr == start_blkaddr - 1) {
+       if (fofs == start_fofs - 1 && blkaddr == start_blkaddr - 1) {
                fi->ext.fofs--;
                fi->ext.blk--;
                fi->ext.len++;
@@ -343,7 +336,7 @@ void update_extent_cache(struct dnode_of_data *dn)
        }
 
        /* Back merge */
-       if (fofs == end_fofs + 1 && dn->data_blkaddr == end_blkaddr + 1) {
+       if (fofs == end_fofs + 1 && blkaddr == end_blkaddr + 1) {
                fi->ext.len++;
                goto end_update;
        }
@@ -370,9 +363,30 @@ void update_extent_cache(struct dnode_of_data *dn)
        }
 end_update:
        write_unlock(&fi->ext_lock);
-       if (need_update)
+       return need_update;
+}
+
+static bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
+                                                       struct extent_info *ei)
+{
+       return lookup_extent_info(inode, pgofs, ei);
+}
+
+void f2fs_update_extent_cache(struct dnode_of_data *dn)
+{
+       struct f2fs_inode_info *fi = F2FS_I(dn->inode);
+       pgoff_t fofs;
+
+       f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR);
+
+       /* Update the page address in the parent node */
+       __set_data_blkaddr(dn);
+
+       fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
+                                                       dn->ofs_in_node;
+
+       if (update_extent_info(dn->inode, fofs, dn->data_blkaddr))
                sync_inode_page(dn);
-       return;
 }
 
 struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
@@ -668,7 +682,7 @@ static int __get_data_block(struct inode *inode, sector_t iblock,
        /* Get the page offset from the block offset(iblock) */
        pgofs = (pgoff_t)(iblock >> (PAGE_CACHE_SHIFT - blkbits));
 
-       if (check_extent_cache(inode, pgofs, &ei)) {
+       if (f2fs_lookup_extent_cache(inode, pgofs, &ei)) {
                f2fs_map_bh(inode->i_sb, pgofs, &ei, bh_result);
                goto out;
        }
@@ -835,7 +849,7 @@ int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
                set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
        } else {
                write_data_page(page, &dn, fio);
-               update_extent_cache(&dn);
+               f2fs_update_extent_cache(&dn);
                set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
        }
 out_writepage:

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 5d2e52e31fac27fb697222e23a3a3a36914256b5..f3fbfa91de8eb1ae81376ec09ff3c7d819a06e1a 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1513,7 +1513,7 @@ void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *,
                                                struct f2fs_io_info *);
 int reserve_new_block(struct dnode_of_data *);
 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
-void update_extent_cache(struct dnode_of_data *);
+void f2fs_update_extent_cache(struct dnode_of_data *);
 struct page *find_data_page(struct inode *, pgoff_t, bool);
 struct page *get_lock_data_page(struct inode *, pgoff_t);
 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 98dac27bc3f733975fabc96404ab30a916b20e7c..baadaf2afc6c8895cd3111723469a00f3c9d8100 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -433,7 +433,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                        continue;
 
                dn->data_blkaddr = NULL_ADDR;
-               update_extent_cache(dn);
+               f2fs_update_extent_cache(dn);
                invalidate_blocks(sbi, blkaddr);
                nr_free++;
        }

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 82b74415b623dee01905d4c074ba06f89ad02c2d..4ba97320d194f496eddf809bce1e8fe318644203 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -122,7 +122,7 @@ no_update:
        set_page_writeback(page);
        fio.blk_addr = dn->data_blkaddr;
        write_data_page(page, dn, &fio);
-       update_extent_cache(dn);
+       f2fs_update_extent_cache(dn);
        f2fs_wait_on_page_writeback(page, DATA);
        if (dirty)
                inode_dec_dirty_pages(dn->inode);

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 41afb9534bbdcb66a20ea6650fc71f62a8b99034..188a03449c5cbced2563a2ffc980fa48874bc9ae 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -401,7 +401,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
                        /* write dummy data page */
                        recover_data_page(sbi, NULL, &sum, src, dest);
                        dn.data_blkaddr = dest;
-                       update_extent_cache(&dn);
+                       f2fs_update_extent_cache(&dn);
                        recovered++;
                }
                dn.ofs_in_node++;