merge d_materialise_unique() into d_splice_alias()

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 35 insertions, 108 deletions

diff --git a/fs/dcache.c b/fs/dcache.c
index e605e90d0f0a..435991eada1e 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2575,11 +2575,11 @@ struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2)
  * Note: If ever the locking in lock_rename() changes, then please
  * remember to update this too...
  */
-static struct dentry *__d_unalias(struct inode *inode,
+static int __d_unalias(struct inode *inode,
                 struct dentry *dentry, struct dentry *alias)
 {
         struct mutex *m1 = NULL, *m2 = NULL;
-        struct dentry *ret = ERR_PTR(-EBUSY);
+        int ret = -EBUSY;
 
         /* If alias and dentry share a parent, then no extra locks required */
         if (alias->d_parent == dentry->d_parent)
@@ -2594,7 +2594,7 @@ static struct dentry *__d_unalias(struct inode *inode,
         m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
         __d_move(alias, dentry, false);
-        ret = alias;
+        ret = 0;
 out_err:
         spin_unlock(&inode->i_lock);
         if (m2)
@@ -2629,130 +2629,57 @@ out_err:
  */
 struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 {
-        struct dentry *new = NULL;
-
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
-        if (inode && S_ISDIR(inode->i_mode)) {
-                spin_lock(&inode->i_lock);
-                new = __d_find_any_alias(inode);
-                if (new) {
-                        if (!IS_ROOT(new)) {
-                                spin_unlock(&inode->i_lock);
-                                dput(new);
-                                iput(inode);
-                                return ERR_PTR(-EIO);
-                        }
-                        if (d_ancestor(new, dentry)) {
-                                spin_unlock(&inode->i_lock);
-                                dput(new);
-                                iput(inode);
-                                return ERR_PTR(-EIO);
-                        }
-                        write_seqlock(&rename_lock);
-                        __d_move(new, dentry, false);
-                        write_sequnlock(&rename_lock);
-                        spin_unlock(&inode->i_lock);
-                        security_d_instantiate(new, inode);
-                        iput(inode);
-                } else {
-                        /* already taking inode->i_lock, so d_add() by hand */
-                        __d_instantiate(dentry, inode);
-                        spin_unlock(&inode->i_lock);
-                        security_d_instantiate(dentry, inode);
-                        d_rehash(dentry);
-                }
-        } else {
-                d_instantiate(dentry, inode);
-                if (d_unhashed(dentry))
-                        d_rehash(dentry);
-        }
-        return new;
-}
-EXPORT_SYMBOL(d_splice_alias);
-
-/**
- * d_materialise_unique - introduce an inode into the tree
- * @dentry: candidate dentry
- * @inode: inode to bind to the dentry, to which aliases may be attached
- *
- * Introduces an dentry into the tree, substituting an extant disconnected
- * root directory alias in its place if there is one. Caller must hold the
- * i_mutex of the parent directory.
- */
-struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
-{
-        struct dentry *actual;
-
         BUG_ON(!d_unhashed(dentry));
 
         if (!inode) {
-                actual = dentry;
                 __d_instantiate(dentry, NULL);
-                d_rehash(actual);
-                goto out_nolock;
+                goto out;
         }
-
         spin_lock(&inode->i_lock);
-
         if (S_ISDIR(inode->i_mode)) {
-                struct dentry *alias;
-
-                /* Does an aliased dentry already exist? */
-                alias = __d_find_alias(inode);
-                if (alias) {
-                        actual = alias;
+                struct dentry *new = __d_find_any_alias(inode);
+                if (unlikely(new)) {
                         write_seqlock(&rename_lock);
-
-                        if (d_ancestor(alias, dentry)) {
-                                /* Check for loops */
-                                actual = ERR_PTR(-ELOOP);
+                        if (unlikely(d_ancestor(new, dentry))) {
+                                write_sequnlock(&rename_lock);
                                 spin_unlock(&inode->i_lock);
-                        } else if (IS_ROOT(alias)) {
-                                /* Is this an anonymous mountpoint that we
-                                 * could splice into our tree? */
-                                __d_move(alias, dentry, false);
+                                dput(new);
+                                new = ERR_PTR(-ELOOP);
+                                pr_warn_ratelimited(
+                                        "VFS: Lookup of '%s' in %s %s"
+                                        " would have caused loop\n",
+                                        dentry->d_name.name,
+                                        inode->i_sb->s_type->name,
+                                        inode->i_sb->s_id);
+                        } else if (!IS_ROOT(new)) {
+                                int err = __d_unalias(inode, dentry, new);
                                 write_sequnlock(&rename_lock);
-                                goto found;
+                                if (err) {
+                                        dput(new);
+                                        new = ERR_PTR(err);
+                                }
                         } else {
-                                /* Nope, but we must(!) avoid directory
-                                 * aliasing. This drops inode->i_lock */
-                                actual = __d_unalias(inode, dentry, alias);
-                        }
-                        write_sequnlock(&rename_lock);
-                        if (IS_ERR(actual)) {
-                                if (PTR_ERR(actual) == -ELOOP)
-                                        pr_warn_ratelimited(
-                                                "VFS: Lookup of '%s' in %s %s"
-                                                " would have caused loop\n",
-                                                dentry->d_name.name,
-                                                inode->i_sb->s_type->name,
-                                                inode->i_sb->s_id);
-                                dput(alias);
+                                __d_move(new, dentry, false);
+                                write_sequnlock(&rename_lock);
+                                spin_unlock(&inode->i_lock);
+                                security_d_instantiate(new, inode);
                         }
-                        goto out_nolock;
+                        iput(inode);
+                        return new;
                 }
         }
-
-        /* Add a unique reference */
-        actual = __d_instantiate_unique(dentry, inode);
-        if (!actual)
-                actual = dentry;
-
-        d_rehash(actual);
-found:
+        /* already taking inode->i_lock, so d_add() by hand */
+        __d_instantiate(dentry, inode);
         spin_unlock(&inode->i_lock);
-out_nolock:
-        if (actual == dentry) {
-                security_d_instantiate(dentry, inode);
-                return NULL;
-        }
-
-        iput(inode);
-        return actual;
+out:
+        security_d_instantiate(dentry, inode);
+        d_rehash(dentry);
+        return NULL;
 }
-EXPORT_SYMBOL_GPL(d_materialise_unique);
+EXPORT_SYMBOL(d_splice_alias);
 
 static int prepend(char **buffer, int *buflen, const char *str, int namelen)
 {