f2fs: don't wait writeback for datas during checkpoint

Normally, while committing checkpoint, we will wait on all pages to be
writebacked no matter the page is data or metadata, so in scenario where
there are lots of data IO being submitted with metadata, we may suffer
long latency for waiting writeback during checkpoint.

Indeed, we only care about persistence for pages with metadata, but not
pages with data, as file system consistent are only related to metadate,
so in order to avoid encountering long latency in above scenario, let's
recognize and reference metadata in submitted IOs, wait writeback only
for metadatas.

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

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index e5677e4a69d6bcf3c32e9d80fc4bf877bd0a9eff..54cc6a9a0d304426d697d1fe6620ce57d3923fe6 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1002,7 +1002,7 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
        for (;;) {
                prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);
 
-               if (!atomic_read(&sbi->nr_wb_bios))
+               if (!get_pages(sbi, F2FS_WB_CP_DATA))
                        break;
 
                io_schedule_timeout(5*HZ);

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 59203a3c143eb5f866bada2d46ae552817970529..8c5b63bda68be1921e0b8b98743bd5698892225d 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -29,6 +29,26 @@
 #include "trace.h"
 #include <trace/events/f2fs.h>
 
+static bool __is_cp_guaranteed(struct page *page)
+{
+       struct address_space *mapping = page->mapping;
+       struct inode *inode;
+       struct f2fs_sb_info *sbi;
+
+       if (!mapping)
+               return false;
+
+       inode = mapping->host;
+       sbi = F2FS_I_SB(inode);
+
+       if (inode->i_ino == F2FS_META_INO(sbi) ||
+                       inode->i_ino ==  F2FS_NODE_INO(sbi) ||
+                       S_ISDIR(inode->i_mode) ||
+                       is_cold_data(page))
+               return true;
+       return false;
+}
+
 static void f2fs_read_end_io(struct bio *bio)
 {
        struct bio_vec *bvec;
@@ -71,6 +91,7 @@ static void f2fs_write_end_io(struct bio *bio)
 
        bio_for_each_segment_all(bvec, bio, i) {
                struct page *page = bvec->bv_page;
+               enum count_type type = WB_DATA_TYPE(page);
 
                fscrypt_pullback_bio_page(&page, true);
 
@@ -78,9 +99,11 @@ static void f2fs_write_end_io(struct bio *bio)
                        mapping_set_error(page->mapping, -EIO);
                        f2fs_stop_checkpoint(sbi, true);
                }
+               dec_page_count(sbi, type);
+               clear_cold_data(page);
                end_page_writeback(page);
        }
