btrfs: delayed-inode: Use spinlock to protect btrfs_inode::delayed_node
RFC PATCH 1/1 btrfs: delayed-inode: Use spinlock to protect btrfs_inode::delayed_node
In the following case, we could trigger a use-after-free bug:
CPU0 | CPU1
-------------------------------------------------------------------------
btrfs_remove_delayed_node | btrfs_get_delayed_node
|- delayed_node = | |- node = btrfs_inode->delayed_node;
| btrfs_inode->delayed_node | |
|- btrfs_release_delaedy_node() | |
|- ref_count_dev_and_test() | |
|- kmem_cache_free() | |
Now delayed node is freed | |
| |- refcount_inc(&node->refs)In that case sine delayed_node is using kmem cache, such use-after-free bug won't directly cause problem, but could leads to corrupted data structure of other kmem cache user.
Fix it by adding btrfs_inode::delayed_node_lock to protect such operation.
---
Please don't merge this patch yet.
The patch caused random slow down for a lot of quick test cases. Old tests can be executed in 1s or so now randomly needs near 20s.
It looks like the spin_lock() with root->inode_lock hold is causing the problem but I can't see what's going wrong.
As the operation done with @delayed_node_lock hold is literatly tiny.
Any comment on this is welcomed.
--- fs/btrfs/btrfs_inode.h | 2 ++ fs/btrfs/delayed-inode.c | 18 +++++++++++++++--- fs/btrfs/inode.c | 1 + 3 files changed, 18 insertions(+), 3 deletions(-)
fs/btrfs/btrfs_inode.h +2 -0
@@ -175,6 +175,8 @@ struct btrfs_inode {*/ unsigned defrag_compress; +/* lock for grabbing/freeing @delayed_node */ +spinlock_t delayed_node_lock;struct btrfs_delayed_node *delayed_node;/* File creation time. */
fs/btrfs/delayed-inode.c +15 -3
@@ -68,19 +68,24 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(u64 ino =btrfs_ino (btrfs_inode);struct btrfs_delayed_node *node; - node =READ_ONCE (btrfs_inode->delayed_node); +spin_lock (&btrfs_inode->delayed_node_lock); + node = btrfs_inode->delayed_node;if (node) {refcount_inc (&node->refs); +spin_unlock (&btrfs_inode->delayed_node_lock);return node; } +spin_unlock (&btrfs_inode->delayed_node_lock);spin_lock (&root->inode_lock); node =radix_tree_lookup (&root->delayed_nodes_tree, ino);if (node) { +spin_lock (&btrfs_inode->delayed_node_lock);if (btrfs_inode->delayed_node) {refcount_inc (&node->refs);/* can be accessed */ BUG_ON (btrfs_inode->delayed_node != node); +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);return node; }
@@ -108,6 +113,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node( node =NULL ; } +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);return node; }
@@ -152,7 +158,9 @@ static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(radix_tree_preload_end (); goto again; } +spin_lock (&btrfs_inode->delayed_node_lock); btrfs_inode->delayed_node = node; +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);radix_tree_preload_end ();
@@ -1279,11 +1287,15 @@ void btrfs_remove_delayed_node(struct btrfs_inode *inode) {struct btrfs_delayed_node *delayed_node; - delayed_node =READ_ONCE (inode->delayed_node); -if (!delayed_node) +spin_lock (&inode->delayed_node_lock); + delayed_node = inode->delayed_node; +if (!delayed_node) { +spin_unlock (&inode->delayed_node_lock);return ; + } inode->delayed_node =NULL ; +spin_unlock (&inode->delayed_node_lock);btrfs_release_delayed_node (delayed_node); }
fs/btrfs/inode.c +1 -0
@@ -9177,6 +9177,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) ei->last_log_commit =0 ;spin_lock_init (&ei->lock); +spin_lock_init (&ei->delayed_node_lock); ei->outstanding_extents =0 ;if (sb->s_magic !=BTRFS_TEST_MAGIC ) btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,
Signature · 1 line
2.19.0
Quoted 17 lines · Qu Wenruo
In the following case, we could trigger a use-after-free bug:
CPU0 | CPU1
-------------------------------------------------------------------------btrfs_remove_delayed_node | btrfs_get_delayed_node |- delayed_node = | |- node = btrfs_inode->delayed_node; | btrfs_inode->delayed_node | | |- btrfs_release_delaedy_node() | | |- ref_count_dev_and_test() | | |- kmem_cache_free() | | Now delayed node is freed | | | |- refcount_inc(&node->refs)In that case sine
delayed_nodeis using kmem cache, such use-after-free bug won't directly cause problem, but could leads to corrupted data structure of other kmem cache user.
Quoted 7 lines
Fix it by adding
btrfs_inode::delayed_node_lockto protect such operation.Reported-by sunny.s.zhang <[email protected]>Signed-off-by Qu Wenruo <[email protected]>---
Please don't merge this patch yet.
False alert.
The performance degradation is a false alert, and it's pretty awkward.
Before this test run, I refilled TEST_DEV with a special file layout (for my qgroup balance test) to increase balance/qgroup overhead. And the file layout also turns out to be pretty heavy for btrfs check, which makes the test time increase.
Since it's a false alert, the RFC tag is no longer needed.
Thanks,
Qu
Quoted 107 lines
The patch caused random slow down for a lot of quick test cases. Old tests can be executed in 1s or so now randomly needs near 20s.
It looks like the
spin_lock()withroot->inode_lockhold is causing the problem but I can't see what's going wrong.
As the operation done with @delayed_node_lock hold is literatly tiny.Any comment on this is welcomed.
--- fs/btrfs/btrfs_inode.h | 2 ++ fs/btrfs/delayed-inode.c | 18 +++++++++++++++--- fs/btrfs/inode.c | 1 + 3 files changed, 18 insertions(+), 3 deletions(-)fs/btrfs/btrfs_inode.h +2
-0@@ -175,6 +175,8 @@ struct btrfs_inode {*/ unsigned defrag_compress; +/* lock for grabbing/freeing @delayed_node */ +spinlock_t delayed_node_lock;struct btrfs_delayed_node *delayed_node;/* File creation time. */ fs/btrfs/delayed-inode.c +15
-3@@ -68,19 +68,24 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(u64 ino =btrfs_ino (btrfs_inode);struct btrfs_delayed_node *node; - node =READ_ONCE (btrfs_inode->delayed_node); +spin_lock (&btrfs_inode->delayed_node_lock); + node = btrfs_inode->delayed_node;if (node) {refcount_inc (&node->refs); +spin_unlock (&btrfs_inode->delayed_node_lock);return node; } +spin_unlock (&btrfs_inode->delayed_node_lock);spin_lock (&root->inode_lock); node =radix_tree_lookup (&root->delayed_nodes_tree, ino);if (node) { +spin_lock (&btrfs_inode->delayed_node_lock);if (btrfs_inode->delayed_node) {refcount_inc (&node->refs);/* can be accessed */ BUG_ON (btrfs_inode->delayed_node != node); +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);return node; }@@ -108,6 +113,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node( node =NULL ; } +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);return node; }@@ -152,7 +158,9 @@ static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(radix_tree_preload_end (); goto again; } +spin_lock (&btrfs_inode->delayed_node_lock); btrfs_inode->delayed_node = node; +spin_unlock (&btrfs_inode->delayed_node_lock);spin_unlock (&root->inode_lock);radix_tree_preload_end ();@@ -1279,11 +1287,15 @@ void btrfs_remove_delayed_node(struct btrfs_inode *inode) {struct btrfs_delayed_node *delayed_node; - delayed_node =READ_ONCE (inode->delayed_node); -if (!delayed_node) +spin_lock (&inode->delayed_node_lock); + delayed_node = inode->delayed_node; +if (!delayed_node) { +spin_unlock (&inode->delayed_node_lock);return ; + } inode->delayed_node =NULL ; +spin_unlock (&inode->delayed_node_lock);btrfs_release_delayed_node (delayed_node); }fs/btrfs/inode.c +1
-0@@ -9177,6 +9177,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) ei->last_log_commit =0 ;spin_lock_init (&ei->lock); +spin_lock_init (&ei->delayed_node_lock); ei->outstanding_extents =0 ;if (sb->s_magic !=BTRFS_TEST_MAGIC ) btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,
Quoted 4 lines · Qu Wenruo
In the following case, we could trigger a use-after-free bug:
CPU0 | CPU1
-------------------------------------------------------------------------
Quoted 9 lines
btrfs_remove_delayed_node | btrfs_get_delayed_node
|- delayed_node = | |- node = btrfs_inode->delayed_node;
| btrfs_inode->delayed_node | |
|- btrfs_release_delaedy_node() | |
|- ref_count_dev_and_test() | |
|- kmem_cache_free() | |
Now delayed node is freed | |
| |- refcount_inc(&node->refs)btrfs_remove_delayed_node is called from evict_inode which is called once the inode has been freed and there are no more referencs to this inode (inode->i_count is 0). Also before calling btrfs_remove_delayed_node we have flushed all the pages and ordered extents. So the crucial bit of information missing is what is the higher-level operation that requests the delayed node for a freed inode ?
Quoted 25 lines · Qu Wenruo
In the following case, we could trigger a use-after-free bug:
CPU0 | CPU1
-------------------------------------------------------------------------btrfs_remove_delayed_node | btrfs_get_delayed_node |- delayed_node = | |- node = btrfs_inode->delayed_node; | btrfs_inode->delayed_node | | |- btrfs_release_delaedy_node() | | |- ref_count_dev_and_test() | | |- kmem_cache_free() | | Now delayed node is freed | | | |- refcount_inc(&node->refs)In that case sine
delayed_nodeis using kmem cache, such use-after-free bug won't directly cause problem, but could leads to corrupted data structure of other kmem cache user.Fix it by adding
btrfs_inode::delayed_node_lockto protect such operation.Reported-by sunny.s.zhang <[email protected]>Signed-off-by Qu Wenruo <[email protected]>---
Please don't merge this patch yet.
Quoted 8 lines
The patch caused random slow down for a lot of quick test cases. Old tests can be executed in 1s or so now randomly needs near 20s.
It looks like the
spin_lock()withroot->inode_lockhold is causing the problem but I can't see what's going wrong.
As the operation done with @delayed_node_lock hold is literatly tiny.Any comment on this is welcomed.
I found the original report and discussion, so the resume is that it's possibly caused by the refcount_t rework and the missing fix ec35e48b2869599 .
As in time of evict there can be no active operation running and the crash happened inside atime update. I take the bug in refcounting as a plausible explanation so your patch does not seem to be necessary, unless there's a reproducer on a recent kernel.