Commit b680b081 authored by Tejun Heo's avatar Tejun Heo
Browse files

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: default avatarTejun Heo <tj@kernel.org>
Reviewed-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
parent db53c73a

fs/kernfs/dir.c

+9 −36
Original line number Diff line number Diff line
@@ -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;

}

fs/kernfs/mount.c

+1 −10
Original line number Diff line number Diff line
@@ -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",

CRA Git | Maintained and supported by SUSTech CRA and CCSE