4 files changed, 25 insertions, 21 deletions

diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index fca83e28edcf..385bed09b0d8 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -209,7 +209,7 @@ static inline int simple_empty_nolock(struct dentry *dentry)
         struct dentry *child;
         int ret = 0;
 
-        list_for_each_entry(child, &dentry->d_subdirs, d_child)
+        list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
                 if (simple_positive(child))
                         goto out;
         ret = 1;
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index feb6ac427d05..dc39589df165 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -105,7 +105,7 @@ repeat:
         next = this_parent->d_subdirs.next;
 resume:
         while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_child);
+                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - give up */
                 if (!simple_positive(dentry)) {
@@ -138,7 +138,7 @@ resume:
         }
 
         if (this_parent != top) {
-                next = this_parent->d_child.next;
+                next = this_parent->d_u.d_child.next;
                 this_parent = this_parent->d_parent;
                 goto resume;
         }
@@ -163,7 +163,7 @@ repeat:
         next = this_parent->d_subdirs.next;
 resume:
         while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_child);
+                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - give up */
                 if (!simple_positive(dentry)) {
@@ -199,7 +199,7 @@ cont:
         }
 
         if (this_parent != parent) {
-                next = this_parent->d_child.next;
+                next = this_parent->d_u.d_child.next;
                 this_parent = this_parent->d_parent;
                 goto resume;
         }
@@ -238,7 +238,7 @@ static struct dentry *autofs4_expire(struct super_block *sb,
         /* On exit from the loop expire is set to a dgot dentry
          * to expire or it's NULL */
         while ( next != &root->d_subdirs ) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_child);
+                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - give up */
                 if ( !simple_positive(dentry) ) {
@@ -302,7 +302,7 @@ next:
                         expired, (int)expired->d_name.len, expired->d_name.name);
                 spin_lock(&dcache_lock);
                 list_del(&expired->d_parent->d_subdirs);
-                list_add(&expired->d_parent->d_subdirs, &expired->d_child);
+                list_add(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
                 spin_unlock(&dcache_lock);
                 return expired;
         }
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 818b37be5153..2d3082854a29 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -91,7 +91,7 @@ repeat:
         next = this_parent->d_subdirs.next;
 resume:
         while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_child);
+                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - don`t care */
                 if (!simple_positive(dentry)) {
@@ -117,7 +117,7 @@ resume:
         if (this_parent != sbi->root) {
                 struct dentry *dentry = this_parent;
 
-                next = this_parent->d_child.next;
+                next = this_parent->d_u.d_child.next;
                 this_parent = this_parent->d_parent;
                 spin_unlock(&dcache_lock);
                 DPRINTK("parent dentry %p %.*s",
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 2a771ec66956..62d8d4acb8bb 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -12,6 +12,7 @@
  *
  * ------------------------------------------------------------------------- */
 
+#include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/stat.h>
 #include <linux/param.h>
@@ -86,7 +87,7 @@ static int autofs4_root_readdir(struct file *file, void *dirent,
 
 /* Update usage from here to top of tree, so that scan of
    top-level directories will give a useful result */
-static void autofs4_update_usage(struct dentry *dentry)
+static void autofs4_update_usage(struct vfsmount *mnt, struct dentry *dentry)
 {
         struct dentry *top = dentry->d_sb->s_root;
 
@@ -95,7 +96,7 @@ static void autofs4_update_usage(struct dentry *dentry)
                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
 
                 if (ino) {
-                        update_atime(dentry->d_inode);
+                        touch_atime(mnt, dentry);
                         ino->last_used = jiffies;
                 }
         }
@@ -143,7 +144,8 @@ static int autofs4_dcache_readdir(struct file * filp, void * dirent, filldir_t f
                         }
 
                         while(1) {
-                                struct dentry *de = list_entry(list, struct dentry, d_child);
+                                struct dentry *de = list_entry(list,
+                                                struct dentry, d_u.d_child);
 
                                 if (!d_unhashed(de) && de->d_inode) {
                                         spin_unlock(&dcache_lock);
@@ -193,6 +195,8 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
                 if (!empty)
                         d_invalidate(dentry);
 
+                nd.dentry = dentry;
+                nd.mnt = mnt;
                 nd.flags = LOOKUP_DIRECTORY;
                 status = (dentry->d_op->d_revalidate)(dentry, &nd);
 
@@ -288,10 +292,10 @@ out:
         return autofs4_dcache_readdir(file, dirent, filldir);
 }
 
-static int try_to_fill_dentry(struct dentry *dentry, 
-                              struct super_block *sb,
-                              struct autofs_sb_info *sbi, int flags)
+static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int flags)
 {
+        struct super_block *sb = mnt->mnt_sb;
+        struct autofs_sb_info *sbi = autofs4_sbi(sb);
         struct autofs_info *de_info = autofs4_dentry_ino(dentry);
         int status = 0;
 
@@ -366,7 +370,7 @@ static int try_to_fill_dentry(struct dentry *dentry,
         /* We don't update the usages for the autofs daemon itself, this
            is necessary for recursive autofs mounts */
         if (!autofs4_oz_mode(sbi))
-                autofs4_update_usage(dentry);
+                autofs4_update_usage(mnt, dentry);
 
         spin_lock(&dentry->d_lock);
         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
@@ -391,7 +395,7 @@ static int autofs4_revalidate(struct dentry * dentry, struct nameidata *nd)
         /* Pending dentry */
         if (autofs4_ispending(dentry)) {
                 if (!oz_mode)
-                        status = try_to_fill_dentry(dentry, dir->i_sb, sbi, flags);
+                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
                 return status;
         }
 
@@ -408,14 +412,14 @@ static int autofs4_revalidate(struct dentry * dentry, struct nameidata *nd)
                          dentry, dentry->d_name.len, dentry->d_name.name);
                 spin_unlock(&dcache_lock);
                 if (!oz_mode)
-                        status = try_to_fill_dentry(dentry, dir->i_sb, sbi, flags);
+                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
                 return status;
         }
         spin_unlock(&dcache_lock);
 
         /* Update the usage list */
         if (!oz_mode)
-                autofs4_update_usage(dentry);
+                autofs4_update_usage(nd->mnt, dentry);
 
         return 1;
 }
@@ -488,9 +492,9 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
         d_add(dentry, NULL);
 
         if (dentry->d_op && dentry->d_op->d_revalidate) {
-                up(&dir->i_sem);
+                mutex_unlock(&dir->i_mutex);
                 (dentry->d_op->d_revalidate)(dentry, nd);
-                down(&dir->i_sem);
+                mutex_lock(&dir->i_mutex);
         }
 
         /*