f2fs: check skipped write in f2fs_enable_checkpoint()

This patch introduces sbi->nr_pages[F2FS_SKIPPED_WRITE] to record any
skipped write during data flush in f2fs_enable_checkpoint().

So in the loop of data flush, if there is any skipped write in previous
flush, let's retry sync_inode_sb(), otherwise, all dirty data written
before f2fs_enable_checkpoint() should have been persisted, then break
the retry loop.

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 d509172b51df6791666792c8a34be321a21add9f..25b4d3f21fa7658196ed14044e96698f83e259f8 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3495,6 +3495,16 @@ static inline void account_writeback(struct inode *inode, bool inc)
        f2fs_up_read(&F2FS_I(inode)->i_sem);
 }
 
+static inline void update_skipped_write(struct f2fs_sb_info *sbi,
+                                               struct writeback_control *wbc)
+{
+       long skipped = wbc->pages_skipped;
+
+       if (is_sbi_flag_set(sbi, SBI_ENABLE_CHECKPOINT) && skipped &&
+               wbc->sync_mode == WB_SYNC_ALL)
+               atomic_add(skipped, &sbi->nr_pages[F2FS_SKIPPED_WRITE]);
+}
+
 static int __f2fs_write_data_pages(struct address_space *mapping,
                                                struct writeback_control *wbc,
                                                enum iostat_type io_type)
@@ -3559,10 +3569,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping,
         */
 
        f2fs_remove_dirty_inode(inode);
+
+       /*
+        * f2fs_write_cache_pages() has retry logic for EAGAIN case which is
+        * common when racing w/ checkpoint, so only update skipped write
+        * when ret is non-zero.
+        */
+       if (ret)
+               update_skipped_write(sbi, wbc);
        return ret;
 
 skip_write:
        wbc->pages_skipped += get_dirty_pages(inode);
+       update_skipped_write(sbi, wbc);
        trace_f2fs_writepages(mapping->host, wbc, DATA);
        return 0;
 }

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index 032683835569f85024dfc9fb8554285a152dd4a4..8e1040e375a7b0aeb401404982a34691a5d2204c 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -423,6 +423,7 @@ static const char *s_flag[MAX_SBI_FLAG] = {
        [SBI_IS_RESIZEFS]       = "resizefs",
        [SBI_IS_FREEZING]       = "freezefs",
        [SBI_IS_WRITABLE]       = "writable",
+       [SBI_ENABLE_CHECKPOINT] = "enable_checkpoint",
 };
 
 static const char *ipu_mode_names[F2FS_IPU_MAX] = {

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 035239758e332fa062cbb9ab840344efd4c024ae..52cec6b3ecf0b7be4888522ebd89bb8e00ea01ac 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1238,6 +1238,7 @@ enum count_type {
        F2FS_RD_META,
        F2FS_DIO_WRITE,
        F2FS_DIO_READ,
+       F2FS_SKIPPED_WRITE,     /* skip or fail during f2fs_enable_checkpoint() */
        NR_COUNT_TYPE,
 };
 
@@ -1476,6 +1477,7 @@ enum {
        SBI_IS_RESIZEFS,                        /* resizefs is in process */
        SBI_IS_FREEZING,                        /* freezefs is in process */
        SBI_IS_WRITABLE,                        /* remove ro mountoption transiently */
+       SBI_ENABLE_CHECKPOINT,                  /* indicate it's during f2fs_enable_checkpoint() */
        MAX_SBI_FLAG,
 };
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 97c2264ec7fe306249a7fb3ccd8f42b00c2e6bba..0afe9f829058a1ead1f2e019f044ec06288f1158 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2690,6 +2690,7 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
        long long start, writeback, end;
        int ret;
        struct f2fs_lock_context lc;
+       long long skipped_write, dirty_data;
 
        f2fs_info(sbi, "f2fs_enable_checkpoint() starts, meta: %lld, node: %lld, data: %lld",
                                        get_pages(sbi, F2FS_DIRTY_META),
@@ -2698,17 +2699,45 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
 
        start = ktime_get();
 
+       set_sbi_flag(sbi, SBI_ENABLE_CHECKPOINT);
+
        /* we should flush all the data to keep data consistency */
        do {
+               skipped_write = get_pages(sbi, F2FS_SKIPPED_WRITE);
+               dirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
+
                sync_inodes_sb(sbi->sb);
                f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
-       } while (get_pages(sbi, F2FS_DIRTY_DATA) && retry--);
+
+               f2fs_info(sbi, "sync_inode_sb done, dirty_data: %lld, %lld, "
+                               "skipped write: %lld, %lld, retry: %d",
+                               get_pages(sbi, F2FS_DIRTY_DATA),
+                               dirty_data,
+                               get_pages(sbi, F2FS_SKIPPED_WRITE),
+                               skipped_write, retry);
+
+               /*
+                * sync_inodes_sb() has retry logic, so let's check dirty_data
+                * in prior to skipped_write in case there is no dirty data.
+                */
+               if (!get_pages(sbi, F2FS_DIRTY_DATA))
+                       break;
+               if (get_pages(sbi, F2FS_SKIPPED_WRITE) == skipped_write)
+                       break;
+       } while (retry--);
+
+       clear_sbi_flag(sbi, SBI_ENABLE_CHECKPOINT);
 
        writeback = ktime_get();
 
-       if (unlikely(get_pages(sbi, F2FS_DIRTY_DATA)))
-               f2fs_warn(sbi, "checkpoint=enable has some unwritten data: %lld",
-                                       get_pages(sbi, F2FS_DIRTY_DATA));
+       if (unlikely(get_pages(sbi, F2FS_DIRTY_DATA) ||
+                       get_pages(sbi, F2FS_SKIPPED_WRITE)))
+               f2fs_warn(sbi, "checkpoint=enable unwritten data: %lld, skipped data: %lld, retry: %d",
+                               get_pages(sbi, F2FS_DIRTY_DATA),
+                               get_pages(sbi, F2FS_SKIPPED_WRITE), retry);
+
+       if (get_pages(sbi, F2FS_SKIPPED_WRITE))
+               atomic_set(&sbi->nr_pages[F2FS_SKIPPED_WRITE], 0);
 
        f2fs_down_write_trace(&sbi->gc_lock, &lc);
        f2fs_dirty_to_prefree(sbi);