Unverified Commit eb7e453a authored by Mateusz Guzik's avatar Mateusz Guzik Committed by Christian Brauner
Browse files

fs: drop the lock trip around I_NEW wake up in evict() 



The unhashed state check in __wait_on_freeing_inode() performed with
->i_lock held against remove_hash_inode() also holding the lock makes
another lock acquire in evict() completely spurious -- all potential
sleepers already dropped the lock before remove_hash_inode() acquired
it or they found the inode to be unhashed and aborted.

Note there is no trickery here: the usual cost of both sides taking
locks is still being paid, it just stops being paid twice.

Signed-off-by: default avatarMateusz Guzik <mjguzik@gmail.com>
Link: https://lore.kernel.org/r/20250317160707.1694135-1-mjguzik@gmail.com


Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 008a746a

fs/inode.c

+6 −13
Original line number Diff line number Diff line
@@ -816,23 +816,16 @@ static void evict(struct inode *inode) 
	/*

	 * Wake up waiters in __wait_on_freeing_inode().

	 *

	 * Lockless hash lookup may end up finding the inode before we removed

	 * it above, but only lock it *after* we are done with the wakeup below.

	 * In this case the potential waiter cannot safely block.

	 * It is an invariant that any thread we need to wake up is already

	 * accounted for before remove_inode_hash() acquires ->i_lock -- both

	 * sides take the lock and sleep is aborted if the inode is found

	 * unhashed. Thus either the sleeper wins and goes off CPU, or removal

	 * wins and the sleeper aborts after testing with the lock.

	 *

	 * The inode being unhashed after the call to remove_inode_hash() is

	 * used as an indicator whether blocking on it is safe.

	 * This also means we don't need any fences for the call below.

	 */

	spin_lock(&inode->i_lock);

	/*

	 * Pairs with the barrier in prepare_to_wait_event() to make sure

	 * ___wait_var_event() either sees the bit cleared or

	 * waitqueue_active() check in wake_up_var() sees the waiter.

	 */

	smp_mb__after_spinlock();

	inode_wake_up_bit(inode, __I_NEW);

	BUG_ON(inode->i_state != (I_FREEING | I_CLEAR));

	spin_unlock(&inode->i_lock);



	destroy_inode(inode);

}