f2fs: use meta_inode cache to improve roll-forward speed
Jaegeuk Kim [Thu, 11 Sep 2014 20:49:55 +0000 (13:49 -0700)]
Previously, all the dnode pages should be read during the roll-forward recovery.
Even worsely, whole the chain was traversed twice.
This patch removes that redundant and costly read operations by using page cache
of meta_inode and readahead function as well.

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

Conflicts:
fs/f2fs/recovery.c

Change-Id: I8953277ddf6b333a3fd1f112ebf4e6b26ab9a0b4

fs/f2fs/checkpoint.c
fs/f2fs/f2fs.h
fs/f2fs/recovery.c
fs/f2fs/segment.h

index 6659a2b..17a680c 100644 (file)
@@ -73,7 +73,23 @@ out:
        return page;
 }
 
-static inline int get_max_meta_blks(struct f2fs_sb_info *sbi, int type)
+struct page *get_meta_page_ra(struct f2fs_sb_info *sbi, pgoff_t index)
+{
+       bool readahead = false;
+       struct page *page;
+
+       page = find_get_page(META_MAPPING(sbi), index);
+       if (!page || (page && !PageUptodate(page)))
+               readahead = true;
+       f2fs_put_page(page, 0);
+
+       if (readahead)
+               ra_meta_pages(sbi, index,
+                               MAX_BIO_BLOCKS(max_hw_blocks(sbi)), META_POR);
+       return get_meta_page(sbi, index);
+}
+
+static inline block_t get_max_meta_blks(struct f2fs_sb_info *sbi, int type)
 {
        switch (type) {
        case META_NAT:
@@ -83,6 +99,8 @@ static inline int get_max_meta_blks(struct f2fs_sb_info *sbi, int type)
        case META_SSA:
        case META_CP:
                return 0;
+       case META_POR:
+               return SM_I(sbi)->seg0_blkaddr + TOTAL_BLKS(sbi);
        default:
                BUG();
        }
@@ -91,12 +109,13 @@ static inline int get_max_meta_blks(struct f2fs_sb_info *sbi, int type)
 /*
  * Readahead CP/NAT/SIT/SSA pages
  */
-int ra_meta_pages(struct f2fs_sb_info *sbi, int start, int nrpages, int type)
+int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int type)
 {
        block_t prev_blk_addr = 0;
        struct page *page;
-       int blkno = start;
-       int max_blks = get_max_meta_blks(sbi, type);
+       block_t blkno = start;
+       block_t max_blks = get_max_meta_blks(sbi, type);
+       block_t min_blks = SM_I(sbi)->seg0_blkaddr;
 
        struct f2fs_io_info fio = {
                .type = META,
@@ -126,7 +145,11 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, int start, int nrpages, int type)
                        break;
                case META_SSA:
                case META_CP:
-                       /* get ssa/cp block addr */
+               case META_POR:
+                       if (unlikely(blkno >= max_blks))
+                               goto out;
+                       if (unlikely(blkno < min_blks))
+                               goto out;
                        blk_addr = blkno;
                        break;
                default:
index c3cb7bc..9941b83 100644 (file)
@@ -106,7 +106,8 @@ enum {
        META_CP,
        META_NAT,
        META_SIT,
-       META_SSA
+       META_SSA,
+       META_POR,
 };
 
 /* for the list of ino */
@@ -1358,7 +1359,8 @@ void destroy_segment_manager_caches(void);
  */
 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
-int ra_meta_pages(struct f2fs_sb_info *, int, int, int);
+struct page *get_meta_page_ra(struct f2fs_sb_info *, pgoff_t);
+int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int);
 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
 void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
 void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
index f78efa5..72583cb 100644 (file)
@@ -141,7 +141,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
 {
        unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
        struct curseg_info *curseg;
-       struct page *page;
+       struct page *page = NULL;
        block_t blkaddr;
        int err = 0;
 
@@ -149,20 +149,14 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
        curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
        blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
 
-       /* read node page */
-       page = alloc_page(GFP_F2FS_ZERO);
-       if (!page)
-               return -ENOMEM;
-       lock_page(page);
-
        while (1) {
                struct fsync_inode_entry *entry;
 
-               err = f2fs_submit_page_bio(sbi, page, blkaddr, READ_SYNC);
-               if (err)
-                       return err;
+               if (blkaddr < SM_I(sbi)->main_blkaddr ||
+                       blkaddr >= (SM_I(sbi)->seg0_blkaddr + TOTAL_BLKS(sbi)))
+                       return 0;
 
-               lock_page(page);
+               page = get_meta_page_ra(sbi, blkaddr);
 
                if (cp_ver != cpver_of_node(page))
                        break;
@@ -216,11 +210,9 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
 next:
                /* check next segment */
                blkaddr = next_blkaddr_of_node(page);
+               f2fs_put_page(page, 1);
        }
-
-       unlock_page(page);
-       __free_pages(page, 0);
-
+       f2fs_put_page(page, 1);
        return err;
 }
 