-       if (atomic_dec_and_test(&sbi->nr_wb_bios) &&
+       if (!get_pages(sbi, F2FS_WB_CP_DATA) &&
                                wq_has_sleeper(&sbi->cp_wait))
                wake_up(&sbi->cp_wait);
 
@@ -148,7 +171,6 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi,
                                struct bio *bio, enum page_type type)
 {
        if (!is_read_io(bio_op(bio))) {
-               atomic_inc(&sbi->nr_wb_bios);
                if (f2fs_sb_mounted_blkzoned(sbi->sb) &&
                        current->plug && (type == DATA || type == NODE))
                        blk_finish_plug(current->plug);
@@ -309,6 +331,11 @@ void f2fs_submit_page_mbio(struct f2fs_io_info *fio)
                verify_block_addr(sbi, fio->old_blkaddr);
        verify_block_addr(sbi, fio->new_blkaddr);
 
+       bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
+
+       if (!is_read)
+               inc_page_count(sbi, WB_DATA_TYPE(bio_page));
+
        down_write(&io->io_rwsem);
 
        if (io->bio && (io->last_block_in_bio != fio->new_blkaddr - 1 ||
@@ -322,8 +349,6 @@ alloc_new:
                io->fio = *fio;
        }
 
-       bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;
-
        if (bio_add_page(io->bio, bio_page, PAGE_SIZE, 0) <
                                                        PAGE_SIZE) {
                __submit_merged_bio(io);
@@ -1339,7 +1364,6 @@ done:
        if (err && err != -ENOENT)
                goto redirty_out;
 
-       clear_cold_data(page);
 out:
        inode_dec_dirty_pages(inode);
        if (err)
@@ -1742,7 +1766,6 @@ static int f2fs_write_end(struct file *file,
                goto unlock_out;
 
        set_page_dirty(page);
-       clear_cold_data(page);
 
        if (pos + copied > i_size_read(inode))
                f2fs_i_size_write(inode, pos + copied);

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index 2fdf23398fa14200d28cc0f6826e0e7b918e44f4..67a04d8074bb5bcda0064b07701e89aae8a5701e 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -50,7 +50,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
        si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
        si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
        si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES);
-       si->wb_bios = atomic_read(&sbi->nr_wb_bios);
+       si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
+       si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);
        si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
        si->rsvd_segs = reserved_segments(sbi);
        si->overp_segs = overprovision_segments(sbi);
@@ -313,8 +314,8 @@ static int stat_show(struct seq_file *s, void *v)
                seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
                                si->ext_tree, si->zombie_tree, si->ext_node);
                seq_puts(s, "\nBalancing F2FS Async:\n");
-               seq_printf(s, "  - inmem: %4d, wb_bios: %4d\n",
-                          si->inmem_pages, si->wb_bios);
+               seq_printf(s, "  - inmem: %4d, wb_cp_data: %4d, wb_data: %4d\n",
+                          si->inmem_pages, si->nr_wb_cp_data, si->nr_wb_data);
                seq_printf(s, "  - nodes: %4d in %4d\n",
                           si->ndirty_node, si->node_pages);
                seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index c963fa8d6895a5a571bb040a5d92bb769208b8c2..ae758e8c245d0ee47455ba45afe248c74aaad2d9 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -654,6 +654,7 @@ struct f2fs_sm_info {
  * f2fs monitors the number of several block types such as on-writeback,
  * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
  */
+#define WB_DATA_TYPE(p)        (__is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
 enum count_type {
        F2FS_DIRTY_DENTS,
        F2FS_DIRTY_DATA,
@@ -661,6 +662,8 @@ enum count_type {
        F2FS_DIRTY_META,
        F2FS_INMEM_PAGES,
        F2FS_DIRTY_IMETA,
+       F2FS_WB_CP_DATA,
+       F2FS_WB_DATA,
        NR_COUNT_TYPE,
 };
 
@@ -840,7 +843,6 @@ struct f2fs_sb_info {
        block_t discard_blks;                   /* discard command candidats */
        block_t last_valid_block_count;         /* for recovery */
        u32 s_next_generation;                  /* for NFS support */
-       atomic_t nr_wb_bios;                    /* # of writeback bios */
 
        /* # of pages, see count_type */
        atomic_t nr_pages[NR_COUNT_TYPE];
@@ -1254,7 +1256,8 @@ static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
 {
        atomic_inc(&sbi->nr_pages[count_type]);
 
-       if (count_type == F2FS_DIRTY_DATA || count_type == F2FS_INMEM_PAGES)
+       if (count_type == F2FS_DIRTY_DATA || count_type == F2FS_INMEM_PAGES ||
+               count_type == F2FS_WB_CP_DATA || count_type == F2FS_WB_DATA)
                return;
 
        set_sbi_flag(sbi, SBI_IS_DIRTY);
@@ -2209,7 +2212,7 @@ struct f2fs_stat_info {
        unsigned int ndirty_dirs, ndirty_files, ndirty_all;
        int nats, dirty_nats, sits, dirty_sits, free_nids, alloc_nids;
        int total_count, utilization;
-       int bg_gc, wb_bios;
+       int bg_gc, nr_wb_cp_data, nr_wb_data;
        int inline_xattr, inline_inode, inline_dir, orphans;
        unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
        unsigned int bimodal, avg_vblocks;

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 9ea89ca8fd0b9347c5f5e5d5a196cbf916547e7d..f9883d597b42f9117ab0d4e7af6e8745bdc51e1f 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -94,8 +94,6 @@ mapped:
        if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
                f2fs_wait_on_encrypted_page_writeback(sbi, dn.data_blkaddr);
 
-       /* if gced page is attached, don't write to cold segment */
-       clear_cold_data(page);
 out:
        sb_end_pagefault(inode->i_sb);
        f2fs_update_time(sbi, REQ_TIME);

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 36f6cfc613d34991cc42ec3f964ea0800d1b0881..5c2fe68be549b1d44ed04a2b590388e6181a8203 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -693,8 +693,6 @@ retry:
                        congestion_wait(BLK_RW_ASYNC, HZ/50);
                        goto retry;
                }
-
-               clear_cold_data(page);
        }
 out:
        f2fs_put_page(page, 1);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 808cb68008529ece832de3a2f48a98cf14af710a..c8dc037dbfa1861abd8cf1c7c80c384537b1e7d7 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -290,7 +290,6 @@ static int __commit_inmem_pages(struct inode *inode,
                        /* record old blkaddr for revoking */
                        cur->old_addr = fio.old_blkaddr;
 
-                       clear_cold_data(page);
                        submit_bio = true;
                }
                unlock_page(page);