Linux filesystem development
 help / color / mirror / Atom feed
From: Al Viro <viro@zeniv.linux.org.uk>
To: Jori Koolstra <jkoolstra@xs4all.nl>,
	Linus Torvalds <torvalds@linux-foundation.org>,
	linux-fsdevel@vger.kernel.org,
	Christian Brauner <brauner@kernel.org>, Jan Kara <jack@suse.cz>,
	NeilBrown <neil@brown.name>
Subject: Re: [RFC PATCH 21/25] shrinking rcu_read_lock() scope in d_alloc_parallel()
Date: Fri, 8 May 2026 04:12:35 +0100	[thread overview]
Message-ID: <20260508031235.GA2636677@ZenIV> (raw)
In-Reply-To: <af0F6BwrJRxMMKMT@lt-jori.localdomain>

On Thu, May 07, 2026 at 11:52:21PM +0200, Jori Koolstra wrote:
> > 	If no match is found, we proceed to lock the hash chain of
> > in-lookup hash and scan that for a match.  If we find a match, we want
> > to grab it and wait for lookup in progress to finish.  Since the bitlock
> > we use for these hash chains has to nest inside ->d_lock, we need to
> > unlock the chain first and use lockref_get_not_dead() on the match.
> 
> Just curious, reading this code as someone fairly new to the kernel,
> how can I know what is the agreed-upon lock order between these hash
> chains and the d_locks of the dentries they contain?

Either wait for documentation to get there, or look at the places where
we deal with those locks; in particular, the removal from the in-lookup
hash chain comes in __d_lookup_unhash():
        hlist_bl_lock(b);
	dentry->d_flags &= ~DCACHE_PAR_LOOKUP;
	__hlist_bl_del(&dentry->d_in_lookup_hash);
	hlist_bl_unlock(b);
with callers of that thing all done under ->d_lock.  And yes, we *do*
need to document that shite - no arguments here.

> > 	That makes the entire thing easier to follow and the purpose
> > of those rcu_read_lock() calls easier to describe - the first scope is
> > for __d_lookup_rcu() + lockref_get_not_dead(), the second one bridges
> > over from the bitlock scope to the ->d_lock scope on the match found in
> > in-lookup hash.
> 
> Because the dentry could be freed after the hash chain unlock and before
> grabbing the d_lock?

Yes.  It's a bit more complicated - the missing bit is "and dentry we might
find in the in-lookup hash is not going to be NORCU, so freeing is guaranteed
to be RCU-delayed".

> I do think the hlist_bl_for_each_entry loop would read clearer if we
> pull the code after having found the initial match out of it, since we
> always exit the loop afterwards.

Umm...  Not sure - we'd need to distinguish between "no match found" and "got
a match, stopped looking" cases.  Would have to be something like
	if (!pos)
		insert into hash
	ele
		dentry is a match, deal with it
which is more reliant upon the details of hlist_bl_for_each_entry than I'd like...

  reply	other threads:[~2026-05-08  3:12 UTC|newest]

