f2fs: add a way to limit roll forward recovery time
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: add a way to limit roll forward recovery time
This adds a sysfs entry to call checkpoint during fsync() in order to avoid long elapsed time to run roll-forward recovery when booting the device.
--- Documentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 3 +++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 20 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +6 -0
@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.
fs/f2fs/checkpoint.c +1 -0
@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );
fs/f2fs/f2fs.h +3 -0
@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */
@@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */
fs/f2fs/node.c +2 -0
@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))
@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);
fs/f2fs/node.h +3 -0
@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 100 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32
fs/f2fs/recovery.c +3 -0
@@ -53,9 +53,12 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }
fs/f2fs/sysfs.c +2 -0
@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);
@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Signature · 1 line
2.35.0.rc0.227.g00780c9af4-goog
Chao Yu
maintainerQuoted 86 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device.Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 3 +++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 20 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +2
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +0
-0
fs/f2fs/node.h line 35
Quoted 5 lines
fs/f2fs/node.h +2
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 100
Will we suffer performance regression issue in some scenarios in where user triggers fsync/fdatasync frequently? e.g. performance test.
If this issue is a corner case, it's better to increase DEF_RF_NODE_BLOCKS to avoid affecting common case AMSP?
Thanks,
Quoted 41 lines
fs/f2fs/node.h +1
-0+/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +3
-0@@ -53,9 +53,12 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Jaegeuk Kim
maintainerQuoted 91 lines · Chao Yu
Quoted 82 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device.Signed-off-by Jaegeuk Kim <[email protected]>--- Documentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 3 +++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 20 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +2
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +0
-0fs/f2fs/node.h line 34
Quoted 4 lines
fs/f2fs/node.h +2
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 100Will we suffer performance regression issue in some scenarios in where user triggers fsync/fdatasync frequently? e.g. performance test.
Quoted 2 lines
If this issue is a corner case, it's better to increase
DEF_RF_NODE_BLOCKSto avoid affecting common case AMSP?
I got one report only. So, let me try to keep as is by default. (ref. v2)
Quoted 42 lines
Thanks,
Quoted 39 lines
fs/f2fs/node.h +1
-0+/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +3
-0@@ -53,9 +53,12 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Jaegeuk Kim
maintainerThis adds a sysfs entry to call checkpoint during fsync() in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.
---
v2 from v1:
- make the default w/o enforcement
Documentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 21 insertions(+)
Documentation/ABI/testing/sysfs-fs-f2fs +6 -0
@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.
fs/f2fs/checkpoint.c +1 -0
@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );
fs/f2fs/f2fs.h +3 -0
@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */
@@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */
fs/f2fs/node.c +2 -0
@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))
@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);
fs/f2fs/node.h +3 -0
@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32
fs/f2fs/recovery.c +4 -0
@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }
fs/f2fs/sysfs.c +2 -0
@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);
@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Signature · 1 line
2.35.0.rc2.247.g8bbb082509-goog
Chao Yu
maintainerQuoted 70 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>---
v2 from v1:
- make the default w/o enforcementDocumentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 21 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +0
-0
fs/f2fs/node.c int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, · line 1785
Quoted 4 lines
fs/f2fs/node.c +1
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);
if (NM_I(sbi)->max_rf_node_blocks)
percpu_counter_inc(&sbi->rf_node_block_count);
Thanks,
Quoted 56 lines
fs/f2fs/node.c +1
-0if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +3
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +4
-0@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +1
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);
fs/f2fs/sysfs.c static struct attribute *f2fs_attrs[] = { · line 862
Quoted 7 lines
fs/f2fs/sysfs.c +1
-0@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerQuoted 74 lines · Chao Yu
Quoted 68 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>---
v2 from v1:
- make the default w/o enforcementDocumentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 21 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +0
-0fs/f2fs/node.c int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, · line 1784
Quoted 3 lines
fs/f2fs/node.c +1
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (NM_I(sbi)->max_rf_node_blocks)
Quoted 1 line
percpu_counter_inc(&sbi->rf_node_block_count);
I think we can just count this and adjust right away once sysfs is changed.
Quoted 62 lines
Thanks,
Quoted 59 lines
fs/f2fs/node.c +1
-0if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +3
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +4
-0@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Chao Yu
maintainerQuoted 77 lines · Jaegeuk Kim
Quoted 74 lines · Chao Yu
Quoted 68 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>---
v2 from v1:
- make the default w/o enforcementDocumentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 21 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +0
-0fs/f2fs/node.c int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, · line 1784
Quoted 3 lines
fs/f2fs/node.c +1
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (NM_I(sbi)->max_rf_node_blocks)
Quoted 1 line
percpu_counter_inc(&sbi->rf_node_block_count);
Quoted 1 line
I think we can just count this and adjust right away once sysfs is changed.
Since this long recovery latency issue is a corner case, I guess we can avoid this to save cpu time...
BTW, shouldn't we account all warn dnode blocks? as we will traverse all blocks there in warn node list.
Thanks,
Quoted 63 lines
Quoted 63 lines
Thanks,
Quoted 59 lines
fs/f2fs/node.c +1
-0if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +3
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +4
-0@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Jaegeuk Kim
maintainerQuoted 78 lines · Chao Yu
Quoted 77 lines · Jaegeuk Kim
Quoted 75 lines · Chao Yu
Quoted 68 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>---
v2 from v1:
- make the default w/o enforcementDocumentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/sysfs.c | 2 ++ 7 files changed, 21 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +0
-0fs/f2fs/node.c int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, · line 1784
Quoted 3 lines
fs/f2fs/node.c +1
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (NM_I(sbi)->max_rf_node_blocks)
percpu_counter_inc(&sbi->rf_node_block_count);
Quoted 4 lines
Quoted 1 line
I think we can just count this and adjust right away once sysfs is changed.
Since this long recovery latency issue is a corner case, I guess we can avoid this to save cpu time...
I think we can show this in debugfs, as it won't give huge overhead.
Quoted 3 lines
BTW, shouldn't we account all warn dnode blocks? as we will traverse all blocks there in warn node list.
I thought we don't need to track the whole bunch of chains, but would be enough to record # of fsync calls roughly.
Quoted 66 lines
Thanks,
Quoted 63 lines
Quoted 63 lines
Thanks,
Quoted 59 lines
fs/f2fs/node.c +1
-0if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +3
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +4
-0@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Chao Yu
maintainerQuoted 37 lines · Jaegeuk Kim
Quoted 36 lines · Chao Yu
Quoted 35 lines · Jaegeuk Kim
Quoted 34 lines · Chao Yu
Quoted 33 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>---
v2 from v1:
- make the default w/o enforcement
Documentation/ABI/testing/sysfs-fs-f2fs| 6 ++++++
fs/f2fs/checkpoint.c| 1 +
fs/f2fs/f2fs.h| 3 +++
fs/f2fs/node.c| 2 ++
fs/f2fs/node.h| 3 +++
fs/f2fs/recovery.c| 4 ++++
fs/f2fs/sysfs.c| 2 ++
7 files changed, 21 insertions(+)Documentation/ABI/testing/sysfs-fs-f2fs +6
-0@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.fs/f2fs/checkpoint.c +0
-0
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
fs/f2fs/checkpoint.c static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) · line 1546
Quoted 8 lines
index
deeda95688f0..57a2d9164bee100644fs/f2fs/checkpoint.c +1
-0@@ -1543,6 +1543,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );
Should be initialized before use?
Thanks,
Quoted 114 lines
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 27 lines
fs/f2fs/checkpoint.c +0
-0/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );fs/f2fs/f2fs.h +3
-0@@ -913,6 +913,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */ @@ -1684,6 +1685,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */ fs/f2fs/node.c +0
-0fs/f2fs/node.c int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, · line 1784
Quoted 3 lines
fs/f2fs/node.c +1
-0@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (NM_I(sbi)->max_rf_node_blocks)
percpu_counter_inc(&sbi->rf_node_block_count);Quoted 4 lines
Quoted 1 line
I think we can just count this and adjust right away once sysfs is changed.
Since this long recovery latency issue is a corner case, I guess we can avoid this to save cpu time...
I think we can show this in debugfs, as it won't give huge overhead.
Quoted 3 lines
BTW, shouldn't we account all warn dnode blocks? as we will traverse all blocks there in warn node list.
I thought we don't need to track the whole bunch of chains, but would be enough to record # of fsync calls roughly.
Quoted 66 lines
Thanks,
Quoted 63 lines
Quoted 63 lines
Thanks,
Quoted 59 lines
fs/f2fs/node.c +1
-0if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);fs/f2fs/node.h +3
-0@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32fs/f2fs/recovery.c +4
-0@@ -53,9 +53,13 @@ extern struct kmem_cache *f2fs_cf_name_slab;bool f2fs_space_for_roll_forward (struct f2fs_sb_info *sbi) {s64 nalloc =percpu_counter_sum_positive (&sbi->alloc_valid_block_count); +u32 rf_node =percpu_counter_sum_positive (&sbi->rf_node_block_count);if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && + rf_node >=NM_I (sbi)->max_rf_node_blocks) +return false;return true; }fs/f2fs/sysfs.c +2
-0@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Jaegeuk Kim
maintainerThis adds a sysfs entry to call checkpoint during fsync() in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.
---
v3 from v2:
- add missing percpu init
- percpu_sum only when it's used
v2 from v1:
- make the default w/o enforcement
Documentation/ABI/testing/sysfs-fs-f2fs | 6 ++++++ fs/f2fs/checkpoint.c | 1 + fs/f2fs/debug.c | 3 +++ fs/f2fs/f2fs.h | 3 +++ fs/f2fs/node.c | 2 ++ fs/f2fs/node.h | 3 +++ fs/f2fs/recovery.c | 4 ++++ fs/f2fs/super.c | 14 ++++++++++++-- fs/f2fs/sysfs.c | 2 ++ 9 files changed, 36 insertions(+), 2 deletions(-)
Documentation/ABI/testing/sysfs-fs-f2fs +6 -0
@@ -567,3 +567,9 @@ Contact: "Daeho Jeong" <[email protected]> Description: You can set the trial count limit for GC urgent high mode with this value. If GC thread gets to the limit, the mode will turn back to GC normal mode. By default, the value is zero, which means there is no limit like before. + +What: /sys/fs/f2fs/<disk>/max_roll_forward_node_blocks +Date: January 2022 +Contact: "Jaegeuk Kim" <[email protected]> +Description: Controls max # of node block writes to be used for roll forward + recovery. This can limit the roll forward recovery time.
fs/f2fs/checkpoint.c +1 -0
@@ -1547,6 +1547,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)/* update user_block_counts */ sbi->last_valid_block_count = sbi->total_valid_block_count;percpu_counter_set (&sbi->alloc_valid_block_count,0 ); +percpu_counter_set (&sbi->rf_node_block_count,0 );/* Here, we have one bio having CP pack except cp pack 2 page */ f2fs_sync_meta_pages (sbi,META ,LONG_MAX ,FS_CP_META_IO );
fs/f2fs/debug.c +3 -0
@@ -532,6 +532,9 @@ static int stat_show(struct seq_file *s, void *v) si->ndirty_meta, si->meta_pages);seq_printf (s," - imeta: %4d\n" , si->ndirty_imeta); +seq_printf (s," - fsync mark: %4lld\n" , +percpu_counter_sum_positive ( + &si->sbi->rf_node_block_count));seq_printf (s," - NATs: %9d/%9d\n - SITs: %9d/%9d\n" , si->dirty_nats, si->nats, si->dirty_sits, si->sits); seq_printf(s, " - free_nids: %9d/%9d\n - alloc_nids: %9d\n",
fs/f2fs/f2fs.h +3 -0
@@ -916,6 +916,7 @@ struct f2fs_nm_info {nid_t max_nid;/* maximum possible node ids */ nid_t available_nids;/* # of available node ids */ nid_t next_scan_nid;/* the next nid to be scanned */ +nid_t max_rf_node_blocks;/* max # of nodes for recovery */ unsigned int ram_thresh;/* control the memory footprint */ unsigned int ra_nid_pages;/* # of nid pages to be readaheaded */ unsigned int dirty_nats_ratio;/* control dirty nats ratio threshold */
@@ -1687,6 +1688,8 @@ struct f2fs_sb_info {atomic_t nr_pages[NR_COUNT_TYPE ];/* # of allocated blocks */ struct percpu_counter alloc_valid_block_count; +/* # of node block writes as roll forward recovery */ +struct percpu_counter rf_node_block_count;/* writeback control */ atomic_t wb_sync_req[META ];/* count # of WB_SYNC threads */
fs/f2fs/node.c +2 -0
@@ -1782,6 +1782,7 @@ int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,if (!atomic || page == last_page) {set_fsync_mark (page,1 ); +percpu_counter_inc (&sbi->rf_node_block_count);if (IS_INODE (page)) {if (is_inode_flag_set (inode,FI_DIRTY_INODE ))
@@ -3218,6 +3219,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) nm_i->ram_thresh =DEF_RAM_THRESHOLD ; nm_i->ra_nid_pages =DEF_RA_NID_PAGES ; nm_i->dirty_nats_ratio =DEF_DIRTY_NAT_RATIO_THRESHOLD ; + nm_i->max_rf_node_blocks =DEF_RF_NODE_BLOCKS ;INIT_RADIX_TREE (&nm_i->free_nid_root,GFP_ATOMIC );INIT_LIST_HEAD (&nm_i->free_nid_list);
fs/f2fs/node.h +3 -0
@@ -31,6 +31,9 @@/* control total # of nats */ #define DEF_NAT_CACHE_THRESHOLD 100000 +/* control total # of node writes used for roll-fowrad recovery */ +#define DEF_RF_NODE_BLOCKS 0 +/* vector size for gang look-up from nat cache that consists of radix tree */ #define NATVEC_SIZE 64#define SETVEC_SIZE 32
fs/f2fs/recovery.c +4 -0
@@ -56,6 +56,10 @@ bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi)if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)return false; +if (NM_I (sbi)->max_rf_node_blocks && +percpu_counter_sum_positive (&sbi->rf_node_block_count) >= +NM_I (sbi)->max_rf_node_blocks) +return false;return true; }
fs/f2fs/super.c +12 -2
@@ -1501,8 +1501,9 @@ static void f2fs_free_inode(struct inode *inode)static void destroy_percpu_info (struct f2fs_sb_info *sbi) { -percpu_counter_destroy (&sbi->alloc_valid_block_count);percpu_counter_destroy (&sbi->total_valid_inode_count); +percpu_counter_destroy (&sbi->rf_node_block_count); +percpu_counter_destroy (&sbi->alloc_valid_block_count); }static void destroy_device_list (struct f2fs_sb_info *sbi)
@@ -3619,11 +3620,20 @@ static int init_percpu_info(struct f2fs_sb_info *sbi)if (err)return err; + err =percpu_counter_init (&sbi->rf_node_block_count,0 ,GFP_KERNEL ); +if (err) + goto err_valid_block; + err =percpu_counter_init (&sbi->total_valid_inode_count,0 ,GFP_KERNEL );if (err) -percpu_counter_destroy (&sbi->alloc_valid_block_count); + goto err_node_block; +return 0 ; +err_node_block: +percpu_counter_destroy (&sbi->rf_node_block_count); +err_valid_block: +percpu_counter_destroy (&sbi->alloc_valid_block_count);return err; }
fs/f2fs/sysfs.c +2 -0
@@ -732,6 +732,7 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ssr_sections, min_ssr_sections);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ram_thresh, ram_thresh);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, ra_nid_pages, ra_nid_pages);F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); +F2FS_RW_ATTR (NM_INFO , f2fs_nm_info, max_roll_forward_node_blocks, max_rf_node_blocks);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, max_victim_search, max_victim_search);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, migration_granularity, migration_granularity);F2FS_RW_ATTR (F2FS_SBI , f2fs_sb_info, dir_level, dir_level);
@@ -855,6 +856,7 @@ static struct attribute *f2fs_attrs[] = {ATTR_LIST (ram_thresh),ATTR_LIST (ra_nid_pages),ATTR_LIST (dirty_nats_ratio), +ATTR_LIST (max_roll_forward_node_blocks),ATTR_LIST (cp_interval),ATTR_LIST (idle_interval), ATTR_LIST(discard_idle_interval),
Signature · 8 lines
2.35.0.263.gb82422642f-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 5 lines · Jaegeuk Kim
This adds a sysfs entry to call checkpoint during
fsync()in order to avoid long elapsed time to run roll-forward recovery when booting the device. Default value doesn't enforce the limitation which is same as before.Signed-off-by Jaegeuk Kim <[email protected]>
Thanks,
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel