f2fs: avoid race condition for shinker count
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: avoid race condition for shinker count
Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting in wrong do_shinker work. Basically the two counts should not happen like that.
So, I suspect this race condtion where:
- f2fs_try_to_free_nats __flush_nat_entry_set
nat_cnt=2, dirty_nat_cnt=2
__clear_nat_cache_dirty
spin_lock(nat_list_lock)
list_move()
spin_unlock(nat_list_lock)
spin_lock(nat_list_lock)
list_del()
spin_unlock(nat_list_lock)
nat_cnt=1, dirty_nat_cnt=2
nat_cnt=1, dirty_nat_cnt=1--- fs/f2fs/node.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/f2fs/node.c +1 -2
@@ -269,11 +269,10 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i, {spin_lock (&nm_i->nat_list_lock);list_move_tail (&ne->list, &nm_i->nat_entries); -spin_unlock (&nm_i->nat_list_lock); -set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; nm_i->dirty_nat_cnt--; +spin_unlock (&nm_i->nat_list_lock); } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,
Signature · 1 line
2.29.2.222.g5d2a92d10f8-goog
Quoted 1 line · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in
I didn't get the problem clearly, did you mean __count_nat_entries() will give the wrong shrink count due to race condition? should there be a lock while reading these two variables?
Quoted 5 lines
wrong
do_shinkerwork. Basically the two counts should not happen like that.So, I suspect this race condtion where:
-f2fs_try_to_free_nats__flush_nat_entry_set
nat_cnt=2, dirty_nat_cnt=2
Quoted 9 lines
__clear_nat_cache_dirty
spin_lock(nat_list_lock)
list_move()
spin_unlock(nat_list_lock)
spin_lock(nat_list_lock)
list_del()
spin_unlock(nat_list_lock)
nat_cnt=1, dirty_nat_cnt=2
nat_cnt=1, dirty_nat_cnt=1nm_i->nat_cnt and nm_i->dirty_nat_cnt were protected by nm_i->nat_tree_lock, I didn't see why expanding nat_list_lock range will help... since there are still places nat_list_lock() didn't cover these two reference counts.
Thanks,
Quoted 25 lines
Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/node.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)fs/f2fs/node.c +1
-2@@ -269,11 +269,10 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i, {spin_lock (&nm_i->nat_list_lock);list_move_tail (&ne->list, &nm_i->nat_entries); -spin_unlock (&nm_i->nat_list_lock); -set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; nm_i->dirty_nat_cnt--; +spin_unlock (&nm_i->nat_list_lock); } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,
Jaegeuk Kim
maintainerQuoted 22 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting inI didn't get the problem clearly, did you mean
__count_nat_entries()will give the wrong shrink count due to race condition? should there be a lock while reading these two variables?Quoted 5 lines
wrong
do_shinkerwork. Basically the two counts should not happen like that.So, I suspect this race condtion where:
-f2fs_try_to_free_nats__flush_nat_entry_set
nat_cnt=2, dirty_nat_cnt=2Quoted 9 lines
__clear_nat_cache_dirty spin_lock(nat_list_lock) list_move() spin_unlock(nat_list_lock) spin_lock(nat_list_lock) list_del() spin_unlock(nat_list_lock) nat_cnt=1, dirty_nat_cnt=2 nat_cnt=1, dirty_nat_cnt=1
Quoted 4 lines
nm_i->nat_cntandnm_i->dirty_nat_cntwere protected bynm_i->nat_tree_lock, I didn't see why expandingnat_list_lockrange will help... since there are still placesnat_list_lock()didn't cover these two reference counts.
Yeah, I missed nat_tree_lock, and indeed it should cover this. So, the problem is Light reported subtle case of nat_cnt < dirty_nat_cnt in shrink_count. We may need to use nat_tree_lock in shrink_count?
Quoted 27 lines
Thanks,
Quoted 24 lines
Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/node.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)fs/f2fs/node.c +1
-2@@ -269,11 +269,10 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i, {spin_lock (&nm_i->nat_list_lock);list_move_tail (&ne->list, &nm_i->nat_entries); -spin_unlock (&nm_i->nat_list_lock); -set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; nm_i->dirty_nat_cnt--; +spin_unlock (&nm_i->nat_list_lock); } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,
Quoted 23 lines · Jaegeuk Kim
Quoted 22 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting inI didn't get the problem clearly, did you mean
__count_nat_entries()will give the wrong shrink count due to race condition? should there be a lock while reading these two variables?Quoted 14 lines
wrong
do_shinkerwork. Basically the two counts should not happen like that.So, I suspect this race condtion where:
-f2fs_try_to_free_nats__flush_nat_entry_set
nat_cnt=2, dirty_nat_cnt=2__clear_nat_cache_dirty spin_lock(nat_list_lock) list_move() spin_unlock(nat_list_lock) spin_lock(nat_list_lock) list_del() spin_unlock(nat_list_lock) nat_cnt=1, dirty_nat_cnt=2 nat_cnt=1, dirty_nat_cnt=1
Quoted 8 lines
Quoted 4 lines
nm_i->nat_cntandnm_i->dirty_nat_cntwere protected bynm_i->nat_tree_lock, I didn't see why expandingnat_list_lockrange will help... since there are still placesnat_list_lock()didn't cover these two reference counts.Yeah, I missed
nat_tree_lock, and indeed it should cover this. So, the problem is Light reported subtle case ofnat_cnt<dirty_nat_cntinshrink_count. We may need to usenat_tree_lockinshrink_count?
change like this?
__count_nat_entries()
down_read(&nm_i->nat_tree_lock); count = NM_I(sbi)->nat_cnt - NM_I(sbi)->dirty_nat_cnt; up_read(&nm_i->nat_tree_lock);
Thanks,
Quoted 30 lines
Quoted 20 lines
Thanks,
Quoted 16 lines
Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/node.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)fs/f2fs/node.c +0
-1@@ -269,11 +269,10 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i, {spin_lock (&nm_i->nat_list_lock);list_move_tail (&ne->list, &nm_i->nat_entries); -spin_unlock (&nm_i->nat_list_lock);Quoted 8 lines
fs/f2fs/node.c static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i,
Quoted 8 lines
fs/f2fs/node.c +1
-1-set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; nm_i->dirty_nat_cnt--; +spin_unlock (&nm_i->nat_list_lock); } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,.
Jaegeuk Kim
maintainerQuoted 29 lines · Chao Yu
Quoted 28 lines · Jaegeuk Kim
Quoted 26 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting inI didn't get the problem clearly, did you mean
__count_nat_entries()will give the wrong shrink count due to race condition? should there be a lock while reading these two variables?Quoted 5 lines
wrong
do_shinkerwork. Basically the two counts should not happen like that.So, I suspect this race condtion where:
-f2fs_try_to_free_nats__flush_nat_entry_set
nat_cnt=2, dirty_nat_cnt=2Quoted 9 lines
__clear_nat_cache_dirty spin_lock(nat_list_lock) list_move() spin_unlock(nat_list_lock) spin_lock(nat_list_lock) list_del() spin_unlock(nat_list_lock) nat_cnt=1, dirty_nat_cnt=2 nat_cnt=1, dirty_nat_cnt=1
nm_i->nat_cntandnm_i->dirty_nat_cntwere protected bynm_i->nat_tree_lock, I didn't see why expandingnat_list_lockrange will help... since there are still placesnat_list_lock()didn't cover these two reference counts.
Quoted 6 lines
Quoted 3 lines
Yeah, I missed
nat_tree_lock, and indeed it should cover this. So, the problem is Light reported subtle case ofnat_cnt<dirty_nat_cntinshrink_count. We may need to usenat_tree_lockinshrink_count?change like this?
Yup.
Quoted 38 lines
__count_nat_entries()down_read(&nm_i->nat_tree_lock); count = NM_I(sbi)->nat_cnt - NM_I(sbi)->dirty_nat_cnt; up_read(&nm_i->nat_tree_lock);Thanks,
Quoted 30 lines
Quoted 20 lines
Thanks,
Quoted 16 lines
Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/node.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)fs/f2fs/node.c +0
-1@@ -269,11 +269,10 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i, {spin_lock (&nm_i->nat_list_lock);list_move_tail (&ne->list, &nm_i->nat_entries); -spin_unlock (&nm_i->nat_list_lock);Quoted 8 lines
fs/f2fs/node.c static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i,
Quoted 8 lines
fs/f2fs/node.c +1
-1-set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; nm_i->dirty_nat_cnt--; +spin_unlock (&nm_i->nat_list_lock); } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,.
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerLight reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting in wrong do_shinker work. Let's avoid to get stale data by using nat_tree_lock.
--- fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
fs/f2fs/shrinker.c +5 -1
@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&nm_i->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&nm_i->nat_tree_lock);return count >0 ? count :0 ; }
Signature · 8 lines
2.29.2.299.gdc1121823c-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerLight reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting in wrong do_shinker work. Let's avoid to get stale data by using nat_tree_lock.
---
v3:
- fix to use NM_I(sbi)
fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
fs/f2fs/shrinker.c +5 -1
@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);return count >0 ? count :0 ; }
Signature · 8 lines
2.29.2.299.gdc1121823c-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Chao Yu
Reviewed-byQuoted 18 lines · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to get stale data by usingnat_tree_lock.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- fix to useNM_I(sbi)fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)fs/f2fs/shrinker.c +0
-0@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;
fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 27
Quoted 10 lines
fs/f2fs/shrinker.c +5
-1static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);return count >0 ? count :0 ;
Minor thing,
Just return count is enough? since count should never be smaller than 0.
Anyway,
Thanks,
Thanks,
Quoted 2 lines
fs/f2fs/shrinker.c +0
-0}
Jaegeuk Kim
maintainerQuoted 30 lines · Chao Yu
Quoted 17 lines · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to get stale data by usingnat_tree_lock.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- fix to useNM_I(sbi)fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)fs/f2fs/shrinker.c +0
-0fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 25
Quoted 9 lines
fs/f2fs/shrinker.c +5
-1@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);return count >0 ? count :0 ;Minor thing,
Quoted 1 line
Just return count is enough? since count should never be smaller than 0.
Yeah, but let me keep this just in case.
Quoted 11 lines
Anyway,
Reviewed-by Chao Yu <[email protected]>Thanks,
Thanks,
Quoted 2 lines
fs/f2fs/shrinker.c +0
-0}
Jaegeuk Kim
maintainerQuoted 17 lines · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to get stale data by usingnat_tree_lock.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- fix to useNM_I(sbi)fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)fs/f2fs/shrinker.c +0
-0
fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 25
Quoted 9 lines
fs/f2fs/shrinker.c +5
-1@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);
I just fosund this can give kernel hang due to the following backtrace. f2fs_shrink_countshrink_slabshrink_nodedo_try_to_free_pagestry_to_free_pages__alloc_pages_nodemaskalloc_pages_currentallocate_slab__slab_alloc__slab_allockmem_cache_allocadd_free_nidf2fs_flush_nat_entriesf2fs_write_checkpoint
Let me just check like this.
From 971163330224449d90aac90957ea38f77d494f0f Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Fri, 6 Nov 2020 13:22:05 -0800
Subject: [PATCH] f2fs: avoid race condition for shrinker count
Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting in wrong do_shinker work. Let's avoid to return insane overflowed value.
--- fs/f2fs/shrinker.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/f2fs/shrinker.c +3 -3
@@ -18,9 +18,9 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; - -return count >0 ? count :0 ; +if (NM_I (sbi)->nat_cnt >NM_I (sbi)->dirty_nat_cnt) +return NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +return 0 ; }static unsigned long __count_free_nids (struct f2fs_sb_info *sbi)
Signature · 1 line
2.29.2.454.gaff20da3a2-goog
Quoted 12 lines
fs/f2fs/shrinker.c +0
-0return count >0 ? count :0 ; }Signature · 8 lines
2.29.2.299.gdc1121823c-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 35 lines · Jaegeuk Kim
Quoted 17 lines · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to get stale data by usingnat_tree_lock.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- fix to useNM_I(sbi)fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)fs/f2fs/shrinker.c +0
-0fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 25
Quoted 9 lines
fs/f2fs/shrinker.c +5
-1@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);I just fosund this can give kernel hang due to the following backtrace.
f2fs_shrink_countshrink_slabshrink_nodedo_try_to_free_pagestry_to_free_pages__alloc_pages_nodemask
Quoted 8 lines
alloc_pages_currentallocate_slab__slab_alloc__slab_allockmem_cache_allocadd_free_nidf2fs_flush_nat_entriesf2fs_write_checkpoint
Oh, I missed that case.
Quoted 22 lines
Let me just check like this.
Quoted 1 line
From
971163330224449d90aac90957ea38f77d494f0fMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Fri, 6 Nov 2020 13:22:05 -0800
Subject: [PATCH] f2fs: avoid race condition for shrinker countLight reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to return insane overflowed value.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/shrinker.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)fs/f2fs/shrinker.c +0
-0
fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 22
Quoted 8 lines
fs/f2fs/shrinker.c +2
-3@@ -18,9 +18,9 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; - -return count >0 ? count :0 ; +if (NM_I (sbi)->nat_cnt >NM_I (sbi)->dirty_nat_cnt) +return NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt;
Hmm.. in the case that we are not in checkpoint progress, nat_cnt and dirty_nat_cnt is mutable, how can we make sure the calculation is non-negative after the check condition? :(
Thanks
Quoted 5 lines
fs/f2fs/shrinker.c +1
-0+return 0 ; }static unsigned long __count_free_nids (struct f2fs_sb_info *sbi)
Jaegeuk Kim
maintainerQuoted 63 lines · Chao Yu
Quoted 34 lines · Jaegeuk Kim
Quoted 17 lines · Jaegeuk Kim
Light reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to get stale data by usingnat_tree_lock.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- fix to useNM_I(sbi)fs/f2fs/shrinker.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)fs/f2fs/shrinker.c +0
-0fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 24
Quoted 8 lines
fs/f2fs/shrinker.c +5
-1@@ -18,7 +18,11 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +long count; + +down_read (&NM_I (sbi)->nat_tree_lock); + count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; +up_read (&NM_I (sbi)->nat_tree_lock);I just fosund this can give kernel hang due to the following backtrace.
f2fs_shrink_countshrink_slabshrink_nodedo_try_to_free_pagestry_to_free_pages__alloc_pages_nodemaskQuoted 8 lines
alloc_pages_currentallocate_slab__slab_alloc__slab_allockmem_cache_allocadd_free_nidf2fs_flush_nat_entriesf2fs_write_checkpointOh, I missed that case.
Quoted 17 lines
Let me just check like this.
Quoted 1 line
From
971163330224449d90aac90957ea38f77d494f0fMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Fri, 6 Nov 2020 13:22:05 -0800
Subject: [PATCH] f2fs: avoid race condition for shrinker countLight reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to return insane overflowed value.Reported-by Light Hsieh <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/shrinker.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
Quoted 16 lines
fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 21
Quoted 12 lines
fs/f2fs/shrinker.c +2
-3@@ -18,9 +18,9 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; - -return count >0 ? count :0 ; +if (NM_I (sbi)->nat_cnt >NM_I (sbi)->dirty_nat_cnt) +return NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt;Hmm.. in the case that we are not in checkpoint progress,
nat_cntanddirty_nat_cntis mutable, how can we make sure the calculation is non-negative after the check condition? :(
How about adding another variable to monitor it?
From bdc5a805487f0210df7ef4e85ce5a4f0471bca72 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Fri, 6 Nov 2020 13:22:05 -0800
Subject: [PATCH] f2fs: avoid race condition for shrinker count
Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting in wrong do_shinker work. Let's avoid to return insane overflowed value by adding single tracking value.
--- fs/f2fs/checkpoint.c | 2 +- fs/f2fs/debug.c | 11 ++++++----- fs/f2fs/f2fs.h | 10 ++++++++-- fs/f2fs/node.c | 29 ++++++++++++++++++----------- fs/f2fs/node.h | 4 ++-- fs/f2fs/shrinker.c | 4 +--- 6 files changed, 36 insertions(+), 24 deletions(-)
fs/f2fs/checkpoint.c +1 -1
@@ -1619,7 +1619,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) goto out; } -if (NM_I (sbi)->dirty_nat_cnt ==0 && +if (NM_I (sbi)->nat_cnt[DIRTY_NAT ] ==0 &&SIT_I (sbi)->dirty_sentries ==0 &&prefree_segments (sbi) ==0 ) {f2fs_flush_sit_entries (sbi, cpc);
fs/f2fs/debug.c +6 -5
@@ -145,8 +145,8 @@ static void update_general_status(struct f2fs_sb_info *sbi) si->node_pages =NODE_MAPPING (sbi)->nrpages;if (sbi->meta_inode) si->meta_pages =META_MAPPING (sbi)->nrpages; - si->nats =NM_I (sbi)->nat_cnt; - si->dirty_nats =NM_I (sbi)->dirty_nat_cnt; + si->nats =NM_I (sbi)->nat_cnt[TOTAL_NAT ]; + si->dirty_nats =NM_I (sbi)->nat_cnt[DIRTY_NAT ]; si->sits =MAIN_SEGS (sbi); si->dirty_sits =SIT_I (sbi)->dirty_sentries; si->free_nids =NM_I (sbi)->nid_cnt[FREE_NID ];
@@ -278,9 +278,10 @@ static void update_mem_info(struct f2fs_sb_info *sbi) si->cache_mem += (NM_I (sbi)->nid_cnt[FREE_NID ] +NM_I (sbi)->nid_cnt[PREALLOC_NID ]) *sizeof (struct free_nid ); - si->cache_mem +=NM_I (sbi)->nat_cnt *sizeof (struct nat_entry ); - si->cache_mem +=NM_I (sbi)->dirty_nat_cnt * -sizeof (struct nat_entry_set ); + si->cache_mem +=NM_I (sbi)->nat_cnt[TOTAL_NAT ] * +sizeof (struct nat_entry ); + si->cache_mem +=NM_I (sbi)->nat_cnt[DIRTY_NAT ] * +sizeof (struct nat_entry_set ); si->cache_mem += si->inmem_pages *sizeof (struct inmem_pages );for (i =0 ; i <MAX_INO_ENTRY ; i++) si->cache_mem += sbi->im[i].ino_num *sizeof (struct ino_entry );
fs/f2fs/f2fs.h +8 -2
@@ -818,6 +818,13 @@ enum nid_state { MAX_NID_STATE, }; +enum nat_state { +TOTAL_NAT , +DIRTY_NAT , +RECLAIMABLE_NAT , +MAX_NAT_STATE , +}; +struct f2fs_nm_info {block_t nat_blkaddr;/* base disk address of NAT */ nid_t max_nid;/* maximum possible node ids */
@@ -833,8 +840,7 @@ struct f2fs_nm_info {struct rw_semaphore nat_tree_lock;/* protect nat_tree_lock */ struct list_head nat_entries;/* cached nat entry list (clean) */ spinlock_t nat_list_lock;/* protect clean nat entry list */ -unsigned int nat_cnt;/* the # of cached nat entries */ -unsigned int dirty_nat_cnt;/* total num of nat entries in set */ +unsigned int nat_cnt[MAX_NAT_STATE ];/* the # of cached nat entries */ unsigned int nat_blocks;/* # of nat blocks */ /* free node ids management */
fs/f2fs/node.c +18 -11
@@ -62,8 +62,8 @@ bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type) sizeof(struct free_nid)) >> PAGE_SHIFT; res = mem_size < ((avail_ram * nm_i->ram_thresh /100 ) >>2 ); }else if (type ==NAT_ENTRIES ) { - mem_size = (nm_i->nat_cnt *sizeof (struct nat_entry )) >> -PAGE_SHIFT ; + mem_size = (nm_i->nat_cnt[TOTAL_NAT ] * +sizeof (struct nat_entry )) >>PAGE_SHIFT ; res = mem_size < ((avail_ram * nm_i->ram_thresh /100 ) >>2 );if (excess_cached_nats (sbi)) res = false;
@@ -177,7 +177,8 @@ static struct nat_entry *__init_nat_entry(struct f2fs_nm_info *nm_i,list_add_tail (&ne->list, &nm_i->nat_entries);spin_unlock (&nm_i->nat_list_lock); - nm_i->nat_cnt++; + nm_i->nat_cnt[TOTAL_NAT ]++; + nm_i->nat_cnt[RECLAIMABLE_NAT ]++;return ne; }
@@ -207,7 +208,8 @@ static unsigned int __gang_lookup_nat_cache(struct f2fs_nm_info *nm_i,static void __del_from_nat_cache (struct f2fs_nm_info *nm_i,struct nat_entry *e) {radix_tree_delete (&nm_i->nat_root,nat_get_nid (e)); - nm_i->nat_cnt--; + nm_i->nat_cnt[TOTAL_NAT ]--; + nm_i->nat_cnt[RECLAIMABLE_NAT ]--;__free_nat_entry (e); }
@@ -253,7 +255,8 @@ static void __set_nat_cache_dirty(struct f2fs_nm_info *nm_i,if (get_nat_flag (ne,IS_DIRTY )) goto refresh_list; - nm_i->dirty_nat_cnt++; + nm_i->nat_cnt[DIRTY_NAT ]++; + nm_i->nat_cnt[RECLAIMABLE_NAT ]--;set_nat_flag (ne,IS_DIRTY , true); refresh_list:spin_lock (&nm_i->nat_list_lock);
@@ -273,7 +276,8 @@ static void __clear_nat_cache_dirty(struct f2fs_nm_info *nm_i,set_nat_flag (ne,IS_DIRTY , false); set->entry_cnt--; - nm_i->dirty_nat_cnt--; + nm_i->nat_cnt[DIRTY_NAT ]--; + nm_i->nat_cnt[RECLAIMABLE_NAT ]++; } static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,
@@ -2944,14 +2948,17 @@ int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)LIST_HEAD (sets);int err =0 ; -/* during unmount, let's flush nat_bits before checking dirty_nat_cnt */ +/* +* during unmount, let's flush nat_bits before checking +* nat_cnt[DIRTY_NAT]. +*/ if (enabled_nat_bits (sbi, cpc)) {down_write (&nm_i->nat_tree_lock);remove_nats_in_journal (sbi);up_write (&nm_i->nat_tree_lock); } -if (!nm_i->dirty_nat_cnt) +if (!nm_i->nat_cnt[DIRTY_NAT ])return 0 ;down_write (&nm_i->nat_tree_lock);
@@ -2962,7 +2969,8 @@ int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)* into nat entry set. */ if (enabled_nat_bits (sbi, cpc) || - !__has_cursum_space (journal, nm_i->dirty_nat_cnt,NAT_JOURNAL )) + !__has_cursum_space (journal, + nm_i->nat_cnt[DIRTY_NAT ],NAT_JOURNAL ))remove_nats_in_journal (sbi); while ((found = __gang_lookup_nat_set(nm_i,
@@ -3086,7 +3094,6 @@ static int init_node_manager(struct f2fs_sb_info *sbi)F2FS_RESERVED_NODE_NUM ; nm_i->nid_cnt[FREE_NID ] =0 ; nm_i->nid_cnt[PREALLOC_NID ] =0 ; - nm_i->nat_cnt =0 ; 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 ;
@@ -3220,7 +3227,7 @@ void f2fs_destroy_node_manager(struct f2fs_sb_info *sbi)__del_from_nat_cache (nm_i, natvec[idx]); } } -f2fs_bug_on (sbi, nm_i->nat_cnt); +f2fs_bug_on (sbi, nm_i->nat_cnt[TOTAL_NAT ]);/* destroy nat set cache */ nid =0 ;
fs/f2fs/node.h +2 -2
@@ -126,13 +126,13 @@ static inline void raw_nat_from_node_info(struct f2fs_nat_entry *raw_ne,static inline bool excess_dirty_nats (struct f2fs_sb_info *sbi) { -return NM_I (sbi)->dirty_nat_cnt >=NM_I (sbi)->max_nid * +return NM_I (sbi)->nat_cnt[DIRTY_NAT ] >=NM_I (sbi)->max_nid *NM_I (sbi)->dirty_nats_ratio /100 ; }static inline bool excess_cached_nats (struct f2fs_sb_info *sbi) { -return NM_I (sbi)->nat_cnt >=DEF_NAT_CACHE_THRESHOLD ; +return NM_I (sbi)->nat_cnt[TOTAL_NAT ] >=DEF_NAT_CACHE_THRESHOLD ; }static inline bool excess_dirty_nodes (struct f2fs_sb_info *sbi)
fs/f2fs/shrinker.c +1 -3
@@ -18,9 +18,7 @@ static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; - -return count >0 ? count :0 ; +return NM_I (sbi)->nat_cnt[RECLAIMABLE_NAT ]; }static unsigned long __count_free_nids (struct f2fs_sb_info *sbi)
Signature · 1 line
2.29.2.454.gaff20da3a2-goog
Chao Yu
Reviewed-byQuoted 1 line · Jaegeuk Kim
How about adding another variable to monitor it?
That makes more sense. :)
I've checked this, LGTM.
Thanks,
Quoted 312 lines
Quoted 2 lines
From
bdc5a805487f0210df7ef4e85ce5a4f0471bca72Mon Sep 17 00:00:00 2001From: Jaegeuk Kim<[email protected]>
Date: Fri, 6 Nov 2020 13:22:05 -0800
Subject: [PATCH] f2fs: avoid race condition for shrinker countLight reported sometimes shinker gets
nat_cnt<dirty_nat_cntresulting in wrongdo_shinkerwork. Let's avoid to return insane overflowed value by adding single tracking value.Reported-by Light Hsieh<[email protected]>Signed-off-by Jaegeuk Kim<[email protected]>--- fs/f2fs/checkpoint.c | 2 +- fs/f2fs/debug.c | 11 ++++++----- fs/f2fs/f2fs.h | 10 ++++++++-- fs/f2fs/node.c | 29 ++++++++++++++++++----------- fs/f2fs/node.h | 4 ++-- fs/f2fs/shrinker.c | 4 +--- 6 files changed, 36 insertions(+), 24 deletions(-)=======================================
fs/f2fs/checkpoint.c +2
-2--- a/fs/f2fs/checkpoint.c +++ b/fs/f2fs/checkpoint.c@@ -1619,7 +1619,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) goto out; } - if (NM_I(sbi)->dirty_nat_cnt == 0 && + if (NM_I(sbi)->nat_cnt[DIRTY_NAT] == 0 &&SIT_I(sbi)->dirty_sentries == 0 &&
prefree_segments(sbi)== 0) {f2fs_flush_sit_entries(sbi, cpc);=======================================
fs/f2fs/debug.c +3
-3--- a/fs/f2fs/debug.c +++ b/fs/f2fs/debug.c@@ -145,8 +145,8 @@static void update_general_status (struct f2fs_sb_info *sbi) si->node_pages = NODE_MAPPING(sbi)->nrpages;if (sbi->meta_inode) si->meta_pages =META_MAPPING (sbi)->nrpages; - si->nats =NM_I (sbi)->nat_cnt; - si->dirty_nats =NM_I (sbi)->dirty_nat_cnt; + si->nats =NM_I (sbi)->nat_cnt[TOTAL_NAT ]; + si->dirty_nats =NM_I (sbi)->nat_cnt[DIRTY_NAT ];
si->sits=MAIN_SEGS(sbi);si->dirty_sits= SIT_I(sbi)->dirty_sentries;si->free_nids= NM_I(sbi)->nid_cnt[FREE_NID];fs/f2fs/debug.c +0
-0@@ -278,9 +278,10 @@static void update_mem_info (struct f2fs_sb_info *sbi)
si->cache_mem+= (NM_I(sbi)->nid_cnt[FREE_NID] + NM_I(sbi)->nid_cnt[PREALLOC_NID]) *sizeof(struct free_nid);
-si->cache_mem+= NM_I(sbi)->nat_cnt *sizeof(struct nat_entry);
-si->cache_mem+= NM_I(sbi)->dirty_nat_cnt *
-sizeof(struct nat_entry_set);
+si->cache_mem+= NM_I(sbi)->nat_cnt[TOTAL_NAT] *
+sizeof(struct nat_entry);
+si->cache_mem+= NM_I(sbi)->nat_cnt[DIRTY_NAT] *
+sizeof(struct nat_entry_set);si->cache_mem+=si->inmem_pages*sizeof(struct inmem_pages); for (i = 0; i <MAX_INO_ENTRY; i++)si->cache_mem+= sbi->im[i].ino_num *sizeof(struct ino_entry);=======================================
fs/f2fs/f2fs.h +8
-1--- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h@@ -818,6 +818,13 @@enum nid_state {MAX_NID_STATE , }; +enum nat_state { +TOTAL_NAT , +DIRTY_NAT , +RECLAIMABLE_NAT , +MAX_NAT_STATE , +}; +struct f2fs_nm_info {
block_tnat_blkaddr; /* base disk address of NAT */nid_tmax_nid; /* maximum possible node ids */fs/f2fs/f2fs.h +0
-0@@ -833,8 +840,7 @@struct f2fs_nm_info {struct
rw_semaphorenat_tree_lock; /* protectnat_tree_lock*/ structlist_headnat_entries; /* cached nat entry list (clean) */spinlock_tnat_list_lock; /* protect clean nat entry list */
- unsigned intnat_cnt; /* the # of cached nat entries */
- unsigned intdirty_nat_cnt; /* total num of nat entries in set */
+ unsigned int nat_cnt[MAX_NAT_STATE]; /* the # of cached nat entries */ unsigned intnat_blocks; /* # of nat blocks */
/* free node ids management */=======================================
fs/f2fs/node.c +3
-3--- a/fs/f2fs/node.c +++ b/fs/f2fs/node.c@@ -62,8 +62,8 @@ bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type) sizeof(struct free_nid)) >> PAGE_SHIFT; res = mem_size < ((avail_ram * nm_i->ram_thresh /100 ) >>2 ); }else if (type ==NAT_ENTRIES ) { - mem_size = (nm_i->nat_cnt *sizeof (struct nat_entry )) >> -PAGE_SHIFT ; + mem_size = (nm_i->nat_cnt[TOTAL_NAT ] * +sizeof (struct nat_entry )) >>PAGE_SHIFT ;res =
mem_size< ((avail_ram*nm_i->ram_thresh/ 100) >> 2); if (excess_cached_nats(sbi))
res = false;fs/f2fs/node.c +2
-1@@ -177,7 +177,8 @@static struct nat_entry *__init_nat_entry (struct f2fs_nm_info *nm_i, list_add_tail(&ne->list, &nm_i->nat_entries);spin_unlock (&nm_i->nat_list_lock); - nm_i->nat_cnt++; + nm_i->nat_cnt[TOTAL_NAT ]++; + nm_i->nat_cnt[RECLAIMABLE_NAT ]++;return ne;}
fs/f2fs/node.c +2
-1@@ -207,7 +208,8 @@static unsigned int __gang_lookup_nat_cache (struct f2fs_nm_info *nm_i, static void __del_from_nat_cache(struct f2fs_nm_info *nm_i, struct nat_entry *e) {radix_tree_delete (&nm_i->nat_root,nat_get_nid (e)); - nm_i->nat_cnt--; + nm_i->nat_cnt[TOTAL_NAT ]--; + nm_i->nat_cnt[RECLAIMABLE_NAT ]--;
__free_nat_entry(e);
}fs/f2fs/node.c +2
-1@@ -253,7 +255,8 @@static void __set_nat_cache_dirty (struct f2fs_nm_info *nm_i, if (get_nat_flag(ne, IS_DIRTY)) goto refresh_list; - nm_i->dirty_nat_cnt++; + nm_i->nat_cnt[DIRTY_NAT]++; + nm_i->nat_cnt[RECLAIMABLE_NAT]--; set_nat_flag(ne, IS_DIRTY, true);
refresh_list:spin_lock(&nm_i->nat_list_lock);fs/f2fs/node.c +2
-1@@ -273,7 +276,8 @@static void __clear_nat_cache_dirty (struct f2fs_nm_info *nm_i, set_nat_flag(ne, IS_DIRTY, false); set->entry_cnt--; - nm_i->dirty_nat_cnt--; + nm_i->nat_cnt[DIRTY_NAT ]--; + nm_i->nat_cnt[RECLAIMABLE_NAT ]++; }static unsigned int __gang_lookup_nat_set(struct
f2fs_nm_info*nm_i,fs/f2fs/node.c +5
-2@@ -2944,14 +2948,17 @@int f2fs_flush_nat_entries (struct f2fs_sb_info *sbi,struct cp_control *cpc) LIST_HEAD(sets); int err = 0; -/* during unmount, let's flush nat_bits before checking dirty_nat_cnt */ +/* +* during unmount, let's flush nat_bits before checking +* nat_cnt[DIRTY_NAT]. +*/ if (enabled_nat_bits (sbi, cpc)) {down_write (&nm_i->nat_tree_lock);remove_nats_in_journal (sbi);up_write (&nm_i->nat_tree_lock); } -if (!nm_i->dirty_nat_cnt) +if (!nm_i->nat_cnt[DIRTY_NAT ])return 0 ;down_write (&nm_i->nat_tree_lock);@@ -2962,7 +2969,8 @@int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc) * into nat entry set. */ if (
enabled_nat_bits(sbi, cpc)||
- !__has_cursum_space(journal,nm_i->dirty_nat_cnt,NAT_JOURNAL))
+ !__has_cursum_space(journal,
+ nm_i->nat_cnt[DIRTY_NAT],NAT_JOURNAL))remove_nats_in_journal(sbi);
while ((found = __gang_lookup_nat_set(nm_i,fs/f2fs/node.c +0
-1@@ -3086,7 +3094,6 @@ static int init_node_manager(struct f2fs_sb_info *sbi) F2FS_RESERVED_NODE_NUM; nm_i->nid_cnt[FREE_NID ] =0 ; nm_i->nid_cnt[PREALLOC_NID ] =0 ; - nm_i->nat_cnt =0 ;
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;fs/f2fs/node.c +1
-1@@ -3220,7 +3227,7 @@void f2fs_destroy_node_manager (struct f2fs_sb_info *sbi) __del_from_nat_cache(nm_i, natvec[idx]); } } -f2fs_bug_on (sbi, nm_i->nat_cnt); +f2fs_bug_on (sbi, nm_i->nat_cnt[TOTAL_NAT ]);/* destroy nat set cache */
nid = 0;=======================================
fs/f2fs/node.h +3
-3--- a/fs/f2fs/node.h +++ b/fs/f2fs/node.h@@ -126,13 +126,13 @@static inline void raw_nat_from_node_info (struct f2fs_nat_entry *raw_ne, static inline bool excess_dirty_nats(struct f2fs_sb_info *sbi) { -return NM_I (sbi)->dirty_nat_cnt >=NM_I (sbi)->max_nid * +return NM_I (sbi)->nat_cnt[DIRTY_NAT ] >=NM_I (sbi)->max_nid *NM_I (sbi)->dirty_nats_ratio /100 ; }static inline bool excess_cached_nats (struct f2fs_sb_info *sbi) { -return NM_I (sbi)->nat_cnt >=DEF_NAT_CACHE_THRESHOLD ; +return NM_I (sbi)->nat_cnt[TOTAL_NAT ] >=DEF_NAT_CACHE_THRESHOLD ; }static inline bool excess_dirty_nodes (struct f2fs_sb_info *sbi)=======================================
fs/f2fs/shrinker.c +2
-4--- a/fs/f2fs/shrinker.c +++ b/fs/f2fs/shrinker.c@@ -18,9 +18,7 @@static unsigned int shrinker_run_no;static unsigned long __count_nat_entries (struct f2fs_sb_info *sbi) { -long count =NM_I (sbi)->nat_cnt -NM_I (sbi)->dirty_nat_cnt; - -return count >0 ? count :0 ; +return NM_I (sbi)->nat_cnt[RECLAIMABLE_NAT ]; }static unsigned long
__count_free_nids(struct f2fs_sb_info *sbi)Signature · 3 lines
2.29.2.454.gaff20da3a2-goog .