Skip to contentSkip to conversation

vfs: Fix lock inversion in drop_pagecache_sb()

PATCH In review Jan Kara 4 participants 7 messages Mar 25, 2008 – Mar 26, 2008 VFS

lore
Share & tools
lore

Jan Kara

author reviewer
#0 lore raw

PATCH 1/1 vfs: Fix lock inversion in drop_pagecache_sb()

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +7 -1
index 59375ef..f5aae26 100644
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;
+		__iget(inode);
+		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
+		iput(toput_inode);
+		toput_inode = inode;
+		spin_lock(&inode_lock);
 	}
 	spin_unlock(&inode_lock);
+	iput(toput_inode);
 }
 
 void drop_pagecache(void)
Signature · 1 line
1.5.2.4
#1 lore raw
Quoted 19 lines · On Tue, 25 Mar 2008 19:12:27 +0100 Jan Kara <[email protected]> wrote:

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +0 -0
index 59375ef..f5aae26 100644

fs/drop_caches.c int sysctl_drop_caches; · line 22

Quoted 10 lines
fs/drop_caches.c +1 -1
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;

OT: it might be worth having an `if (mapping->nrpages==0) continue' here.

fs/drop_caches.c int sysctl_drop_caches; · line 34

Quoted 12 lines
fs/drop_caches.c +6 -0
+		__iget(inode);
+		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
+		iput(toput_inode);
+		toput_inode = inode;
+		spin_lock(&inode_lock);
 	}
 	spin_unlock(&inode_lock);
+	iput(toput_inode);
 }
 
 void drop_pagecache(void)

hrm. So we have a random ref on an inode without holding inode_lock. If we race with invalidate_list() we end up with an inode stuck on s_inodes and "Self-destruct in 5 seconds. Have a nice day...", don't we?

#2 lore raw
Quoted 46 lines · Andrew Morton
Quoted 19 lines · On Tue, 25 Mar 2008 19:12:27 +0100 Jan Kara <[email protected]> wrote:

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +0 -0
index 59375ef..f5aae26 100644

fs/drop_caches.c int sysctl_drop_caches; · line 22

Quoted 10 lines
fs/drop_caches.c +1 -1
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;

OT: it might be worth having an `if (mapping->nrpages==0) continue' here.

Quoted 11 lines
fs/drop_caches.c +6 -0
+		__iget(inode);
+		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
+		iput(toput_inode);
+		toput_inode = inode;
+		spin_lock(&inode_lock);
 	}
 	spin_unlock(&inode_lock);
+	iput(toput_inode);
 }
 
Quoted 5 lines

fs/drop_caches.c int sysctl_drop_caches; · line 34

Quoted 1 line
fs/drop_caches.c +0 -0
 void drop_pagecache(void)

hrm. So we have a random ref on an inode without holding inode_lock. If we race with invalidate_list() we end up with an inode stuck on s_inodes and "Self-destruct in 5 seconds. Have a nice day...", don't we?

Calling drop_pagecache_sb() without having a reference to 'sb'? Surely not...

Trond

#3 lore raw
In reply to Andrew Morton
Quoted 28 lines · Andrew Morton
Quoted 25 lines · On Tue, 25 Mar 2008 19:12:27 +0100 Jan Kara <[email protected]> wrote:

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +1 -1
index 59375ef..f5aae26 100644
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
Quoted 6 lines

fs/drop_caches.c int sysctl_drop_caches; · line 22

Quoted 4 lines
fs/drop_caches.c +0 -0
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;

OT: it might be worth having an `if (mapping->nrpages==0) continue' here.

Good catch!

There are 25k opened inodes in my desktop, merely 10% of them has cached pages:

% cat /proc/sys/fs/inode-state
25395 129 0 0 0 0 0
# wc -l /proc/filecache
2542 /proc/filecache

+ if (!inode->i_mapping || !inode->i_mapping->nrpages)
+ continue;

author reviewer
#4 lore raw
In reply to Andrew Morton
Quoted 28 lines · Andrew Morton
Quoted 25 lines · On Tue, 25 Mar 2008 19:12:27 +0100 Jan Kara <[email protected]> wrote:

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +1 -1
index 59375ef..f5aae26 100644
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
Quoted 6 lines

fs/drop_caches.c int sysctl_drop_caches; · line 22

Quoted 4 lines
fs/drop_caches.c +0 -0
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;

OT: it might be worth having an `if (mapping->nrpages==0) continue' here.

Good idea. I'll send a patch in a minute.

Quoted 11 lines
Quoted 11 lines
fs/drop_caches.c +6 -0
+		__iget(inode);
+		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
+		iput(toput_inode);
+		toput_inode = inode;
+		spin_lock(&inode_lock);
 	}
 	spin_unlock(&inode_lock);
+	iput(toput_inode);
 }
 
Quoted 5 lines

fs/drop_caches.c int sysctl_drop_caches; · line 34

Quoted 1 line
fs/drop_caches.c +0 -0
 void drop_pagecache(void)

hrm. So we have a random ref on an inode without holding inode_lock. If we race with invalidate_list() we end up with an inode stuck on s_inodes and "Self-destruct in 5 seconds. Have a nice day...", don't we?

We hold s_umount for reading so we should be safe against someone trying
to do umount. We could possibly race with invalidate_list() called from check_disk_change() but removing media without unmounting is a bad behavior anyway. So I think we are fine.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author reviewer
#5 lore raw

PATCH 1/1 vfs: Skip inodes without pages to free in drop_pagecache_sb()

In reply to Andrew Morton
CC Fengguang Wu <[email protected]>
---
 fs/drop_caches.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)
fs/drop_caches.c +2 -0
index f5aae26..7327a42 100644
@@ -20,6 +20,8 @@ static void drop_pagecache_sb(struct super_block *sb)
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;
+		if (inode->i_mapping->nrpages == 0)
+			continue;
 		__iget(inode);
 		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
Signature · 1 line
1.5.2.4
Reviewed-by on v1 1/1
#6 lore raw
In reply to Jan Kara
Quoted 5 lines · Jan Kara

Fix longstanding lock inversion in drop_pagecache_sb by dropping inode_lock before calling __invalidate_mapping_pages(). We just have to make sure inode won't go away from under us by keeping reference to it and putting the reference only after we have safely resumed the scan of the inode list. A bit tricky but not too bad...

It's a handy trick to iterate through the list_head :-) I have practiced this in my filecache code, and it works nice.

Fengguang

Quoted 38 lines
CC Fengguang Wu <[email protected]>
CC David Chinner <[email protected]>
---
 fs/drop_caches.c |    8 +++++++-
 1 files changed, 7 insertions(+), 1 deletions(-)
fs/drop_caches.c +7 -1
index 59375ef..f5aae26 100644
@@ -14,15 +14,21 @@ int sysctl_drop_caches;
 
 static void drop_pagecache_sb(struct super_block *sb)
 {
-	struct inode *inode;
+	struct inode *inode, *toput_inode = NULL;
 
 	spin_lock(&inode_lock);
 	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
 		if (inode->i_state & (I_FREEING|I_WILL_FREE))
 			continue;
+		__iget(inode);
+		spin_unlock(&inode_lock);
 		__invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
+		iput(toput_inode);
+		toput_inode = inode;
+		spin_lock(&inode_lock);
 	}
 	spin_unlock(&inode_lock);
+	iput(toput_inode);
 }
 
 void drop_pagecache(void)
Signature · 1 line
1.5.2.4