1 files changed, 46 insertions, 72 deletions

diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index edf5b6bddb52..9ead2279df4f 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -493,10 +493,10 @@ void autofs4_dentry_release(struct dentry *de)
                 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);
 
                 if (sbi) {
-                        spin_lock(&sbi->rehash_lock);
-                        if (!list_empty(&inf->rehash))
-                                list_del(&inf->rehash);
-                        spin_unlock(&sbi->rehash_lock);
+                        spin_lock(&sbi->lookup_lock);
+                        if (!list_empty(&inf->expiring))
+                                list_del(&inf->expiring);
+                        spin_unlock(&sbi->lookup_lock);
                 }
 
                 inf->dentry = NULL;
@@ -518,7 +518,7 @@ static struct dentry_operations autofs4_dentry_operations = {
         .d_release      = autofs4_dentry_release,
 };
 
-static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct dentry *parent, struct qstr *name)
+static struct dentry *autofs4_lookup_expiring(struct autofs_sb_info *sbi, struct dentry *parent, struct qstr *name)
 {
         unsigned int len = name->len;
         unsigned int hash = name->hash;
@@ -526,14 +526,14 @@ static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct
         struct list_head *p, *head;
 
         spin_lock(&dcache_lock);
-        spin_lock(&sbi->rehash_lock);
-        head = &sbi->rehash_list;
+        spin_lock(&sbi->lookup_lock);
+        head = &sbi->expiring_list;
         list_for_each(p, head) {
                 struct autofs_info *ino;
                 struct dentry *dentry;
                 struct qstr *qstr;
 
-                ino = list_entry(p, struct autofs_info, rehash);
+                ino = list_entry(p, struct autofs_info, expiring);
                 dentry = ino->dentry;
 
                 spin_lock(&dentry->d_lock);
@@ -555,33 +555,16 @@ static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct
                         goto next;
 
                 if (d_unhashed(dentry)) {
-                        struct inode *inode = dentry->d_inode;
-
-                        ino = autofs4_dentry_ino(dentry);
-                        list_del_init(&ino->rehash);
                         dget(dentry);
-                        /*
-                         * Make the rehashed dentry negative so the VFS
-                         * behaves as it should.
-                         */
-                        if (inode) {
-                                dentry->d_inode = NULL;
-                                list_del_init(&dentry->d_alias);
-                                spin_unlock(&dentry->d_lock);
-                                spin_unlock(&sbi->rehash_lock);
-                                spin_unlock(&dcache_lock);
-                                iput(inode);
-                                return dentry;
-                        }
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&sbi->rehash_lock);
+                        spin_unlock(&sbi->lookup_lock);
                         spin_unlock(&dcache_lock);
                         return dentry;
                 }
 next:
                 spin_unlock(&dentry->d_lock);
         }
-        spin_unlock(&sbi->rehash_lock);
+        spin_unlock(&sbi->lookup_lock);
         spin_unlock(&dcache_lock);
 
         return NULL;
