vfs: check unlinked ancestors before mount

We check submounts before doing d_drop() on a non-empty directory dentry in
NFS (have_submounts()), but we do not exclude a racing mount.  Nor do we
prevent mounts to be added to the disconnected subtree using relative paths
after the d_drop().

This patch fixes these issues by checking for unlinked (unhashed, non-root)
ancestors before proceeding with the mount.  This is done with rename
seqlock taken for write and with ->d_lock grabbed on each ancestor in turn,
including our dentry itself.  This ensures that the only one of
check_submounts_and_drop() or has_unlinked_ancestor() can succeed.

Signed-off-by: Miklos Szeredi <miklos@szeredi.hu>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 33 insertions, 0 deletions

diff --git a/fs/dcache.c b/fs/dcache.c
index ce5a7e6d84cd..761e31bacbc2 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1184,6 +1184,39 @@ int have_submounts(struct dentry *parent)
 EXPORT_SYMBOL(have_submounts);
 
 /*
+ * Called by mount code to set a mountpoint and check if the mountpoint is
+ * reachable (e.g. NFS can unhash a directory dentry and then the complete
+ * subtree can become unreachable).
+ *
+ * Only one of check_submounts_and_drop() and d_set_mounted() must succeed.  For
+ * this reason take rename_lock and d_lock on dentry and ancestors.
+ */
+int d_set_mounted(struct dentry *dentry)
+{
+        struct dentry *p;
+        int ret = -ENOENT;
+        write_seqlock(&rename_lock);
+        for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
+                /* Need exclusion wrt. check_submounts_and_drop() */
+                spin_lock(&p->d_lock);
+                if (unlikely(d_unhashed(p))) {
+                        spin_unlock(&p->d_lock);
+                        goto out;
+                }
+                spin_unlock(&p->d_lock);
+        }
+        spin_lock(&dentry->d_lock);
+        if (!d_unlinked(dentry)) {
+                dentry->d_flags |= DCACHE_MOUNTED;
+                ret = 0;
+        }
+        spin_unlock(&dentry->d_lock);
+out:
+        write_sequnlock(&rename_lock);
+        return ret;
+}
+
+/*
  * Search the dentry child list of the specified parent,
  * and move any unused dentries to the end of the unused
  * list for prune_dcache(). We descend to the next level