Skip to contentSkip to conversation

f2fs: do not use mutex lock in atomic context

PATCH In review Sahitya Tummala 4 participants 7 messages Feb 4, 2019 – Feb 18, 2019 F2FS file system

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 f2fs: do not use mutex lock in atomic context

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
 dump_backtrace+0x0/0x2b4
 show_stack+0x20/0x28
 dump_stack+0xa8/0xe0
 ___might_sleep+0x144/0x194
 __might_sleep+0x58/0x8c
 mutex_lock+0x2c/0x48
 f2fs_trace_pid+0x88/0x14c
 f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
 fs/f2fs/trace.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +13 -7
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
 #include "trace.h"
 
 static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
 static struct last_io_info last_io;
 
 static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
 	set_page_private(page, (unsigned long)pid);
 
+retry:
 	if (radix_tree_preload(GFP_NOFS))
 		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	p = radix_tree_lookup(&pids, pid);
 	if (p == current)
 		goto out;
 	if (p)
 		radix_tree_delete(&pids, pid);
 
-	f2fs_radix_tree_insert(&pids, pid, current);
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
 	trace_printk("%3x:%3x %4x %-16s\n",
 			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
 			pid, current->comm);
 out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 	radix_tree_preload_end();
 }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
 void f2fs_build_trace_ios(void)
 {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
 }
 
 #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
 	pid_t next_pid = 0;
 	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
 		unsigned idx;
 
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
 		for (idx = 0; idx < found; idx++)
 			radix_tree_delete(&pids, pid[idx]);
 	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 }
Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc.
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
#1 lore raw
Quoted 53 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
 dump_backtrace+0x0/0x2b4
 show_stack+0x20/0x28
 dump_stack+0xa8/0xe0
 ___might_sleep+0x144/0x194
 __might_sleep+0x58/0x8c
 mutex_lock+0x2c/0x48
 f2fs_trace_pid+0x88/0x14c
 f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
 fs/f2fs/trace.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +3 -3
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
 #include "trace.h"
 
 static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
 static struct last_io_info last_io;
 
 static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
 	set_page_private(page, (unsigned long)pid);
 
+retry:
 	if (radix_tree_preload(GFP_NOFS))
 		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	p = radix_tree_lookup(&pids, pid);
 	if (p == current)
 		goto out;
 	if (p)
 		radix_tree_delete(&pids, pid);
 
-	f2fs_radix_tree_insert(&pids, pid, current);

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 81

Quoted 10 lines
fs/f2fs/trace.c +6 -0
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
 	trace_printk("%3x:%3x %4x %-16s\n",
 			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
 			pid, current->comm);

Hi Sahitya,

Can trace_printk sleep? For safety, how about moving it out of spinlock?

Thanks,

Quoted 32 lines
fs/f2fs/trace.c +4 -4
 out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 	radix_tree_preload_end();
 }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
 void f2fs_build_trace_ios(void)
 {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
 }
 
 #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
 	pid_t next_pid = 0;
 	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
 		unsigned idx;
 
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
 		for (idx = 0; idx < found; idx++)
 			radix_tree_delete(&pids, pid[idx]);
 	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 }
#2 lore raw
Quoted 61 lines · Chao Yu
Quoted 60 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
 dump_backtrace+0x0/0x2b4
 show_stack+0x20/0x28
 dump_stack+0xa8/0xe0
 ___might_sleep+0x144/0x194
 __might_sleep+0x58/0x8c
 mutex_lock+0x2c/0x48
 f2fs_trace_pid+0x88/0x14c
 f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
 fs/f2fs/trace.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +9 -3
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
 #include "trace.h"
 
 static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
 static struct last_io_info last_io;
 
 static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
 	set_page_private(page, (unsigned long)pid);
 
+retry:
 	if (radix_tree_preload(GFP_NOFS))
 		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	p = radix_tree_lookup(&pids, pid);
 	if (p == current)
 		goto out;
 	if (p)
 		radix_tree_delete(&pids, pid);
 
-	f2fs_radix_tree_insert(&pids, pid, current);
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
Quoted 8 lines

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 81