@@ -435,7 +427,7 @@ static int recover_data(struct f2fs_sb_info *sbi,
 {
        unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
        struct curseg_info *curseg;
-       struct page *page;
+       struct page *page = NULL;
        int err = 0;
        block_t blkaddr;
 
@@ -443,28 +435,19 @@ static int recover_data(struct f2fs_sb_info *sbi,
        curseg = CURSEG_I(sbi, type);
        blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
 
-       /* read node page */
-       page = alloc_page(GFP_F2FS_ZERO);
-       if (!page)
-               return -ENOMEM;
-
-       lock_page(page);
-
        while (1) {
                struct fsync_inode_entry *entry;
 
-               err = f2fs_submit_page_bio(sbi, page, blkaddr, READ_SYNC);
-               if (err) {
-                       f2fs_msg(sbi->sb, KERN_INFO,
-                               "%s: f2fs_readpage failed: %d",
-                               __func__, err);
-                       return err;
-               }
+               if (blkaddr < SM_I(sbi)->main_blkaddr ||
+                       blkaddr >= (SM_I(sbi)->seg0_blkaddr + TOTAL_BLKS(sbi)))
+                       break;
 
-               lock_page(page);
+               page = get_meta_page_ra(sbi, blkaddr);
 
-               if (cp_ver != cpver_of_node(page))
+               if (cp_ver != cpver_of_node(page)) {
+                       f2fs_put_page(page, 1);
                        break;
+               }
 
                entry = get_fsync_inode(head, ino_of_node(page));
                if (!entry)
@@ -472,6 +455,7 @@ static int recover_data(struct f2fs_sb_info *sbi,
 
                err = do_recover_data(sbi, entry->inode, page, blkaddr);
                if (err) {
+                       f2fs_put_page(page, 1);
                        f2fs_msg(sbi->sb, KERN_INFO,
                                "%s: do_recover_data failed: %d",
                                __func__, err);
@@ -486,11 +470,8 @@ static int recover_data(struct f2fs_sb_info *sbi,
 next:
                /* check next segment */
                blkaddr = next_blkaddr_of_node(page);
+               f2fs_put_page(page, 1);
        }
-
-       unlock_page(page);
-       __free_pages(page, 0);
-
        if (!err)
                allocate_new_segments(sbi);
        return err;
@@ -541,6 +522,10 @@ out:
        destroy_fsync_dnodes(&inode_list);
        kmem_cache_destroy(fsync_entry_slab);
 
+       /* truncate meta pages to be used by the recovery */
+       truncate_inode_pages_range(META_MAPPING(sbi),
+               SM_I(sbi)->main_blkaddr << PAGE_CACHE_SHIFT, -1);
+
        if (err) {
                truncate_inode_pages(NODE_MAPPING(sbi), 0);
                truncate_inode_pages(META_MAPPING(sbi), 0);
index 0c5dca4..c42129d 100644 (file)
@@ -87,6 +87,7 @@
        (BITS_TO_LONGS(nr) * sizeof(unsigned long))
 #define TOTAL_SEGS(sbi)        (SM_I(sbi)->main_segments)
 #define TOTAL_SECS(sbi)        (sbi->total_sections)
+#define TOTAL_BLKS(sbi)        (SM_I(sbi)->segment_count << sbi->log_blocks_per_seg)
 
 #define SECTOR_FROM_BLOCK(sbi, blk_addr)                               \
        (((sector_t)blk_addr) << (sbi)->log_sectors_per_block)
@@ -553,7 +554,7 @@ static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
 static inline void verify_block_addr(struct f2fs_sb_info *sbi, block_t blk_addr)
 {
        struct f2fs_sm_info *sm_info = SM_I(sbi);
-       block_t total_blks = sm_info->segment_count << sbi->log_blocks_per_seg;
+       block_t total_blks = TOTAL_BLKS(sbi);
        block_t start_addr = sm_info->seg0_blkaddr;
        block_t end_addr = start_addr + total_blks - 1;
        BUG_ON(blk_addr < start_addr);
@@ -606,7 +607,7 @@ static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
 static inline void verify_block_addr(struct f2fs_sb_info *sbi, block_t blk_addr)
 {
        struct f2fs_sm_info *sm_info = SM_I(sbi);
-       block_t total_blks = sm_info->segment_count << sbi->log_blocks_per_seg;
+       block_t total_blks = TOTAL_BLKS(sbi);
        block_t start_addr = sm_info->seg0_blkaddr;
        block_t end_addr = start_addr + total_blks - 1;