On Mon, Jul 04, 2022 at 12:16:24PM -0700, Linus Torvalds wrote:
> On Mon, Jul 4, 2022 at 12:03 PM Al Viro <viro@xxxxxxxxxxxxxxxxxx> wrote:
> >
> > Anyway, I've thrown a mount_lock check in there, running xfstests to
> > see how it goes...
>
> So my reaction had been that it would be good to just do something like this:
>
> diff --git a/fs/namei.c b/fs/namei.c
> index 1f28d3f463c3..25c4bcc91142 100644
> --- a/fs/namei.c
> +++ b/fs/namei.c
> @@ -1493,11 +1493,18 @@ static bool __follow_mount_rcu(struct n...
> if (flags & DCACHE_MOUNTED) {
> struct mount *mounted = __lookup_mnt(path->mnt, dentry);
> if (mounted) {
> + struct dentry *old_dentry = dentry;
> + unsigned old_seq = *seqp;
> +
> path->mnt = &mounted->mnt;
> dentry = path->dentry = mounted->mnt.mnt_root;
> nd->state |= ND_JUMPED;
> *seqp = read_seqcount_begin(&dentry->d_seq);
> *inode = dentry->d_inode;
> +
> + if (read_seqcount_retry(&old_dentry->d_seq, old_seq))
> + return false;
> +
> /*
> * We don't need to re-check ->d_seq after this
> * ->d_inode read - there will be an RCU delay
>
> but the above is just whitespace-damaged random monkey-scribbling by
> yours truly.
>
> More like a "shouldn't we do something like this" than a serious
> patch, in other words.
>
> IOW, it has *NOT* had a lot of real thought behind it. Purely a
> "shouldn't we always clearly check the old sequence number after we've
> picked up the new one?"
You are checking the wrong thing here. It's really about mount_lock -
->d_seq is *not* bumped when we or attach in some namespace. If there's
a mismatch, RCU pathwalk is doomed anyway (it'll fail any form of unlazy)
and we might as well bugger off. If it *does* match, we know that both
mountpoint and root had been pinned since before the pathwalk, remain
pinned as of that check and had a mount connecting them all along.
IOW, if we could have arrived to this dentry at any point, we would have
gotten that dentry as the next step.
We sample into nd->m_seq in path_init() and we want it to stay unchanged
all along. If it does, all mountpoints and roots we observe are pinned
and their association with each other is stable.
It's not dentry -> dentry, it's dentry -> mount -> dentry. The following
would've been safe:
find mountpoint
sample ->d_seq
verify whatever had lead us to mountpoint
sample mount_lock
find mount
verify mountpoint's ->d_seq
find root of mounted
sample its ->d_seq
verify mount_lock
Correct? Now, note that the last step done against the value we'd sampled
in path_init() guarantees that mount hash had not changed through all of
that. Which is to say, we can pretend that we'd found mount before ->d_seq
of mountpoint might've changed, leaving us with
find mountpoint
sample ->d_seq
verify whatever had lead us to mountpoint
find mount
find root of mounted
sample its ->d_seq
verify mount_lock