Quoted 3 lines
fs/f2fs/trace.c +0 -0
 	trace_printk("%3x:%3x %4x %-16s\n",
 			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
 			pid, current->comm);

Hi Sahitya,

Can trace_printk sleep? For safety, how about moving it out of spinlock?

Hi Chao,

Yes, trace_printk() is safe to use in atomic context (unlike printk).

Thanks,
Sahitya.

Quoted 35 lines

Thanks,

Quoted 32 lines
fs/f2fs/trace.c +4 -4
 out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 	radix_tree_preload_end();
 }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
 void f2fs_build_trace_ios(void)
 {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
 }
 
 #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
 	pid_t next_pid = 0;
 	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
 		unsigned idx;
 
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
 		for (idx = 0; idx < found; idx++)
 			radix_tree_delete(&pids, pid[idx]);
 	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 }
Signature · 3 lines
--
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
maintainer Reviewed-by
#3 lore raw
Quoted 68 lines · Sahitya Tummala
Quoted 67 lines · Chao Yu
Quoted 53 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
 dump_backtrace+0x0/0x2b4
 show_stack+0x20/0x28
 dump_stack+0xa8/0xe0
 ___might_sleep+0x144/0x194
 __might_sleep+0x58/0x8c
 mutex_lock+0x2c/0x48
 f2fs_trace_pid+0x88/0x14c
 f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
 fs/f2fs/trace.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +3 -3
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
 #include "trace.h"
 
 static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
 static struct last_io_info last_io;
 
 static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
 	set_page_private(page, (unsigned long)pid);
 
+retry:
 	if (radix_tree_preload(GFP_NOFS))
 		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	p = radix_tree_lookup(&pids, pid);
 	if (p == current)
 		goto out;
 	if (p)
 		radix_tree_delete(&pids, pid);
 
-	f2fs_radix_tree_insert(&pids, pid, current);

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 81

Quoted 10 lines
fs/f2fs/trace.c +6 -0
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
 	trace_printk("%3x:%3x %4x %-16s\n",
 			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
 			pid, current->comm);

Hi Sahitya,

Quoted 5 lines
Quoted 2 lines

Can trace_printk sleep? For safety, how about moving it out of spinlock?

Hi Chao,

Yes, trace_printk() is safe to use in atomic context (unlike printk).

Hi Sahitya,

Thanks for your confirmation. :)

Thanks,

Quoted 40 lines

Thanks,
Sahitya.

Quoted 35 lines

Thanks,

Quoted 32 lines
fs/f2fs/trace.c +4 -4
 out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 	radix_tree_preload_end();
 }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
 void f2fs_build_trace_ios(void)
 {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
 }
 
 #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
 	pid_t next_pid = 0;
 	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
 	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
 		unsigned idx;
 
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
 		for (idx = 0; idx < found; idx++)
 			radix_tree_delete(&pids, pid[idx]);
 	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
 }
#4 lore raw
Quoted 55 lines · Chao Yu
Quoted 54 lines · Sahitya Tummala
Quoted 53 lines · Chao Yu
Quoted 52 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
  dump_backtrace+0x0/0x2b4
  show_stack+0x20/0x28
  dump_stack+0xa8/0xe0
  ___might_sleep+0x144/0x194
  __might_sleep+0x58/0x8c
  mutex_lock+0x2c/0x48
  f2fs_trace_pid+0x88/0x14c
  f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
  fs/f2fs/trace.c | 20 +++++++++++++-------
  1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +3 -2
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
  #include "trace.h"
 
  static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
  static struct last_io_info last_io;
 
  static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
  	set_page_private(page, (unsigned long)pid);
 
+retry:
  	if (radix_tree_preload(GFP_NOFS))
  		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
  	p = radix_tree_lookup(&pids, pid);
  	if (p == current)
  		goto out;
  	if (p)
  		radix_tree_delete(&pids, pid);
 
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 71

Quoted 1 line
fs/f2fs/trace.c +0 -1
-	f2fs_radix_tree_insert(&pids, pid, current);

Do you know why do we have a retry logic here? When anyways we have called for radix_tree_delete with pid key? Which should ensure the slot is empty, no?
Then why in the original code (f2fs_radix_tree_insert), we were retrying. For what condition a retry was needed?

Regards
Ritesh

Quoted 67 lines
Quoted 12 lines
Quoted 12 lines

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 81

Quoted 10 lines
fs/f2fs/trace.c +6 -0
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
  	trace_printk("%3x:%3x %4x %-16s\n",
  			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
  			pid, current->comm);

Hi Sahitya,

Quoted 5 lines
Quoted 2 lines

Can trace_printk sleep? For safety, how about moving it out of spinlock?

Hi Chao,

Yes, trace_printk() is safe to use in atomic context (unlike printk).

Hi Sahitya,

Thanks for your confirmation. :)

Thanks,

Quoted 29 lines

Thanks,
Sahitya.

Quoted 26 lines

Thanks,

Quoted 24 lines
fs/f2fs/trace.c +3 -3
  out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
  	radix_tree_preload_end();
  }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
  void f2fs_build_trace_ios(void)
  {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
  }
 
  #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
  	pid_t next_pid = 0;
  	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
  	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
  		unsigned idx;
 
Quoted 8 lines
Quoted 8 lines

fs/f2fs/trace.c void f2fs_destroy_trace_ios(void) · line 165

Quoted 8 lines
fs/f2fs/trace.c +1 -1
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
  		for (idx = 0; idx < found; idx++)
  			radix_tree_delete(&pids, pid[idx]);
  	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
  }

_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

#5 lore raw
Quoted 57 lines · Ritesh Harjani
Quoted 55 lines · Chao Yu
Quoted 54 lines · Sahitya Tummala
Quoted 53 lines · Chao Yu
Quoted 52 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
  dump_backtrace+0x0/0x2b4
  show_stack+0x20/0x28
  dump_stack+0xa8/0xe0
  ___might_sleep+0x144/0x194
  __might_sleep+0x58/0x8c
  mutex_lock+0x2c/0x48
  f2fs_trace_pid+0x88/0x14c
  f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
  fs/f2fs/trace.c | 20 +++++++++++++-------
  1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +3 -2
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
  #include "trace.h"
 
  static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
  static struct last_io_info last_io;
 
  static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
  	set_page_private(page, (unsigned long)pid);
 
+retry:
  	if (radix_tree_preload(GFP_NOFS))
  		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
  	p = radix_tree_lookup(&pids, pid);
  	if (p == current)
  		goto out;
  	if (p)
  		radix_tree_delete(&pids, pid);
 
Quoted 7 lines
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 71

Quoted 1 line
fs/f2fs/trace.c +0 -1
-	f2fs_radix_tree_insert(&pids, pid, current);

Do you know why do we have a retry logic here? When anyways we have called for radix_tree_delete with pid key?
Which should ensure the slot is empty, no?
Then why in the original code (f2fs_radix_tree_insert), we were retrying. For what condition a retry was needed?

Hi,

f2fs_radix_tree_insert is used in many places, it was introduced to used in some paths we should not failed.

And here, I guess we used it for the same purpose, if we failed to insert @current pointer into radix, next time, we may not skip calling trace_printk, actually it will print the same current->comm info as previous one, it's redundant.

Thanks,

Quoted 75 lines

Regards
Ritesh

Quoted 54 lines
Quoted 12 lines
Quoted 12 lines

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 81

Quoted 10 lines
fs/f2fs/trace.c +6 -0
+	if (radix_tree_insert(&pids, pid, current)) {
+		spin_unlock(&pids_lock);
+		radix_tree_preload_end();
+		cond_resched();
+		goto retry;
+	}
 
  	trace_printk("%3x:%3x %4x %-16s\n",
  			MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
  			pid, current->comm);

Hi Sahitya,

Quoted 5 lines
Quoted 2 lines

Can trace_printk sleep? For safety, how about moving it out of spinlock?

Hi Chao,

Yes, trace_printk() is safe to use in atomic context (unlike printk).

Hi Sahitya,

Thanks for your confirmation. :)

Thanks,

Quoted 29 lines

Thanks,
Sahitya.

Quoted 26 lines

Thanks,

Quoted 24 lines
fs/f2fs/trace.c +3 -3
  out:
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
  	radix_tree_preload_end();
  }
 
