f2fs: fix changing cursegs if recovery fails on zoned device

Fsync data recovery attempts to check and fix write pointer consistency
of cursegs and all other zones. If the write pointers of cursegs are
unaligned, cursegs are changed to new sections.

If recovery fails, zone write pointers are still checked and fixed,
but the latest checkpoint cannot be written back. Additionally, retry-
mount skips recovery and rolls back to reuse the old cursegs whose
zones are already finished. This can lead to unaligned write later.

This patch addresses the issue by leaving writer pointers untouched if
recovery fails. When retry-mount is performed, cursegs and other zones
are checked and fixed after skipping recovery.

Signed-off-by: Song Feng <songfeng@oppo.com>
Signed-off-by: Yongpeng Yang <yangyongpeng1@oppo.com>
Signed-off-by: Sheng Yong <shengyong@oppo.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 119706dbaefa9ba42c3eb5e50dc88cdf1bcc7c1b..b65b023a588a0e1d52bebabfb31972dd4aebea31 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3775,8 +3775,7 @@ void f2fs_write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
 int f2fs_lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
                        unsigned int val, int alloc);
 void f2fs_flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
-int f2fs_fix_curseg_write_pointer(struct f2fs_sb_info *sbi);
-int f2fs_check_write_pointer(struct f2fs_sb_info *sbi);
+int f2fs_check_and_fix_write_pointer(struct f2fs_sb_info *sbi);
 int f2fs_build_segment_manager(struct f2fs_sb_info *sbi);
 void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi);
 int __init f2fs_create_segment_manager_caches(void);

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index e4d81b8705d1e6450c606197b7e74a95d3a789df..f35be2c48e3c0897dd65b056691b26455cc37e4f 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -899,13 +899,8 @@ skip:
         * and the f2fs is not read only, check and fix zoned block devices'
         * write pointer consistency.
         */
-       if (f2fs_sb_has_blkzoned(sbi) && !f2fs_readonly(sbi->sb)) {
-               int err2 = f2fs_fix_curseg_write_pointer(sbi);
-
-               if (!err2)
-                       err2 = f2fs_check_write_pointer(sbi);
-               if (err2)
-                       err = err2;
+       if (!err) {
+               err = f2fs_check_and_fix_write_pointer(sbi);
                ret = err;
        }
 

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index edf2a74207b355f7a6fb26c563f2c814c009e12c..4236040e3994cc74948b6908fc36539d10e93743 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -5246,7 +5246,7 @@ static int report_one_zone_cb(struct blk_zone *zone, unsigned int idx,
        return 0;
 }
 
-static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
+static int do_fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
 {
        struct curseg_info *cs = CURSEG_I(sbi, type);
        struct f2fs_dev_info *zbd;
@@ -5351,12 +5351,12 @@ static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
        return 0;
 }
 
-int f2fs_fix_curseg_write_pointer(struct f2fs_sb_info *sbi)
+static int fix_curseg_write_pointer(struct f2fs_sb_info *sbi)
 {
        int i, ret;
 
        for (i = 0; i < NR_PERSISTENT_LOG; i++) {
-               ret = fix_curseg_write_pointer(sbi, i);
+               ret = do_fix_curseg_write_pointer(sbi, i);
                if (ret)
                        return ret;
        }
@@ -5379,7 +5379,7 @@ static int check_zone_write_pointer_cb(struct blk_zone *zone, unsigned int idx,
        return check_zone_write_pointer(args->sbi, args->fdev, zone);
 }
 
-int f2fs_check_write_pointer(struct f2fs_sb_info *sbi)
+static int check_write_pointer(struct f2fs_sb_info *sbi)
 {
        int i, ret;
        struct check_zone_write_pointer_args args;
@@ -5399,6 +5399,20 @@ int f2fs_check_write_pointer(struct f2fs_sb_info *sbi)
        return 0;
 }
 
+int f2fs_check_and_fix_write_pointer(struct f2fs_sb_info *sbi)
+{
+       int ret;
+
+       if (!f2fs_sb_has_blkzoned(sbi) || f2fs_readonly(sbi->sb))
+               return 0;
+
+       f2fs_notice(sbi, "Checking entire write pointers");
+       ret = fix_curseg_write_pointer(sbi);
+       if (!ret)
+               ret = check_write_pointer(sbi);
+       return ret;
+}
+
 /*
  * Return the number of usable blocks in a segment. The number of blocks
  * returned is always equal to the number of blocks in a segment for
@@ -5435,12 +5449,7 @@ static inline unsigned int f2fs_usable_zone_blks_in_seg(
        return BLKS_PER_SEG(sbi);
 }
 #else
-int f2fs_fix_curseg_write_pointer(struct f2fs_sb_info *sbi)
-{
-       return 0;
-}
-
-int f2fs_check_write_pointer(struct f2fs_sb_info *sbi)
+int f2fs_check_and_fix_write_pointer(struct f2fs_sb_info *sbi)
 {
        return 0;
 }

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e9d2267b8788011a7b5630be49f6e3ee3dbab178..41cc13b43ce1cb02aa67cd8247bfaacec870ce5d 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -4774,16 +4774,13 @@ try_onemore:
 reset_checkpoint:
        /*
         * If the f2fs is not readonly and fsync data recovery succeeds,
-        * check zoned block devices' write pointer consistency.
+        * write pointer consistency of cursegs and other zones are already
+        * checked and fixed during recovery. However, if recovery fails,
+        * write pointers are left untouched, and retry-mount should check
+        * them here.
         */
-       if (f2fs_sb_has_blkzoned(sbi) && !f2fs_readonly(sb)) {
-               int err2;
-
-               f2fs_notice(sbi, "Checking entire write pointers");
-               err2 = f2fs_check_write_pointer(sbi);
-               if (err2)
-                       err = err2;
-       }
+       if (skip_recovery)
+               err = f2fs_check_and_fix_write_pointer(sbi);
        if (err)
                goto free_meta;