@@ -591,7 +574,7 @@ next:
 static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 {
         struct autofs_sb_info *sbi;
-        struct dentry *unhashed;
+        struct dentry *expiring;
         int oz_mode;
 
         DPRINTK("name = %.*s",
@@ -607,44 +590,44 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
         DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
                  current->pid, task_pgrp_nr(current), sbi->catatonic, oz_mode);
 
-        unhashed = autofs4_lookup_unhashed(sbi, dentry->d_parent, &dentry->d_name);
-        if (!unhashed) {
-                /*
-                 * Mark the dentry incomplete but don't hash it. We do this
-                 * to serialize our inode creation operations (symlink and
-                 * mkdir) which prevents deadlock during the callback to
-                 * the daemon. Subsequent user space lookups for the same
-                 * dentry are placed on the wait queue while the daemon
-                 * itself is allowed passage unresticted so the create
-                 * operation itself can then hash the dentry. Finally,
-                 * we check for the hashed dentry and return the newly
-                 * hashed dentry.
-                 */
-                dentry->d_op = &autofs4_root_dentry_operations;
-
-                dentry->d_fsdata = NULL;
-                d_instantiate(dentry, NULL);
-        } else {
-                struct autofs_info *ino = autofs4_dentry_ino(unhashed);
-                DPRINTK("rehash %p with %p", dentry, unhashed);
+        expiring = autofs4_lookup_expiring(sbi, dentry->d_parent, &dentry->d_name);
+        if (expiring) {
+                struct autofs_info *ino = autofs4_dentry_ino(expiring);
                 /*
                  * If we are racing with expire the request might not
                  * be quite complete but the directory has been removed
                  * so it must have been successful, so just wait for it.
-                 * We need to ensure the AUTOFS_INF_EXPIRING flag is clear
-                 * before continuing as revalidate may fail when calling
-                 * try_to_fill_dentry (returning EAGAIN) if we don't.
                  */
                 while (ino && (ino->flags & AUTOFS_INF_EXPIRING)) {
                         DPRINTK("wait for incomplete expire %p name=%.*s",
-                                unhashed, unhashed->d_name.len,
-                                unhashed->d_name.name);
-                        autofs4_wait(sbi, unhashed, NFY_NONE);
+                                expiring, expiring->d_name.len,
+                                expiring->d_name.name);
+                        autofs4_wait(sbi, expiring, NFY_NONE);
                         DPRINTK("request completed");
                 }
-                dentry = unhashed;
+                spin_lock(&sbi->lookup_lock);
+                if (!list_empty(&ino->expiring))
+                        list_del_init(&ino->expiring);
+                spin_unlock(&sbi->lookup_lock);
+                dput(expiring);
         }
 
+        /*
+         * Mark the dentry incomplete but don't hash it. We do this
+         * to serialize our inode creation operations (symlink and
+         * mkdir) which prevents deadlock during the callback to
+         * the daemon. Subsequent user space lookups for the same
+         * dentry are placed on the wait queue while the daemon
+         * itself is allowed passage unresticted so the create
+         * operation itself can then hash the dentry. Finally,
+         * we check for the hashed dentry and return the newly
+         * hashed dentry.
+         */
+        dentry->d_op = &autofs4_root_dentry_operations;
+
+        dentry->d_fsdata = NULL;
+        d_instantiate(dentry, NULL);
+
         if (!oz_mode) {
                 spin_lock(&dentry->d_lock);
                 dentry->d_flags |= DCACHE_AUTOFS_PENDING;
@@ -668,8 +651,6 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
                         if (sigismember (sigset, SIGKILL) ||
                             sigismember (sigset, SIGQUIT) ||
                             sigismember (sigset, SIGINT)) {
-                            if (unhashed)
-                                dput(unhashed);
                             return ERR_PTR(-ERESTARTNOINTR);
                         }
                 }
@@ -699,15 +680,9 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
                 else
                         dentry = ERR_PTR(-ENOENT);
 
-                if (unhashed)
-                        dput(unhashed);
-
                 return dentry;
         }
 
-        if (unhashed)
-                return dentry;
-
         return NULL;
 }
 
@@ -769,9 +744,8 @@ static int autofs4_dir_symlink(struct inode *dir,
  * that the file no longer exists. However, doing that means that the
  * VFS layer can turn the dentry into a negative dentry.  We don't want
  * this, because the unlink is probably the result of an expire.
- * We simply d_drop it and add it to a rehash candidates list in the
- * super block, which allows the dentry lookup to reuse it retaining
- * the flags, such as expire in progress, in case we're racing with expire.
+ * We simply d_drop it and add it to a expiring list in the super block,
+ * which allows the dentry lookup to check for an incomplete expire.
  *
  * If a process is blocked on the dentry waiting for the expire to finish,
  * it will invalidate the dentry and try to mount with a new one.
@@ -801,9 +775,9 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
         dir->i_mtime = CURRENT_TIME;
 
         spin_lock(&dcache_lock);
-        spin_lock(&sbi->rehash_lock);
-        list_add(&ino->rehash, &sbi->rehash_list);
-        spin_unlock(&sbi->rehash_lock);
+        spin_lock(&sbi->lookup_lock);
+        list_add(&ino->expiring, &sbi->expiring_list);
+        spin_unlock(&sbi->lookup_lock);
         spin_lock(&dentry->d_lock);
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
@@ -829,9 +803,9 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
                 spin_unlock(&dcache_lock);
                 return -ENOTEMPTY;
         }
-        spin_lock(&sbi->rehash_lock);
-        list_add(&ino->rehash, &sbi->rehash_list);
-        spin_unlock(&sbi->rehash_lock);
+        spin_lock(&sbi->lookup_lock);
+        list_add(&ino->expiring, &sbi->expiring_list);
+        spin_unlock(&sbi->lookup_lock);
         spin_lock(&dentry->d_lock);
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);