Skip to contentSkip to conversation

f2fs: avoid race condition for shinker count

PATCH In review Jaegeuk Kim 2 participants 13 messages Nov 9, 2020 – Dec 3, 2020 F2FS file system

lore
Share & tools
lore

Jaegeuk Kim

author maintainer
#0 lore raw

PATCH 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
index 42394de6c7eb..e8ec65e40f06 100644
@@ -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
#1 lore raw
Quoted 1 line · Jaegeuk Kim

Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting 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_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

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=1

nm_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
---
  fs/f2fs/node.c | 3 +--
  1 file changed, 1 insertion(+), 2 deletions(-)
fs/f2fs/node.c +1 -2
index 42394de6c7eb..e8ec65e40f06 100644
@@ -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,
author maintainer
#2 lore raw
Quoted 22 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim

Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting 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_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

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=1
Quoted 4 lines

nm_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.

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
---
  fs/f2fs/node.c | 3 +--
  1 file changed, 1 insertion(+), 2 deletions(-)
fs/f2fs/node.c +1 -2
index 42394de6c7eb..e8ec65e40f06 100644
@@ -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,
 
#3 lore raw
Quoted 23 lines · Jaegeuk Kim
Quoted 22 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim

Light reported sometimes shinker gets nat_cnt < dirty_nat_cnt resulting 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 14 lines

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
Quoted 8 lines
Quoted 4 lines

nm_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.

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?

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
---
   fs/f2fs/node.c | 3 +--
   1 file changed, 1 insertion(+), 2 deletions(-)
fs/f2fs/node.c +0 -1
index 42394de6c7eb..e8ec65e40f06 100644
@@ -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,
 

.

author maintainer
#4 lore raw
Quoted 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_cnt resulting 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_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

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=1

nm_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.

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 of nat_cnt < dirty_nat_cnt in shrink_count. We may need to use nat_tree_lock in shrink_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
---
   fs/f2fs/node.c | 3 +--
   1 file changed, 1 insertion(+), 2 deletions(-)
fs/f2fs/node.c +0 -1
index 42394de6c7eb..e8ec65e40f06 100644
@@ -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

author maintainer
#5 lore raw
In reply to Jaegeuk Kim

Light 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
index d66de5999a26..d42245ab07f4 100644
@@ -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
author maintainer
#6 lore raw

Light 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
index d66de5999a26..555712ba06d8 100644
@@ -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
Reviewed-by
#7 lore raw
Quoted 18 lines · Jaegeuk Kim

Light 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 +0 -0
index d66de5999a26..555712ba06d8 100644
@@ -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 -1
  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,

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
  }
author maintainer
#8 lore raw
Quoted 30 lines · Chao Yu
Quoted 17 lines · Jaegeuk Kim

Light 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 +0 -0
index d66de5999a26..555712ba06d8 100644

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);
  	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,

Thanks,

Thanks,

Quoted 2 lines
fs/f2fs/shrinker.c +0 -0
  }
 
author maintainer
#9 lore raw
In reply to Jaegeuk Kim
Quoted 17 lines · Jaegeuk Kim

Light 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 +0 -0
index d66de5999a26..555712ba06d8 100644

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_count
shrink_slab
shrink_node
do_try_to_free_pages
try_to_free_pages
__alloc_pages_nodemask
alloc_pages_current
allocate_slab
__slab_alloc
__slab_alloc
kmem_cache_alloc
add_free_nid
f2fs_flush_nat_entries
f2fs_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
index d66de5999a26..75b5b4aaed99 100644
@@ -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 -0
 	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
#10 lore raw
Quoted 35 lines · Jaegeuk Kim
Quoted 17 lines · Jaegeuk Kim

Light 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 +0 -0
index d66de5999a26..555712ba06d8 100644

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_count
shrink_slab
shrink_node
do_try_to_free_pages
try_to_free_pages
__alloc_pages_nodemask

Quoted 8 lines

alloc_pages_current
allocate_slab
__slab_alloc
__slab_alloc
kmem_cache_alloc
add_free_nid
f2fs_flush_nat_entries
f2fs_write_checkpoint

Oh, I missed that case.

Quoted 22 lines

Let me just check like this.

Quoted 1 line

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 +0 -0
index d66de5999a26..75b5b4aaed99 100644

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)
author maintainer
#11 lore raw
Quoted 63 lines · Chao Yu
Quoted 34 lines · Jaegeuk Kim
Quoted 17 lines · Jaegeuk Kim

Light 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 +0 -0
index d66de5999a26..555712ba06d8 100644

fs/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_count
shrink_slab
shrink_node
do_try_to_free_pages
try_to_free_pages
__alloc_pages_nodemask

Quoted 8 lines

alloc_pages_current
allocate_slab
__slab_alloc
__slab_alloc
kmem_cache_alloc
add_free_nid
f2fs_flush_nat_entries
f2fs_write_checkpoint

Oh, I missed that case.

Quoted 17 lines

Let me just check like this.

Quoted 1 line

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(-)
Quoted 16 lines

fs/f2fs/shrinker.c static unsigned int shrinker_run_no; · line 21

Quoted 12 lines
fs/f2fs/shrinker.c +2 -3
index d66de5999a26..75b5b4aaed99 100644
@@ -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? :(

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
index 14ba1519639e..617d0f6b0836 100644
@@ -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
index a8357fd4f5fa..197c914119da 100644
@@ -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
index 4417f791dbc6..78394ea91717 100644
@@ -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
index 42394de6c7eb..e65d73293a3f 100644
@@ -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
index 69e5859e993c..f84541b57acb 100644
@@ -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
index d66de5999a26..dd3c3c7a90ec 100644
@@ -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
Reviewed-by
#12 lore raw
Quoted 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 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 +2 -2
index 14ba1519639e..617d0f6b0836 100644
 
--- 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
index a8357fd4f5fa..197c914119da 100644
 
--- 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
index 4417f791dbc6..78394ea91717 100644
 
--- 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_t nat_blkaddr; /* base disk address of NAT */ nid_t max_nid; /* maximum possible node ids */

fs/f2fs/f2fs.h +0 -0
@@ -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 +3 -3
index 42394de6c7eb..e65d73293a3f 100644
 
--- 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
index 69e5859e993c..f84541b57acb 100644
 
--- 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
index d66de5999a26..dd3c3c7a90ec 100644
 
--- 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

.