UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

kernfs: use dumber locking for kernfs_find_and_get_node_by_ino() 

kernfs_find_and_get_node_by_ino() uses RCU protection.  It's currently
a bit buggy because it can look up a node which hasn't been activated
yet and thus may end up exposing a node that the kernfs user is still
prepping.

While it can be fixed by pushing it further in the current direction,
it's already complicated and isn't clear whether the complexity is
justified.  The main use of kernfs_find_and_get_node_by_ino() is for
exportfs operations.  They aren't super hot and all the follow-up
operations (e.g. mapping to path) use normal locking anyway.

Let's switch to a dumber locking scheme and protect the lookup with
kernfs_idr_lock.

Signed-off-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
This commit is contained in:
Tejun Heo 2019-11-04 15:54:29 -08:00
parent db53c73a8b
commit b680b08171
2 changed files with 10 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
fs/kernfs/dir.c
View File

@ -508,10 +508,6 @@ void kernfs_put(struct kernfs_node *kn)
struct kernfs_node *parent;
struct kernfs_root *root;
/*
* kernfs_node is freed with ->count 0, kernfs_find_and_get_node_by_ino
* depends on this to filter reused stale node
*/
if (!kn || !atomic_dec_and_test(&kn->count))
return;
root = kernfs_root(kn);
@ -646,11 +642,7 @@ static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root,
kn->id.ino = ret;
kn->id.generation = gen;
/*
* set ino first. This RELEASE is paired with atomic_inc_not_zero in
* kernfs_find_and_get_node_by_ino
*/
atomic_set_release(&kn->count, 1);
atomic_set(&kn->count, 1);
atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
RB_CLEAR_NODE(&kn->rb);
@ -716,38 +708,19 @@ struct kernfs_node *kernfs_find_and_get_node_by_ino(struct kernfs_root *root,
{
struct kernfs_node *kn;
rcu_read_lock();
spin_lock(&kernfs_idr_lock);
kn = idr_find(&root->ino_idr, ino);
if (!kn)
goto out;
goto err_unlock;
/*
* Since kernfs_node is freed in RCU, it's possible an old node for ino
* is freed, but reused before RCU grace period. But a freed node (see
* kernfs_put) or an incompletedly initialized node (see
* __kernfs_new_node) should have 'count' 0. We can use this fact to
* filter out such node.
*/
if (!atomic_inc_not_zero(&kn->count)) {
kn = NULL;
goto out;
}
/*
* The node could be a new node or a reused node. If it's a new node,
* we are ok. If it's reused because of RCU (because of
* SLAB_TYPESAFE_BY_RCU), the __kernfs_new_node always sets its 'ino'
* before 'count'. So if 'count' is uptodate, 'ino' should be uptodate,
* hence we can use 'ino' to filter stale node.
*/
if (kn->id.ino != ino)
goto out;
rcu_read_unlock();
if (unlikely(!atomic_inc_not_zero(&kn->count)))
goto err_unlock;
spin_unlock(&kernfs_idr_lock);
return kn;
out:
rcu_read_unlock();
kernfs_put(kn);
err_unlock:
spin_unlock(&kernfs_idr_lock);
return NULL;
}

11
fs/kernfs/mount.c
View File

@ -363,18 +363,9 @@ void kernfs_kill_sb(struct super_block *sb)
void __init kernfs_init(void)
{
/*
* the slab is freed in RCU context, so kernfs_find_and_get_node_by_ino
* can access the slab lock free. This could introduce stale nodes,
* please see how kernfs_find_and_get_node_by_ino filters out stale
* nodes.
*/
kernfs_node_cache = kmem_cache_create("kernfs_node_cache",
sizeof(struct kernfs_node),
0,
SLAB_PANIC | SLAB_TYPESAFE_BY_RCU,
NULL);
0, SLAB_PANIC, NULL);
/* Creates slab cache for kernfs inode attributes */
kernfs_iattrs_cache = kmem_cache_create("kernfs_iattrs_cache",