f2fs: prevent meta updates while checkpoint is in progress
Subsystems (2)
PATCH 1/1 f2fs: prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)
fs/f2fs/gc.c +2 -0
@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {
Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Jaegeuk Kim
maintainerHi Sahitya,
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
Doesn't freeze|thaw_bdev(sbi->sb->s_bdev); work for you?
Quoted 24 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Hi all,
Quoted 9 lines · Jaegeuk Kim
Hi Sahitya,
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Doesn't freeze|thaw_bdev(sbi->sb->s_bdev); work for you?
That can avoid foreground ops racing? rather than background ops like balance_fs() from kworker?
BTW, I found that {freeze,thaw}_bdev is not enough to freeze all foreground fs ops, it needs to use {freeze,thaw}_super instead.
--- fs/f2fs/gc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/f2fs/gc.c +3 -3
@@ -1538,7 +1538,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));
@@ -1551,7 +1551,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }
@@ -1613,6 +1613,6 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) }clear_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }
Signature · 1 line
2.18.0.rc1
Quoted 27 lines
Quoted 25 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project..
Quoted 11 lines · Chao Yu
Hi all,
Quoted 8 lines · Jaegeuk Kim
Hi Sahitya,
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
Quoted 5 lines
Quoted 1 line
Doesn't freeze|thaw_bdev(sbi->sb->s_bdev); work for you?
That can avoid foreground ops racing? rather than background ops like
balance_fs()from kworker?
Yes, that can only prevent foreground ops but not the background ops invoked in the context of kworker thread.
Quoted 3 lines
BTW, I found that {freeze,thaw}_bdev is not enough to freeze all foreground fs ops, it needs to use {freeze,thaw}_super instead.
Yes, I agree.
Thanks,
Quoted 64 lines
--- fs/f2fs/gc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)fs/f2fs/gc.c +3
-3@@ -1538,7 +1538,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));@@ -1551,7 +1551,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }@@ -1613,6 +1613,6 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) }clear_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }Signature · 1 line
2.18.0.rc1Quoted 27 lines
Quoted 25 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project..
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Jaegeuk Kim
maintainerQuoted 18 lines · Sahitya Tummala
Quoted 11 lines · Chao Yu
Hi all,
Quoted 8 lines · Jaegeuk Kim
Hi Sahitya,
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Quoted 5 lines
Quoted 1 line
Doesn't freeze|thaw_bdev(sbi->sb->s_bdev); work for you?
That can avoid foreground ops racing? rather than background ops like
balance_fs()from kworker?
Quoted 8 lines
Yes, that can only prevent foreground ops but not the background ops invoked in the context of kworker thread.
Quoted 3 lines
BTW, I found that {freeze,thaw}_bdev is not enough to freeze all foreground fs ops, it needs to use {freeze,thaw}_super instead.
Yes, I agree.
sgtm. :)
Quoted 60 lines
Thanks,
Quoted 57 lines
--- fs/f2fs/gc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)fs/f2fs/gc.c +3
-3@@ -1538,7 +1538,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));@@ -1551,7 +1551,7 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }@@ -1613,6 +1613,6 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) }clear_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +thaw_super (sbi->sb);return err; }Signature · 1 line
2.18.0.rc1Quoted 20 lines
Quoted 20 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);
Quoted 12 lines
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
fs/f2fs/gc.c +0
-0/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project..
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 6 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>
Thanks,
Jaegeuk Kim
maintainerQuoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
I'd prefer to use f2fs_lock_op() in bigger coverage.
Quoted 24 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Quoted 7 lines · Jaegeuk Kim
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.I'd prefer to use
f2fs_lock_op()in bigger coverage.
Do you mean to cover the entire free_segment_range() function within f2fs_lock_op()? Please clarify.
Thanks,
Quoted 25 lines
Quoted 25 lines
Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/gc.c | 2 ++ 1 file changed, 2 insertions(+)fs/f2fs/gc.c +2
-0@@ -1399,8 +1399,10 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,int err =0 ;/* Move out cursegs from the target range */ +f2fs_lock_op (sbi);for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)allocate_segment_for_resize (sbi, type, start, end); +f2fs_unlock_op (sbi);/* do GC to move out valid blocks in the range */ for (segno = start; segno <= end; segno += sbi->segs_per_sec) {Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Jaegeuk Kim
maintainerQuoted 11 lines · Sahitya Tummala
Quoted 7 lines · Jaegeuk Kim
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.I'd prefer to use
f2fs_lock_op()in bigger coverage.Do you mean to cover the entire
free_segment_range()function withinf2fs_lock_op()? Please clarify.
I didn't test tho, something like this?
--- fs/f2fs/checkpoint.c | 6 ++++-- fs/f2fs/f2fs.h | 2 +- fs/f2fs/gc.c | 28 ++++++++++++++-------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +++- 5 files changed, 22 insertions(+), 19 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1417,7 +1418,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/gc.c +14 -14
@@ -1402,8 +1402,9 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start,unsigned int end) { -int type;unsigned int segno, next_inuse; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int type;int err =0 ;/* Move out cursegs from the target range */
@@ -1417,16 +1418,14 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);if (get_valid_blocks (sbi, segno, true))return -EAGAIN ; } - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err)return err;
@@ -1502,6 +1501,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs;int gc_mode, gc_type;int err =0 ;
@@ -1538,7 +1538,9 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));
@@ -1551,11 +1553,12 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; } -mutex_lock (&sbi->resize_mutex);set_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_lock (&DIRTY_I (sbi)->seglist_lock);
@@ -1587,17 +1590,13 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) goto out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); }
@@ -1612,7 +1611,8 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)spin_unlock (&sbi->stat_lock); }clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; }
fs/f2fs/super.c +0 -1
@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 1 line
2.26.0.rc2.310.g2932bb562d-goog
Quoted 109 lines · Jaegeuk Kim
Quoted 11 lines · Sahitya Tummala
Quoted 7 lines · Jaegeuk Kim
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.I'd prefer to use
f2fs_lock_op()in bigger coverage.Do you mean to cover the entire
free_segment_range()function withinf2fs_lock_op()? Please clarify.I didn't test tho, something like this?
--- fs/f2fs/checkpoint.c | 6 ++++-- fs/f2fs/f2fs.h | 2 +- fs/f2fs/gc.c | 28 ++++++++++++++-------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +++- 5 files changed, 22 insertions(+), 19 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1417,7 +1418,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/gc.c +4
-4@@ -1402,8 +1402,9 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start,unsigned int end) { -int type;unsigned int segno, next_inuse; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int type;int err =0 ;/* Move out cursegs from the target range */ @@ -1417,16 +1418,14 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);if (get_valid_blocks (sbi, segno, true))return -EAGAIN ; } - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err)return err;@@ -1502,6 +1501,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs;int gc_mode, gc_type;int err =0 ;
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1541
Quoted 5 lines
fs/f2fs/gc.c +1
-1@@ -1538,7 +1538,9 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb);
Look at this again, I guess holding freeze lock here may cause potential hang task issue, imaging that in a low-end storage, shrinking large size address space, free_segment_range() needs very long time to migrate all valid blocks in the tail of device, that's why previously we do block migration with small gc_lock coverage.
Quoted:
Changelog v5 ==> v6:
- In free_segment_range(), reduce granularity of gc_mutex.
Thanks,
Quoted 85 lines
fs/f2fs/gc.c +9
-9+down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));@@ -1551,11 +1553,12 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; } -mutex_lock (&sbi->resize_mutex);set_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_lock (&DIRTY_I (sbi)->seglist_lock);@@ -1587,17 +1590,13 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) goto out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); }@@ -1612,7 +1611,8 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)spin_unlock (&sbi->stat_lock); }clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Jaegeuk Kim
maintainerQuoted 113 lines · Chao Yu
Quoted 112 lines · Jaegeuk Kim
Quoted 11 lines · Sahitya Tummala
Quoted 7 lines · Jaegeuk Kim
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.I'd prefer to use
f2fs_lock_op()in bigger coverage.Do you mean to cover the entire
free_segment_range()function withinf2fs_lock_op()? Please clarify.I didn't test tho, something like this?
--- fs/f2fs/checkpoint.c | 6 ++++-- fs/f2fs/f2fs.h | 2 +- fs/f2fs/gc.c | 28 ++++++++++++++-------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +++- 5 files changed, 22 insertions(+), 19 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1417,7 +1418,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/gc.c +4
-4@@ -1402,8 +1402,9 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start,unsigned int end) { -int type;unsigned int segno, next_inuse; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int type;int err =0 ;/* Move out cursegs from the target range */ @@ -1417,16 +1418,14 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);if (get_valid_blocks (sbi, segno, true))return -EAGAIN ; } - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err)return err;@@ -1502,6 +1501,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs;int gc_mode, gc_type;int err =0 ;@@ -1538,7 +1538,9 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; }
Quoted 8 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1541
Quoted 2 lines
fs/f2fs/gc.c +1
-1-freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb);Look at this again, I guess holding freeze lock here may cause potential hang task issue, imaging that in a low-end storage, shrinking large size address space,
free_segment_range()needs very long time to migrate all valid blocks in the tail of device, that's why previously we do block migration with smallgc_lockcoverage.
Hmm, it seems we had to do like:
1) do GC
2) freeze everything
3) check it's okay to go new metadata
4) do resize
5) thaw
Quoted 93 lines
Quoted:
Changelog v5 ==> v6:
- Infree_segment_range(), reduce granularity ofgc_mutex.Thanks,
Quoted 85 lines
fs/f2fs/gc.c +9
-9+down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));@@ -1551,11 +1553,12 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; } -mutex_lock (&sbi->resize_mutex);set_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_lock (&DIRTY_I (sbi)->seglist_lock);@@ -1587,17 +1590,13 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) goto out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); }@@ -1612,7 +1611,8 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)spin_unlock (&sbi->stat_lock); }clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Thanks,
Quoted 201 lines · Jaegeuk Kim
Quoted 11 lines · Sahitya Tummala
Quoted 7 lines · Jaegeuk Kim
Quoted 4 lines · Sahitya Tummala
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.I'd prefer to use
f2fs_lock_op()in bigger coverage.Do you mean to cover the entire
free_segment_range()function withinf2fs_lock_op()? Please clarify.I didn't test tho, something like this?
--- fs/f2fs/checkpoint.c | 6 ++++-- fs/f2fs/f2fs.h | 2 +- fs/f2fs/gc.c | 28 ++++++++++++++-------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +++- 5 files changed, 22 insertions(+), 19 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1417,7 +1418,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/gc.c +14
-14@@ -1402,8 +1402,9 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start,unsigned int end) { -int type;unsigned int segno, next_inuse; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int type;int err =0 ;/* Move out cursegs from the target range */ @@ -1417,16 +1418,14 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);if (get_valid_blocks (sbi, segno, true))return -EAGAIN ; } - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err)return err;@@ -1502,6 +1501,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs;int gc_mode, gc_type;int err =0 ;@@ -1538,7 +1538,9 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi));@@ -1551,11 +1553,12 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock);if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; } -mutex_lock (&sbi->resize_mutex);set_sbi_flag (sbi,SBI_IS_RESIZEFS );mutex_lock (&DIRTY_I (sbi)->seglist_lock);@@ -1587,17 +1590,13 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) goto out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); }@@ -1612,7 +1611,8 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)spin_unlock (&sbi->stat_lock); }clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb); +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \Signature · 1 line
2.26.0.rc2.310.g2932bb562d-goog
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Jaegeuk Kim
maintainerQuoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
From b9126ba7437602d7945c420eb2eb411f9cb95600 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactor resize_fs to avoid meta updates in progress
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 ++- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 105 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 66 insertions(+), 57 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +57 -48
184 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 1 line
2.26.0.292.g33ef6b2f38-goog
Jaegeuk Kim
maintainerQuoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v2:
From 6bf7d5b227d466b0fe90d4957af29bd184fb646e Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactor resize_fs to avoid meta updates in progress
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 107 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 58 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +58 -49
187 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 1 line
2.26.0.292.g33ef6b2f38-goog
Quoted 201 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v2:
Quoted 1 line
From
6bf7d5b227d466b0fe90d4957af29bd184fb646eMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 107 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 58 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +33
-11@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1455,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1502,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1524,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1560,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ;
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1568
Quoted 10 lines
fs/f2fs/gc.c +4
-2} -freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true);
For this path, we break the rule that we need hold gc_lock during do_garbage_collect().
One other concern is that still the granularity of lock_op is too large, to avoid potential hang if it triggers heavy gc migration, how about using a timeout mechanism in free_segment_range() like we did in f2fs_disable_checkpoint()?
Quoted 36 lines
fs/f2fs/gc.c +10
-19+f2fs_unlock_op (sbi); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1584,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) - if (sbi->next_victim_seg[gc_type] >=
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1590
Quoted 10 lines
fs/f2fs/gc.c +3
-6- MAIN_SECS(sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err; - err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);
Lock coverage is still large here, what about just checking the resize condition with find_next_inuse(, end + 1, start), if the migration finished, then let's call write_checkpoint(), otherwise, returning -EAGAIN.
Quoted 83 lines
fs/f2fs/gc.c +8
-11if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Jaegeuk Kim
maintainerQuoted 204 lines · Chao Yu
Quoted 203 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v2:
Quoted 1 line
From
6bf7d5b227d466b0fe90d4957af29bd184fb646eMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 107 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 58 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +33
-11@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1455,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1502,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1524,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1560,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; }
Quoted 11 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1568
Quoted 8 lines
fs/f2fs/gc.c +4
-2-freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true);For this path, we break the rule that we need hold
gc_lockduringdo_garbage_collect().
I don't get the point.
In free_segment_range(), gc_lock is held before/after do_garbage_collect().
Quoted 5 lines
One other concern is that still the granularity of
lock_opis too large, to avoid potential hang if it triggers heavy gc migration, how about using a timeout mechanism infree_segment_range()like we did inf2fs_disable_checkpoint()?
We can do first round GC without f2fs_lock_op().
Quoted 44 lines
Quoted 44 lines
fs/f2fs/gc.c +12
-23+f2fs_unlock_op (sbi); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1584,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err;
Quoted 7 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1590
Quoted 3 lines
fs/f2fs/gc.c +1
-2- err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);Lock coverage is still large here, what about just checking the resize condition with
find_next_inuse(, end + 1, start), if the migration finished, then let's callwrite_checkpoint(), otherwise, returning-EAGAIN.
We did GC above, so how much time do you expect to complete here? Basically I hesitate to return EAGAIN, since there's no context with respect to how many times user need to retry to get succeess. Disabling checkpoint has some ways to get a sense tho. Nevertheless, if we want to return EAGAIN, it'd be better to give # of bytes that it requires to migrate further?
Quoted 84 lines
Quoted 84 lines
fs/f2fs/gc.c +8
-11if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Quoted 217 lines · Jaegeuk Kim
Quoted 204 lines · Chao Yu
Quoted 203 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v2:
Quoted 1 line
From
6bf7d5b227d466b0fe90d4957af29bd184fb646eMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 107 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 58 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +33
-11@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1455,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1502,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1524,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1560,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; }Quoted 11 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1568
Quoted 8 lines
fs/f2fs/gc.c +4
-2-freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true);For this path, we break the rule that we need hold
gc_lockduringdo_garbage_collect().
Quoted 2 lines
I don't get the point.
Infree_segment_range(),gc_lockis held before/afterdo_garbage_collect().
@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,
.iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS),
};
- down_write(&sbi->gc_lock);
do_garbage_collect(sbi, segno, &gc_list, FG_GC);
- up_write(&sbi->gc_lock);
put_gc_inode(&gc_list);
They were removed, right?
Quoted 8 lines
Quoted 6 lines
One other concern is that still the granularity of
lock_opis too large, to avoid potential hang if it triggers heavy gc migration, how about using a timeout mechanism infree_segment_range()like we did inf2fs_disable_checkpoint()?We can do first round GC without
f2fs_lock_op().
Yup, that makes sense to me.
Quoted 53 lines
Quoted 45 lines
Quoted 45 lines
fs/f2fs/gc.c +12
-23+f2fs_unlock_op (sbi); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1584,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err;Quoted 7 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1590
Quoted 3 lines
fs/f2fs/gc.c +1
-2- err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);Lock coverage is still large here, what about just checking the resize condition with
find_next_inuse(, end + 1, start), if the migration finished, then let's callwrite_checkpoint(), otherwise, returning-EAGAIN.
Quoted 1 line
We did GC above, so how much time do you expect to complete here? Basically
Just to consider handling corner case here, which is in between round 1 and round 2 GC, there may occur a fair mount of data writes locating in the tail of device.
Quoted 2 lines
I hesitate to return EAGAIN, since there's no context with respect to how many times user need to retry to get succeess. Disabling checkpoint has
I think user can accept EAGAIN if we describe clearly about that the interface may fail due to concurrent IO on device, if the administrator want to resize successfully, concurrent operation on device should be avoided.
Quoted 2 lines
some ways to get a sense tho. Nevertheless, if we want to return EAGAIN, it'd be better to give # of bytes that it requires to migrate further?
Hmm.. I don't think there is such number, as resize should be atomic.
Thanks,
Quoted 87 lines
Quoted 82 lines
Quoted 82 lines
fs/f2fs/gc.c +8
-11if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" })Quoted 3 lines
include/trace/events/f2fs.h TRACE_DEFINE_ENUM(CP_PAUSE); · line 134
Quoted 3 lines
include/trace/events/f2fs.h +0
-0#define show_fsync_cpreason (type) \ __print_symbolic(type, \.
Jaegeuk Kim
maintainerQuoted 230 lines · Chao Yu
Quoted 219 lines · Jaegeuk Kim
Quoted 204 lines · Chao Yu
Quoted 203 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v2:
Quoted 1 line
From
6bf7d5b227d466b0fe90d4957af29bd184fb646eMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 107 +++++++++++++++++++----------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 58 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1553,7 +1553,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1622,7 +1623,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -193,6 +193,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1421,7 +1422,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3305,7 +3305,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3317,9 +3316,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +33
-11@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1455,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1502,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1524,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1560,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; }Quoted 11 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1568
Quoted 8 lines
fs/f2fs/gc.c +4
-2-freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true);For this path, we break the rule that we need hold
gc_lockduringdo_garbage_collect().I don't get the point.
Infree_segment_range(),gc_lockis held before/afterdo_garbage_collect().fs/f2fs/gc.c +0
-2@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);
Quoted 1 line
They were removed, right?
Ah, I messed up the patches. Yes, it seems I removed it.
Quoted 73 lines
Quoted 9 lines
Quoted 7 lines
One other concern is that still the granularity of
lock_opis too large, to avoid potential hang if it triggers heavy gc migration, how about using a timeout mechanism infree_segment_range()like we did inf2fs_disable_checkpoint()?We can do first round GC without
f2fs_lock_op().Yup, that makes sense to me.
Quoted 53 lines
Quoted 45 lines
Quoted 45 lines
fs/f2fs/gc.c +12
-23+f2fs_unlock_op (sbi); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1584,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err;Quoted 7 lines
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1590
Quoted 3 lines
fs/f2fs/gc.c +1
-2- err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);Lock coverage is still large here, what about just checking the resize condition with
find_next_inuse(, end + 1, start), if the migration finished, then let's callwrite_checkpoint(), otherwise, returning-EAGAIN.Quoted 1 line
We did GC above, so how much time do you expect to complete here? Basically
Just to consider handling corner case here, which is in between round 1 and round 2 GC, there may occur a fair mount of data writes locating in the tail of device.
Quoted 2 lines
I hesitate to return EAGAIN, since there's no context with respect to how many times user need to retry to get succeess. Disabling checkpoint has
Quoted 8 lines
I think user can accept EAGAIN if we describe clearly about that the interface may fail due to concurrent IO on device, if the administrator want to resize successfully, concurrent operation on device should be avoided.
Quoted 2 lines
some ways to get a sense tho. Nevertheless, if we want to return EAGAIN, it'd be better to give # of bytes that it requires to migrate further?
Hmm.. I don't think there is such number, as resize should be atomic.
I thought we can return roughly # of dirty segments?
Quoted 90 lines
Thanks,
Quoted 87 lines
Quoted 82 lines
Quoted 82 lines
fs/f2fs/gc.c +8
-11if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3412,7 +3412,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" })Quoted 3 lines
include/trace/events/f2fs.h TRACE_DEFINE_ENUM(CP_PAUSE); · line 134
Quoted 3 lines
include/trace/events/f2fs.h +0
-0#define show_fsync_cpreason (type) \ __print_symbolic(type, \.
Jaegeuk Kim
maintainerQuoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v3:
- fix gc_lock
From d10c09dfedc7a10cef7dd34493ddbd7c27889033 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactor resize_fs to avoid meta updates in progress
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 ++- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 105 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 56 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1422,7 +1423,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3313,7 +3313,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3325,9 +3324,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +58 -47
182 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3413,7 +3413,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 8 lines
2.26.0.110.g2183baf09c-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 205 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v3:
- fixgc_lockFrom
d10c09dfedc7a10cef7dd34493ddbd7c27889033Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 ++- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 105 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 56 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1422,7 +1423,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3313,7 +3313,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3325,9 +3324,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +35
-11@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1422,13 +1439,17 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1457,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1504,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1526,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1562,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1578
Quoted 10 lines
fs/f2fs/gc.c +10
-0+f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true); +f2fs_unlock_op (sbi); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock);
free_segment_range() tries to acquire the gc_lock before do_garbage_collect(). It can deadlock.
Thanks,
Quoted 123 lines
fs/f2fs/gc.c +13
-36+mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1586,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err; - err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3413,7 +3413,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \Signature · 1 line
2.26.0.110.g2183baf09c-goog
Signature · 9 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum. _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 198 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v3:
- fixgc_lockQuoted 1 line
From
d10c09dfedc7a10cef7dd34493ddbd7c27889033Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 ++- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 105 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 67 insertions(+), 56 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1422,7 +1423,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3313,7 +3313,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3325,9 +3324,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +33
-9@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)@@ -1422,13 +1439,17 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,up_write (&sbi->gc_lock);put_gc_inode (&gc_list); -if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1457,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1504,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1526,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1562,22 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; }
fs/f2fs/gc.c int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count) · line 1571
Quoted 10 lines
fs/f2fs/gc.c +5
-2-freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true); +f2fs_unlock_op (sbi);
There will be ABBA deadlock:
- lock_op()
- free_segment_range()
- f2fs_sync_fs()
- down_write(gc_lock)
- down_write(gc_lock)
- do_garbage_collect()
- f2fs_write_checkpoint()
- block_operations()
- f2fs_lock_all()
Thanks,
Quoted 128 lines
fs/f2fs/gc.c +20
-36+if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1586,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err; - err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3413,7 +3413,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +3
-1@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Jaegeuk Kim
maintainerQuoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v4:
- fix deadlock
From fcbf75b308a8b933706c7e4dd18f275129baa928 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactor resize_fs to avoid meta updates in progress
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 112 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 72 insertions(+), 58 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1423,7 +1424,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3306,7 +3306,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3318,9 +3317,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +63 -49
192 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3420,7 +3420,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 8 lines
2.26.0.110.g2183baf09c-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 149 lines · Jaegeuk Kim
Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v4:
- fix deadlockQuoted 1 line
From
fcbf75b308a8b933706c7e4dd18f275129baa928Mon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 31 Mar 2020 11:43:07 -0700
Subject: [PATCH] f2fs: refactorresize_fsto avoid meta updates in progressSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 112 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 72 insertions(+), 58 deletions(-)fs/f2fs/checkpoint.c +4
-2@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }fs/f2fs/f2fs.h +1
-1@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */ @@ -1423,7 +1424,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */ fs/f2fs/file.c +1
-4@@ -3306,7 +3306,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -3318,9 +3317,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)fs/f2fs/gc.c +21
-4@@ -1399,12 +1399,29 @@ void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)GET_SEGNO (sbi,FDEV (0 ).end_blk) +1 ; } -static int free_segment_range (struct f2fs_sb_info *sbi,unsigned int start, -unsigned int end) +static int free_segment_range (struct f2fs_sb_info *sbi, +unsigned int secs,bool gc_only) { -int type; -unsigned int segno, next_inuse; +unsigned int segno, next_inuse, start, end; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 }; +int gc_mode, gc_type;int err =0 ; +int type; + +/* Force block allocation for GC */ +MAIN_SECS (sbi) -= secs; + start =MAIN_SECS (sbi) * sbi->segs_per_sec; + end =MAIN_SEGS (sbi) -1 ; + +mutex_lock (&DIRTY_I (sbi)->seglist_lock); +for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) +if (SIT_I (sbi)->last_victim[gc_mode] >= start) +SIT_I (sbi)->last_victim[gc_mode] =0 ; + +for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) +if (sbi->next_victim_seg[gc_type] >= start) + sbi->next_victim_seg[gc_type] =NULL_SEGNO ; +mutex_unlock (&DIRTY_I (sbi)->seglist_lock);/* Move out cursegs from the target range */ for (type =CURSEG_HOT_DATA ; type <NR_CURSEG_TYPE ; type++)
fs/f2fs/gc.c static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, · line 1438
Quoted 7 lines
fs/f2fs/gc.c +0
-2@@ -1417,18 +1434,20 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), }; -down_write (&sbi->gc_lock);do_garbage_collect (sbi, segno, &gc_list,FG_GC ); -up_write (&sbi->gc_lock);put_gc_inode (&gc_list);
Granularity is still large, how about handling userspace signal here to provide a termination way in case of user don't want / can't wait for more time.
if (fatal_signal_pending(current)) return -ERESTARTSYS;
Thanks,
Quoted 183 lines
fs/f2fs/gc.c +42
-43-if (get_valid_blocks (sbi, segno, true)) -return -EAGAIN ; +if (!gc_only &&get_valid_blocks (sbi, segno, true)) { + err = -EAGAIN ; + goto out; + } } +if (gc_only) + goto out; - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) -return err; + goto out; next_inuse =find_next_inuse (FREE_I (sbi), end +1 , start);if (next_inuse <= end) {@@ -1436,6 +1455,8 @@ static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start, next_inuse);f2fs_bug_on (sbi,1 ); } +out: +MAIN_SECS (sbi) -= secs;return err; }@@ -1481,6 +1502,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)SM_I (sbi)->segment_count = (int )SM_I (sbi)->segment_count + segs;MAIN_SEGS (sbi) = (int )MAIN_SEGS (sbi) + segs; +MAIN_SECS (sbi) += secs;FREE_I (sbi)->free_sections = (int )FREE_I (sbi)->free_sections + secs;FREE_I (sbi)->free_segments = (int )FREE_I (sbi)->free_segments + segs;F2FS_CKPT (sbi)->user_block_count =cpu_to_le64 (user_block_count + blks);@@ -1502,8 +1524,8 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)int f2fs_resize_fs (struct f2fs_sb_info *sbi,__u64 block_count) {__u64 old_block_count, shrunk_blocks; +struct cp_control cpc = {CP_RESIZE ,0 ,0 ,0 };unsigned int secs; -int gc_mode, gc_type;int err =0 ;__u32 rem;@@ -1538,10 +1560,27 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)return -EINVAL ; } -freeze_bdev (sbi->sb->s_bdev); - shrunk_blocks = old_block_count - block_count; secs =div_u64 (shrunk_blocks,BLKS_PER_SEC (sbi)); + +/* stop other GC */ +if (!down_write_trylock (&sbi->gc_lock)) +return -EAGAIN ; + +/* stop CP to protect MAIN_SEC in free_segment_range */ +f2fs_lock_op (sbi); + err =free_segment_range (sbi, secs, true); +f2fs_unlock_op (sbi); +up_write (&sbi->gc_lock); +if (err) +return err; + +set_sbi_flag (sbi,SBI_IS_RESIZEFS ); + +freeze_super (sbi->sb); +down_write (&sbi->gc_lock); +mutex_lock (&sbi->cp_mutex); +spin_lock (&sbi->stat_lock); if (shrunk_blocks + valid_user_blocks(sbi) + sbi->current_reserved_blocks + sbi->unusable_block_count +@@ -1550,69 +1589,44 @@ int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)else sbi->user_block_count -= shrunk_blocks;spin_unlock (&sbi->stat_lock); -if (err) { -thaw_bdev (sbi->sb->s_bdev, sbi->sb); -return err; - } - -mutex_lock (&sbi->resize_mutex); -set_sbi_flag (sbi,SBI_IS_RESIZEFS ); - -mutex_lock (&DIRTY_I (sbi)->seglist_lock); - -MAIN_SECS (sbi) -= secs; - -for (gc_mode =0 ; gc_mode <MAX_GC_POLICY ; gc_mode++) -if (SIT_I (sbi)->last_victim[gc_mode] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) -SIT_I (sbi)->last_victim[gc_mode] =0 ; - -for (gc_type =BG_GC ; gc_type <=FG_GC ; gc_type++) -if (sbi->next_victim_seg[gc_type] >= -MAIN_SECS (sbi) * sbi->segs_per_sec) - sbi->next_victim_seg[gc_type] =NULL_SEGNO ; - -mutex_unlock (&DIRTY_I (sbi)->seglist_lock); +if (err) + goto out_err; - err =free_segment_range (sbi,MAIN_SECS (sbi) * sbi->segs_per_sec, -MAIN_SEGS (sbi) -1 ); + err =free_segment_range (sbi, secs, false);if (err) - goto out; + goto recover_out;update_sb_metadata (sbi, -secs); err =f2fs_commit_super (sbi, false);if (err) {update_sb_metadata (sbi, secs); - goto out; + goto recover_out; } -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, -secs);clear_sbi_flag (sbi,SBI_IS_RESIZEFS );set_sbi_flag (sbi,SBI_IS_DIRTY ); -mutex_unlock (&sbi->cp_mutex); - err =f2fs_sync_fs (sbi->sb,1 ); + err =f2fs_write_checkpoint (sbi, &cpc);if (err) { -mutex_lock (&sbi->cp_mutex);update_fs_metadata (sbi, secs); -mutex_unlock (&sbi->cp_mutex);update_sb_metadata (sbi, secs);f2fs_commit_super (sbi, false); } -out: +recover_out:if (err) {set_sbi_flag (sbi,SBI_NEED_FSCK );f2fs_err (sbi,"resize_fs failed, should run fsck to repair!" ); -MAIN_SECS (sbi) += secs;spin_lock (&sbi->stat_lock); sbi->user_block_count += shrunk_blocks;spin_unlock (&sbi->stat_lock); } +out_err: +mutex_unlock (&sbi->cp_mutex); +up_write (&sbi->gc_lock); +thaw_super (sbi->sb);clear_sbi_flag (sbi,SBI_IS_RESIZEFS ); -mutex_unlock (&sbi->resize_mutex); -thaw_bdev (sbi->sb->s_bdev, sbi->sb);return err; }fs/f2fs/super.c +0
-1@@ -3420,7 +3420,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);include/trace/events/f2fs.h +1
-0@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
include/trace/events/f2fs.h TRACE_DEFINE_ENUM(CP_PAUSE); · line 134
Quoted 9 lines
include/trace/events/f2fs.h +2
-1@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerQuoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v5:
- add signal handler
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 114 ++++++++++++++++++++---------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 74 insertions(+), 58 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1554,7 +1554,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1623,7 +1624,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1423,7 +1424,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3306,7 +3306,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3318,9 +3317,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +65 -49
194 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3420,7 +3420,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 1 line
2.26.1.301.g55bc3eb7cb9-goog
Chao Yu
Reviewed-byQuoted 23 lines · Jaegeuk Kim
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v5:
- add signal handlerSahitya raised an issue:
- prevent meta updates while checkpoint is in progress
Quoted 7 lines
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>
Thanks,
Jaegeuk Kim
maintainerHi Sahitya,
Could you please test this patch fully? I didn't test at all.
Thanks,
Quoted 35 lines · Chao Yu
Quoted 23 lines · Jaegeuk Kim
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v5:
- add signal handlerSahitya raised an issue:
- prevent meta updates while checkpoint is in progressQuoted 7 lines
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>Reviewed-by Chao Yu <[email protected]>Thanks,
Hi Jaegeuk,
Quoted 3 lines · Jaegeuk Kim
Hi Sahitya,
Could you please test this patch fully? I didn't test at all.
I have tested v5 and so far found only one problem where MAIN_SECS(sbi) isn't updated properly. Fixed it as below.
fs/f2fs/gc.c +1 -1
@@ -1450,7 +1450,7 @@ static int free_segment_range(struct f2fs_sb_info *sbi,f2fs_bug_on (sbi,1 ); } out: -MAIN_SECS (sbi) -= secs; +MAIN_SECS (sbi) += secs;return err; }
I will let you know in case anything else shows up later.
Thanks,
Quoted 39 lines
Thanks,
Quoted 35 lines · Chao Yu
Quoted 23 lines · Jaegeuk Kim
Quoted 10 lines · Jaegeuk Kim
Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 5 lines · Sahitya Tummala
Hi Jaegeuk,
Got it.
The diff below looks good to me.
Would you like me to test it and put a patch for this?Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Sahitya, Chao,
Could you please take a look at this patch and test intensively?
Thanks,
v5:
- add signal handlerSahitya raised an issue:
- prevent meta updates while checkpoint is in progressQuoted 7 lines
allocate_segment_for_resize()can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.Signed-off-by Sahitya Tummala <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>Reviewed-by Chao Yu <[email protected]>Thanks,
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Quoted 9 lines · Sahitya Tummala
Hi Jaegeuk,
Quoted 3 lines · Jaegeuk Kim
Hi Sahitya,
Could you please test this patch fully? I didn't test at all.
I have tested v5 and so far found only one problem where
MAIN_SECS(sbi)isn't updated properly. Fixed it as below.
Thanks. I fixed this with one more signal error case together.
Sahitya raised an issue:
- prevent meta updates while checkpoint is in progress
allocate_segment_for_resize() can cause metapage updates if it requires to change the current node/data segments for resizing. Stop these meta updates when there is a checkpoint already in progress to prevent inconsistent CP data.
--- fs/f2fs/checkpoint.c | 6 +- fs/f2fs/f2fs.h | 2 +- fs/f2fs/file.c | 5 +- fs/f2fs/gc.c | 116 +++++++++++++++++++++--------------- fs/f2fs/super.c | 1 - include/trace/events/f2fs.h | 4 +- 6 files changed, 76 insertions(+), 58 deletions(-)
fs/f2fs/checkpoint.c +4 -2
@@ -1559,7 +1559,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)return 0 ;f2fs_warn (sbi,"Start checkpoint disabled!" ); } -mutex_lock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_lock (&sbi->cp_mutex); if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
@@ -1628,7 +1629,8 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)f2fs_update_time (sbi,CP_TIME );trace_f2fs_write_checkpoint (sbi->sb, cpc->reason,"finish checkpoint" ); out: -mutex_unlock (&sbi->cp_mutex); +if (cpc->reason !=CP_RESIZE ) +mutex_unlock (&sbi->cp_mutex);return err; }
fs/f2fs/f2fs.h +1 -1
@@ -194,6 +194,7 @@ enum {#define CP_DISCARD 0x00000010#define CP_TRIMMED 0x00000020#define CP_PAUSE 0x00000040 +#define CP_RESIZE 0x00000080#define MAX_DISCARD_BLOCKS (sbi) BLKS_PER_SEC(sbi)#define DEF_MAX_DISCARD_REQUEST 8/* issue 8 discards per round */
@@ -1435,7 +1436,6 @@ struct f2fs_sb_info {unsigned int segs_per_sec;/* segments per section */ unsigned int secs_per_zone;/* sections per zone */ unsigned int total_sections;/* total section count */ -struct mutex resize_mutex;/* for resize exclusion */ unsigned int total_node_count;/* total node block count */ unsigned int total_valid_node_count;/* valid node block count */ loff_t max_file_blocks;/* max block index of file */
fs/f2fs/file.c +1 -4
@@ -3310,7 +3310,6 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) {struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (filp));__u64 block_count; -int ret;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -3322,9 +3321,7 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) sizeof(block_count)))return -EFAULT ; - ret =f2fs_resize_fs (sbi, block_count); - -return ret; +return f2fs_resize_fs (sbi, block_count); }static int f2fs_ioc_enable_verity (struct file *filp,unsigned long arg)
fs/f2fs/gc.c +67 -49
196 lines not on this page · raw message
fs/f2fs/super.c +0 -1
@@ -3420,7 +3420,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->gc_lock);mutex_init (&sbi->writepages);mutex_init (&sbi->cp_mutex); -mutex_init (&sbi->resize_mutex);init_rwsem (&sbi->node_write);init_rwsem (&sbi->node_change);
include/trace/events/f2fs.h +3 -1
@@ -50,6 +50,7 @@ TRACE_DEFINE_ENUM(CP_RECOVERY);TRACE_DEFINE_ENUM (CP_DISCARD );TRACE_DEFINE_ENUM (CP_TRIMMED );TRACE_DEFINE_ENUM (CP_PAUSE ); +TRACE_DEFINE_ENUM (CP_RESIZE );#define show_block_type (type) \ __print_symbolic(type, \
@@ -126,7 +127,8 @@ TRACE_DEFINE_ENUM(CP_PAUSE); { CP_RECOVERY, "Recovery" }, \ { CP_DISCARD, "Discard" }, \ { CP_PAUSE, "Pause" }, \ - { CP_TRIMMED, "Trimmed" }) + { CP_TRIMMED, "Trimmed" }, \ + { CP_RESIZE, "Resize" }) #define show_fsync_cpreason(type) \ __print_symbolic(type, \
Signature · 1 line
2.26.1.301.g55bc3eb7cb9-goog