Thread overview: 53+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-05-05  5:53 [RFC PATCH 00/25] assorted dcache cleanups and fixes Al Viro
2026-05-05  5:53 ` [RFC PATCH 01/25] VFS: use wait_var_event for waiting in d_alloc_parallel() Al Viro
2026-05-05  5:53 ` [RFC PATCH 02/25] alloc_path_pseudo(): make sure we don't end up with NORCU dentries for directories Al Viro
2026-05-05  8:21   ` NeilBrown
2026-05-05 17:48     ` Al Viro
2026-05-05  5:53 ` [RFC PATCH 03/25] fix a race between d_find_any_alias() and final dput() of NORCU dentries Al Viro
2026-05-05 17:06   ` Linus Torvalds
2026-05-05 20:29     ` Al Viro
2026-05-05  5:53 ` [RFC PATCH 04/25] find_acceptable_alias(): skip NORCU aliases with zero refcount Al Viro
2026-05-05  5:53 ` [RFC PATCH 05/25] select_collect(): ignore dentries on shrink lists if they have positive refcounts Al Viro
2026-05-05  5:53 ` [RFC PATCH 06/25] make to_shrink_list() return whether it has moved dentry to list Al Viro
2026-05-05  5:53 ` [RFC PATCH 07/25] kill d_dispose_if_unused() Al Viro
2026-05-05  5:53 ` [RFC PATCH 08/25] d_prune_aliases(): make sure to skip NORCU aliases Al Viro
2026-05-05  5:53 ` [RFC PATCH 09/25] shrink_dentry_list(): start with removing from shrink list Al Viro
2026-05-07 20:39   ` Al Viro
2026-05-05  5:53 ` [RFC PATCH 10/25] fold lock_for_kill() into shrink_kill() Al Viro
2026-05-05  5:53 ` [RFC PATCH 11/25] fold lock_for_kill() and __dentry_kill() into common helper Al Viro
2026-05-05  5:53 ` [RFC PATCH 12/25] reducing rcu_read_lock() scopes in dput and friends, step 1 Al Viro
2026-05-05  8:55   ` NeilBrown
2026-05-05 14:22     ` Al Viro
2026-05-05 21:58       ` NeilBrown
2026-05-05 16:47   ` Linus Torvalds
2026-05-05 22:42     ` Al Viro
2026-05-07  7:35       ` Al Viro
2026-05-07 15:32         ` Linus Torvalds
2026-05-05  5:54 ` [RFC PATCH 13/25] reducing rcu_read_lock() scopes in dput and friends, step 2 Al Viro
2026-05-05  5:54 ` [RFC PATCH 14/25] reducing rcu_read_lock() scopes in dput and friends, step 3 Al Viro
2026-05-05  5:54 ` [RFC PATCH 15/25] reducing rcu_read_lock() scopes in dput and friends, step 4 Al Viro
2026-05-05  5:54 ` [RFC PATCH 16/25] reducing rcu_read_lock() scopes in dput and friends, step 5 Al Viro
2026-05-05  5:54 ` [RFC PATCH 17/25] reducing rcu_read_lock() scopes in dput and friends, step 6 Al Viro
2026-05-05  5:54 ` [RFC PATCH 18/25] adjust calling conventions of lock_for_kill(), fold __dentry_kill() into dentry_kill() Al Viro
2026-05-05  5:54 ` [RFC PATCH 19/25] document dentry_kill() Al Viro
2026-05-05  5:54 ` [RFC PATCH 20/25] d_walk(): shrink rcu_read_lock() scope Al Viro
2026-05-05 17:01   ` Linus Torvalds
2026-05-05 20:05     ` Al Viro
2026-05-05 21:40       ` Frederic Weisbecker
2026-05-05 22:50         ` Al Viro
2026-05-06  3:49           ` Paul E. McKenney
2026-05-07 22:39             ` NeilBrown
2026-05-07 23:21               ` Paul E. McKenney
2026-05-08 14:47                 ` Al Viro
2026-05-08 22:03                   ` Paul E. McKenney
2026-05-08 23:03                     ` Al Viro
2026-05-08  3:01         ` Al Viro
2026-05-05  5:54 ` [RFC PATCH 21/25] shrinking rcu_read_lock() scope in d_alloc_parallel() Al Viro
2026-05-07 21:52   ` Jori Koolstra
2026-05-08  3:12     ` Al Viro [this message]
2026-05-08  9:28       ` Jori Koolstra
2026-05-05  5:54 ` [RFC PATCH 22/25] shrink_dentry_tree(): unify the calls of shrink_dentry_list() Al Viro
2026-05-05  5:54 ` [RFC PATCH 23/25] wind ->s_roots via ->d_sib instead of ->d_hash Al Viro
2026-05-05  5:54 ` [RFC PATCH 24/25] nfs: get rid of fake root dentries Al Viro
2026-05-05  5:54 ` [RFC PATCH 25/25] make cursors NORCU Al Viro
2026-05-05 17:09 ` [RFC PATCH 00/25] assorted dcache cleanups and fixes Linus Torvalds

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20260508031235.GA2636677@ZenIV \
    --to=viro@zeniv.linux.org.uk \
    --cc=brauner@kernel.org \
    --cc=jack@suse.cz \
    --cc=jkoolstra@xs4all.nl \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=neil@brown.name \
    --cc=torvalds@linux-foundation.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox