1 files changed, 49 insertions, 30 deletions

diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 30cc9ddf4b70..40ca9360caef 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -17,8 +17,11 @@
 #include <linux/stat.h>
 #include <linux/param.h>
 #include <linux/time.h>
+#include <linux/spinlock.h>
 #include "autofs_i.h"
 
+DEFINE_SPINLOCK(autofs4_lock);
+
 static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
 static int autofs4_dir_unlink(struct inode *,struct dentry *);
 static int autofs4_dir_rmdir(struct inode *,struct dentry *);
@@ -225,12 +228,15 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
          * autofs file system so just let the libfs routines handle
          * it.
          */
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&dentry->d_lock);
         if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&autofs4_lock);
                 return -ENOENT;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&autofs4_lock);
 
 out:
         return dcache_dir_open(inode, file);
@@ -299,9 +305,9 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
         /* We trigger a mount for almost all flags */
         lookup_type = autofs4_need_mount(nd->flags);
         spin_lock(&sbi->fs_lock);
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         if (!(lookup_type || ino->flags & AUTOFS_INF_PENDING)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&autofs4_lock);
                 spin_unlock(&sbi->fs_lock);
                 goto follow;
         }
@@ -311,10 +317,11 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
          * multi-mount with no root mount offset. So don't try to
          * mount it again.
          */
+        spin_lock(&dentry->d_lock);
         if (ino->flags & AUTOFS_INF_PENDING ||
             (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs))) {
                 ino->flags |= AUTOFS_INF_PENDING;
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
                 spin_unlock(&sbi->fs_lock);
 
                 status = try_to_fill_dentry(dentry);
@@ -322,14 +329,16 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
                 spin_lock(&sbi->fs_lock);
                 ino->flags &= ~AUTOFS_INF_PENDING;
                 spin_unlock(&sbi->fs_lock);
+                spin_unlock(&autofs4_lock);
 
                 if (status)
                         goto out_error;
 
                 goto follow;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
         spin_unlock(&sbi->fs_lock);
+        spin_unlock(&autofs4_lock);
 follow:
         /*
          * If there is no root mount it must be an autofs
@@ -380,7 +389,7 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
         mutex_aquired = mutex_trylock(&dir->i_mutex);
 
         spin_lock(&sbi->fs_lock);
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         /* Pending dentry */
         if (autofs4_ispending(dentry)) {
                 int status;
@@ -394,11 +403,11 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
                 ino->flags |= AUTOFS_INF_PENDING;
                 if (!mutex_aquired) {
                         autofs4_revalidate_drop(dentry, entry);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&autofs4_lock);
                         spin_unlock(&sbi->fs_lock);
                         return 0;
                 }
-                spin_unlock(&dcache_lock);
+                spin_unlock(&autofs4_lock);
                 spin_unlock(&sbi->fs_lock);
                 mutex_unlock(&dir->i_mutex);
                 kfree(entry);
@@ -445,11 +454,11 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
                         ino->flags |= AUTOFS_INF_PENDING;
                         if (!mutex_aquired) {
                                 autofs4_revalidate_drop(dentry, entry);
-                                spin_unlock(&dcache_lock);
+                                spin_unlock(&autofs4_lock);
                                 spin_unlock(&sbi->fs_lock);
                                 return 0;
                         }
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&autofs4_lock);
                         spin_unlock(&sbi->fs_lock);
                         mutex_unlock(&dir->i_mutex);
                         kfree(entry);
@@ -470,7 +479,7 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
                         return status;
                 }
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
         spin_unlock(&sbi->fs_lock);
 
         if (mutex_aquired)
@@ -544,7 +553,7 @@ static struct dentry *autofs4_lookup_active(struct dentry *dentry)
         struct list_head *p, *head;
 
 restart:
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         spin_lock(&sbi->lookup_lock);
         head = &sbi->active_list;
         list_for_each(p, head) {
@@ -558,15 +567,15 @@ restart:
                 spin_lock(&active->d_lock);
 
                 /* Already gone? */
-                if (atomic_read(&active->d_count) == 0)
+                if (atomic_read(&dentry->d_count) == 0)
                         goto next;
 
                 if (active->d_inode && IS_DEADDIR(active->d_inode)) {
                         if (!list_empty(&ino->rehash_list)) {
-                                dget(active);
+                                dget_dlock(active);
                                 spin_unlock(&active->d_lock);
                                 spin_unlock(&sbi->lookup_lock);
-                                spin_unlock(&dcache_lock);
+                                spin_unlock(&autofs4_lock);
                                 autofs4_remove_rehash_entrys(ino);
                                 dput(active);
                                 goto restart;
@@ -586,16 +595,16 @@ restart:
                 if (memcmp(qstr->name, str, len))
                         goto next;
 
-                dget(active);
+                dget_dlock(active);
                 spin_unlock(&active->d_lock);
                 spin_unlock(&sbi->lookup_lock);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&autofs4_lock);
                 return active;
 next:
                 spin_unlock(&active->d_lock);
         }
         spin_unlock(&sbi->lookup_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return NULL;
 }
@@ -610,7 +619,7 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
         const unsigned char *str = name->name;
         struct list_head *p, *head;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         spin_lock(&sbi->lookup_lock);
         head = &sbi->expiring_list;
         list_for_each(p, head) {
@@ -639,16 +648,16 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
                 if (memcmp(qstr->name, str, len))
                         goto next;
 
-                dget(expiring);
+                dget_dlock(expiring);
                 spin_unlock(&expiring->d_lock);
                 spin_unlock(&sbi->lookup_lock);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&autofs4_lock);
                 return expiring;
 next:
                 spin_unlock(&expiring->d_lock);
         }
         spin_unlock(&sbi->lookup_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return NULL;
 }
@@ -909,11 +918,15 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
 
         dir->i_mtime = CURRENT_TIME;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&sbi->lookup_lock);
+        if (list_empty(&ino->expiring))
+                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);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return 0;
 }
@@ -930,15 +943,21 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&sbi->lookup_lock);
+        spin_lock(&dentry->d_lock);
         if (!list_empty(&dentry->d_subdirs)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&sbi->lookup_lock);
+                spin_unlock(&autofs4_lock);
                 return -ENOTEMPTY;
         }
-        spin_lock(&dentry->d_lock);
+        if (list_empty(&ino->expiring))
+                list_add(&ino->expiring, &sbi->expiring_list);
+        spin_unlock(&sbi->lookup_lock);
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         if (atomic_dec_and_test(&ino->count)) {
                 p_ino = autofs4_dentry_ino(dentry->d_parent);