@@ -119,7 +125,7 @@ void f2fs_trace_ios(struct f2fs_io_info *fio, int flush)
 
  void f2fs_build_trace_ios(void)
  {
-	mutex_init(&pids_lock);
+	spin_lock_init(&pids_lock);
  }
 
  #define PIDVEC_SIZE	128
@@ -147,7 +153,7 @@ void f2fs_destroy_trace_ios(void)
  	pid_t next_pid = 0;
  	unsigned int found;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
  	while ((found = gang_lookup_pids(pid, next_pid, PIDVEC_SIZE))) {
  		unsigned idx;
 
Quoted 13 lines
Quoted 8 lines
Quoted 8 lines

fs/f2fs/trace.c void f2fs_destroy_trace_ios(void) · line 165

Quoted 8 lines
fs/f2fs/trace.c +1 -1
@@ -155,5 +161,5 @@ void f2fs_destroy_trace_ios(void)
  		for (idx = 0; idx < found; idx++)
  			radix_tree_delete(&pids, pid[idx]);
  	}
-	mutex_unlock(&pids_lock);
+	spin_unlock(&pids_lock);
  }

_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

.

#6 lore raw
Quoted 65 lines · Chao Yu
Quoted 56 lines · Ritesh Harjani
Quoted 55 lines · Chao Yu
Quoted 54 lines · Sahitya Tummala
Quoted 53 lines · Chao Yu
Quoted 52 lines · Sahitya Tummala

Fix below warning coming because of using mutex lock in atomic context.

BUG: sleeping function called from invalid context at kernel/locking/mutex.c:98
in_atomic(): 1, irqs_disabled(): 0, pid: 585, name: sh
Preemption disabled at: __radix_tree_preload+0x28/0x130
Call trace:
   dump_backtrace+0x0/0x2b4
   show_stack+0x20/0x28
   dump_stack+0xa8/0xe0
   ___might_sleep+0x144/0x194
   __might_sleep+0x58/0x8c
   mutex_lock+0x2c/0x48
   f2fs_trace_pid+0x88/0x14c
   f2fs_set_node_page_dirty+0xd0/0x184

Do not use f2fs_radix_tree_insert() to avoid doing cond_resched() with spin_lock() acquired.

---
   fs/f2fs/trace.c | 20 +++++++++++++-------
   1 file changed, 13 insertions(+), 7 deletions(-)
fs/f2fs/trace.c +3 -2
index ce2a5eb..d0ab533 100644
@@ -14,7 +14,7 @@
   #include "trace.h"
 
   static RADIX_TREE(pids, GFP_ATOMIC);
-static struct mutex pids_lock;
+static spinlock_t pids_lock;
   static struct last_io_info last_io;
 
   static inline void __print_last_io(void)
@@ -58,23 +58,29 @@ void f2fs_trace_pid(struct page *page)
 
   	set_page_private(page, (unsigned long)pid);
 
+retry:
   	if (radix_tree_preload(GFP_NOFS))
   		return;
 
-	mutex_lock(&pids_lock);
+	spin_lock(&pids_lock);
   	p = radix_tree_lookup(&pids, pid);
   	if (p == current)
   		goto out;
   	if (p)
   		radix_tree_delete(&pids, pid);
 
Quoted 6 lines
Quoted 1 line
Quoted 1 line
Quoted 1 line

fs/f2fs/trace.c void f2fs_trace_pid(struct page *page) · line 71

Quoted 1 line
fs/f2fs/trace.c +0 -1
-	f2fs_radix_tree_insert(&pids, pid, current);

Do you know why do we have a retry logic here? When anyways we have called for radix_tree_delete with pid key?
Which should ensure the slot is empty, no?
Then why in the original code (f2fs_radix_tree_insert), we were retrying. For what condition a retry was needed?

Hi,

Quoted 7 lines

f2fs_radix_tree_insert is used in many places, it was introduced to used in some paths we should not failed.

And here, I guess we used it for the same purpose, if we failed to insert @current pointer into radix, next time, we may not skip calling trace_printk, actually it will print the same current->comm info as previous one, it's redundant.

Sure, thanks for the info.

Regards
Ritesh