Merge getxattr prototype change into work.lookups

The rest of work.xattr stuff isn't needed for this branch

93 files changed, 364 insertions, 426 deletions

diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 9da967f38387..eb3589edf485 100644
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -93,7 +93,7 @@ static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
          * instantiating the inode (v9fs_inode_from_fid)
          */
         acl = get_cached_acl(inode, type);
-        BUG_ON(acl == ACL_NOT_CACHED);
+        BUG_ON(is_uncached_acl(acl));
         return acl;
 }
 
@@ -213,8 +213,8 @@ int v9fs_acl_mode(struct inode *dir, umode_t *modep,
 }
 
 static int v9fs_xattr_get_acl(const struct xattr_handler *handler,
-                              struct dentry *dentry, const char *name,
-                              void *buffer, size_t size)
+                              struct dentry *dentry, struct inode *inode,
+                              const char *name, void *buffer, size_t size)
 {
         struct v9fs_session_info *v9ses;
         struct posix_acl *acl;
@@ -227,7 +227,7 @@ static int v9fs_xattr_get_acl(const struct xattr_handler *handler,
         if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
                 return v9fs_xattr_get(dentry, handler->name, buffer, size);
 
-        acl = v9fs_get_cached_acl(d_inode(dentry), handler->flags);
+        acl = v9fs_get_cached_acl(inode, handler->flags);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl == NULL)
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 3a08b3e6ff1d..f4645c515262 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -1071,7 +1071,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         if (IS_ERR(st))
                 return PTR_ERR(st);
 
-        v9fs_stat2inode(st, d_inode(dentry), d_inode(dentry)->i_sb);
+        v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb);
         generic_fillattr(d_inode(dentry), stat);
 
         p9stat_free(st);
diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index 9dd9b47a6c1a..18c62bae9591 100644
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -138,8 +138,8 @@ ssize_t v9fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 }
 
 static int v9fs_xattr_handler_get(const struct xattr_handler *handler,
-                                  struct dentry *dentry, const char *name,
-                                  void *buffer, size_t size)
+                                  struct dentry *dentry, struct inode *inode,
+                                  const char *name, void *buffer, size_t size)
 {
         const char *full_name = xattr_full_name(handler, name);
 
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 103f5d7c3083..72e35b721608 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -106,8 +106,8 @@ static int bad_inode_setxattr(struct dentry *dentry, const char *name,
         return -EIO;
 }
 
-static ssize_t bad_inode_getxattr(struct dentry *dentry, const char *name,
-                        void *buffer, size_t size)
+static ssize_t bad_inode_getxattr(struct dentry *dentry, struct inode *inode,
+                        const char *name, void *buffer, size_t size)
 {
         return -EIO;
 }
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c
index 6d263bb1621c..67a607709d4f 100644
--- a/fs/btrfs/acl.c
+++ b/fs/btrfs/acl.c
@@ -63,9 +63,6 @@ struct posix_acl *btrfs_get_acl(struct inode *inode, int type)
         }
         kfree(value);
 
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
-
         return acl;
 }
 
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 517d0ccb351e..e692eea87af6 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4988,7 +4988,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                         goto out;
 
         if (!S_ISDIR(inode->i_mode)) {
-                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != parent->d_sb)
                         goto out;
                 inode = d_inode(parent);
         }
@@ -5009,7 +5009,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                         break;
                 }
 
-                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != parent->d_sb)
                         break;
 
                 if (IS_ROOT(parent))
@@ -5422,7 +5422,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
         }
 
         while (1) {
-                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != parent->d_sb)
                         break;
 
                 inode = d_inode(parent);
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 145d2b89e62d..03224b00ea70 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -369,11 +369,9 @@ err:
 }
 
 static int btrfs_xattr_handler_get(const struct xattr_handler *handler,
-                                   struct dentry *dentry, const char *name,
-                                   void *buffer, size_t size)
+                                   struct dentry *unused, struct inode *inode,
+                                   const char *name, void *buffer, size_t size)
 {
-        struct inode *inode = d_inode(dentry);
-
         name = xattr_full_name(handler, name);
         return __btrfs_getxattr(inode, name, buffer, size);
 }
diff --git a/fs/ceph/acl.c b/fs/ceph/acl.c
index f19708487e2f..5457f216e2e5 100644
--- a/fs/ceph/acl.c
+++ b/fs/ceph/acl.c
@@ -37,6 +37,8 @@ static inline void ceph_set_cached_acl(struct inode *inode,
         spin_lock(&ci->i_ceph_lock);
         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 0))
                 set_cached_acl(inode, type, acl);
+        else
+                forget_cached_acl(inode, type);
         spin_unlock(&ci->i_ceph_lock);
 }
 
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index e705c4d612d7..beb893bb234f 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -795,7 +795,7 @@ extern int ceph_setxattr(struct dentry *, const char *, const void *,
 int __ceph_setxattr(struct dentry *, const char *, const void *, size_t, int);
 ssize_t __ceph_getxattr(struct inode *, const char *, void *, size_t);
 int __ceph_removexattr(struct dentry *, const char *);
-extern ssize_t ceph_getxattr(struct dentry *, const char *, void *, size_t);
+extern ssize_t ceph_getxattr(struct dentry *, struct inode *, const char *, void *, size_t);
 extern ssize_t ceph_listxattr(struct dentry *, char *, size_t);
 extern int ceph_removexattr(struct dentry *, const char *);
 extern void __ceph_build_xattrs_blob(struct ceph_inode_info *ci);
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 9410abdef3ce..c6e917d360f7 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -804,13 +804,13 @@ out:
         return err;
 }
 
-ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
-                      size_t size)
+ssize_t ceph_getxattr(struct dentry *dentry, struct inode *inode,
+                      const char *name, void *value, size_t size)
 {
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
-                return generic_getxattr(dentry, name, value, size);
+                return generic_getxattr(dentry, inode, name, value, size);
 
-        return __ceph_getxattr(d_inode(dentry), name, value, size);
+        return __ceph_getxattr(inode, name, value, size);
 }
 
 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index e956cba94338..94f2c8a9ae6d 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -302,7 +302,7 @@ static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt)
         if (full_path == NULL)
                 goto cdda_exit;
 
-        cifs_sb = CIFS_SB(d_inode(mntpt)->i_sb);
+        cifs_sb = CIFS_SB(mntpt->d_sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
                 mnt = ERR_CAST(tlink);
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 83aac8ba50b0..c89ecd7a5c39 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -123,7 +123,7 @@ extern int cifs_symlink(struct inode *inode, struct dentry *direntry,
 extern int      cifs_removexattr(struct dentry *, const char *);
 extern int      cifs_setxattr(struct dentry *, const char *, const void *,
                         size_t, int);
-extern ssize_t  cifs_getxattr(struct dentry *, const char *, void *, size_t);
+extern ssize_t  cifs_getxattr(struct dentry *, struct inode *, const char *, void *, size_t);
 extern ssize_t  cifs_listxattr(struct dentry *, char *, size_t);
 extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg);
 #ifdef CONFIG_CIFS_NFSD_EXPORT
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 5f9ad5c42180..514dadb0575d 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -2418,8 +2418,7 @@ cifs_setattr_exit:
 int
 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
 {
-        struct inode *inode = d_inode(direntry);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
 
         if (pTcon->unix_ext)
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index b30a4a6d98a0..4cfb4d9f88e2 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -78,7 +78,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
 {
         struct dentry *dentry, *alias;
         struct inode *inode;
-        struct super_block *sb = d_inode(parent)->i_sb;
+        struct super_block *sb = parent->d_sb;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 
         cifs_dbg(FYI, "%s: for %s\n", __func__, name->name);
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index f5dc2f0df4ad..5d57c85703a9 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -42,21 +42,11 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
         int rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
         unsigned int xid;
-        struct cifs_sb_info *cifs_sb;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
-        struct super_block *sb;
         char *full_path = NULL;
 
-        if (direntry == NULL)
-                return -EIO;
-        if (d_really_is_negative(direntry))
-                return -EIO;
-        sb = d_inode(direntry)->i_sb;
-        if (sb == NULL)
-                return -EIO;
-
-        cifs_sb = CIFS_SB(sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
@@ -103,21 +93,12 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
         int rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
         unsigned int xid;
-        struct cifs_sb_info *cifs_sb;
+        struct super_block *sb = direntry->d_sb;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
-        struct super_block *sb;
         char *full_path;
 
-        if (direntry == NULL)
-                return -EIO;
-        if (d_really_is_negative(direntry))
-                return -EIO;
-        sb = d_inode(direntry)->i_sb;
-        if (sb == NULL)
-                return -EIO;
-
-        cifs_sb = CIFS_SB(sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
@@ -232,27 +213,18 @@ set_ea_exit:
         return rc;
 }
 
-ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
-        void *ea_value, size_t buf_size)
+ssize_t cifs_getxattr(struct dentry *direntry, struct inode *inode,
+        const char *ea_name, void *ea_value, size_t buf_size)
 {
         ssize_t rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
         unsigned int xid;
-        struct cifs_sb_info *cifs_sb;
+        struct super_block *sb = direntry->d_sb;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
-        struct super_block *sb;
         char *full_path;
 
-        if (direntry == NULL)
-                return -EIO;
-        if (d_really_is_negative(direntry))
-                return -EIO;
-        sb = d_inode(direntry)->i_sb;
-        if (sb == NULL)
-                return -EIO;
-
-        cifs_sb = CIFS_SB(sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
@@ -324,7 +296,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                                 goto get_ea_exit; /* rc already EOPNOTSUPP */
 
                         pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
-                                        d_inode(direntry), full_path, &acllen);
+                                        inode, full_path, &acllen);
                         if (IS_ERR(pacl)) {
                                 rc = PTR_ERR(pacl);
                                 cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
@@ -374,21 +346,11 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
         ssize_t rc = -EOPNOTSUPP;
 #ifdef CONFIG_CIFS_XATTR
         unsigned int xid;
-        struct cifs_sb_info *cifs_sb;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
-        struct super_block *sb;
         char *full_path;
 
-        if (direntry == NULL)
-                return -EIO;
-        if (d_really_is_negative(direntry))
-                return -EIO;
-        sb = d_inode(direntry)->i_sb;
-        if (sb == NULL)
-                return -EIO;
-
-        cifs_sb = CIFS_SB(sb);
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                 return -EOPNOTSUPP;
 
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index d09cb4cdd09f..8710093aae5e 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1369,7 +1369,9 @@ int ecryptfs_read_xattr_region(char *page_virt, struct inode *ecryptfs_inode)
         ssize_t size;
         int rc = 0;
 
-        size = ecryptfs_getxattr_lower(lower_dentry, ECRYPTFS_XATTR_NAME,
+        size = ecryptfs_getxattr_lower(lower_dentry,
+                                       ecryptfs_inode_to_lower(ecryptfs_inode),
+                                       ECRYPTFS_XATTR_NAME,
                                        page_virt, ECRYPTFS_DEFAULT_EXTENT_SIZE);
         if (size < 0) {
                 if (unlikely(ecryptfs_verbosity > 0))
@@ -1391,6 +1393,7 @@ int ecryptfs_read_and_validate_xattr_region(struct dentry *dentry,
         int rc;
 
         rc = ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
+                                     ecryptfs_inode_to_lower(inode),
                                      ECRYPTFS_XATTR_NAME, file_size,
                                      ECRYPTFS_SIZE_AND_MARKER_BYTES);
         if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index d123fbaa28e0..6ff907f73331 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -607,8 +607,8 @@ ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
                           unsigned char *src, struct dentry *ecryptfs_dentry);
 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length);
 ssize_t
-ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
-                        void *value, size_t size);
+ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
+                        const char *name, void *value, size_t size);
 int
 ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                   size_t size, int flags);
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 224b49e71aa4..9323c536b2f2 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -1033,29 +1033,30 @@ out:
 }
 
 ssize_t
-ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
-                        void *value, size_t size)
+ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
+                        const char *name, void *value, size_t size)
 {
         int rc = 0;
 
-        if (!d_inode(lower_dentry)->i_op->getxattr) {
+        if (!lower_inode->i_op->getxattr) {
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        inode_lock(d_inode(lower_dentry));
-        rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value,
-                                                   size);
-        inode_unlock(d_inode(lower_dentry));
+        inode_lock(lower_inode);
+        rc = lower_inode->i_op->getxattr(lower_dentry, lower_inode,
+                                         name, value, size);
+        inode_unlock(lower_inode);
 out:
         return rc;
 }
 
 static ssize_t
-ecryptfs_getxattr(struct dentry *dentry, const char *name, void *value,
-                  size_t size)
+ecryptfs_getxattr(struct dentry *dentry, struct inode *inode,
+                  const char *name, void *value, size_t size)
 {
-        return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry), name,
-                                       value, size);
+        return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
+                                       ecryptfs_inode_to_lower(inode),
+                                       name, value, size);
 }
 
 static ssize_t
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index e6b1d80952b9..148d11b514fb 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -436,7 +436,8 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
                 goto out;
         }
         inode_lock(lower_inode);
-        size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
+        size = lower_inode->i_op->getxattr(lower_dentry, lower_inode,
+                                           ECRYPTFS_XATTR_NAME,
                                            xattr_virt, PAGE_SIZE);
         if (size < 0)
                 size = 8;
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index 40ba9cc41bf7..d34a40edcdb2 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -113,7 +113,7 @@ struct dentry *efs_get_parent(struct dentry *child)
 
         ino = efs_find_entry(d_inode(child), "..", 2);
         if (ino)
-                parent = d_obtain_alias(efs_iget(d_inode(child)->i_sb, ino));
+                parent = d_obtain_alias(efs_iget(child->d_sb, ino));
 
         return parent;
 }
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index 6658a50530a0..192373653dfb 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -958,7 +958,7 @@ static struct dentry *exofs_get_parent(struct dentry *child)
         if (!ino)
                 return ERR_PTR(-ESTALE);
 
-        return d_obtain_alias(exofs_iget(d_inode(child)->i_sb, ino));
+        return d_obtain_alias(exofs_iget(child->d_sb, ino));
 }
 
 static struct inode *exofs_nfs_get_inode(struct super_block *sb,
diff --git a/fs/ext2/acl.c b/fs/ext2/acl.c
index 27695e6f4e46..42f1d1814083 100644
--- a/fs/ext2/acl.c
+++ b/fs/ext2/acl.c
@@ -172,9 +172,6 @@ ext2_get_acl(struct inode *inode, int type)
                 acl = ERR_PTR(retval);
         kfree(value);
 
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
-
         return acl;
 }
 
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index d34843925b23..d446203127fc 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -82,7 +82,7 @@ struct dentry *ext2_get_parent(struct dentry *child)
         unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino));
+        return d_obtain_alias(ext2_iget(child->d_sb, ino));
 } 
 
 /*
diff --git a/fs/ext2/xattr_security.c b/fs/ext2/xattr_security.c
index ba97f243b050..7fd3b867ce65 100644
--- a/fs/ext2/xattr_security.c
+++ b/fs/ext2/xattr_security.c
@@ -9,10 +9,10 @@
 
 static int
 ext2_xattr_security_get(const struct xattr_handler *handler,
-                        struct dentry *dentry, const char *name,
-                        void *buffer, size_t size)
+                        struct dentry *unused, struct inode *inode,
+                        const char *name, void *buffer, size_t size)
 {
-        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name,
+        return ext2_xattr_get(inode, EXT2_XATTR_INDEX_SECURITY, name,
                               buffer, size);
 }
 
diff --git a/fs/ext2/xattr_trusted.c b/fs/ext2/xattr_trusted.c
index 2c94d1930626..0f85705ff519 100644
--- a/fs/ext2/xattr_trusted.c
+++ b/fs/ext2/xattr_trusted.c
@@ -16,10 +16,10 @@ ext2_xattr_trusted_list(struct dentry *dentry)
 
 static int
 ext2_xattr_trusted_get(const struct xattr_handler *handler,
-                       struct dentry *dentry, const char *name,
-                       void *buffer, size_t size)
+                       struct dentry *unused, struct inode *inode,
+                       const char *name, void *buffer, size_t size)
 {
-        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name,
+        return ext2_xattr_get(inode, EXT2_XATTR_INDEX_TRUSTED, name,
                               buffer, size);
 }
 
diff --git a/fs/ext2/xattr_user.c b/fs/ext2/xattr_user.c
index 72a2a96d677f..1fafd27037cc 100644
--- a/fs/ext2/xattr_user.c
+++ b/fs/ext2/xattr_user.c
@@ -18,12 +18,12 @@ ext2_xattr_user_list(struct dentry *dentry)
 
 static int
 ext2_xattr_user_get(const struct xattr_handler *handler,
-                    struct dentry *dentry, const char *name,
-                    void *buffer, size_t size)
+                    struct dentry *unused, struct inode *inode,
+                    const char *name, void *buffer, size_t size)
 {
-        if (!test_opt(dentry->d_sb, XATTR_USER))
+        if (!test_opt(inode->i_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_USER,
+        return ext2_xattr_get(inode, EXT2_XATTR_INDEX_USER,
                               name, buffer, size);
 }
 
diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index 69b1e73026a5..c6601a476c02 100644
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -172,9 +172,6 @@ ext4_get_acl(struct inode *inode, int type)
                 acl = ERR_PTR(retval);
         kfree(value);
 
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
-
         return acl;
 }
 
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 48e4b8907826..5611ec9348d7 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1638,13 +1638,13 @@ struct dentry *ext4_get_parent(struct dentry *child)
         ino = le32_to_cpu(de->inode);
         brelse(bh);
 
-        if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
+        if (!ext4_valid_inum(child->d_sb, ino)) {
                 EXT4_ERROR_INODE(d_inode(child),
                                  "bad parent inode number: %u", ino);
                 return ERR_PTR(-EFSCORRUPTED);
         }
 
-        return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
+        return d_obtain_alias(ext4_iget_normal(child->d_sb, ino));
 }
 
 /*
diff --git a/fs/ext4/xattr_security.c b/fs/ext4/xattr_security.c
index 3e81bdca071a..123a7d010efe 100644
--- a/fs/ext4/xattr_security.c
+++ b/fs/ext4/xattr_security.c
@@ -13,10 +13,10 @@
 
 static int
 ext4_xattr_security_get(const struct xattr_handler *handler,
-                        struct dentry *dentry, const char *name,
-                        void *buffer, size_t size)
+                        struct dentry *unused, struct inode *inode,
+                        const char *name, void *buffer, size_t size)
 {
-        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY,
+        return ext4_xattr_get(inode, EXT4_XATTR_INDEX_SECURITY,
                               name, buffer, size);
 }
 
diff --git a/fs/ext4/xattr_trusted.c b/fs/ext4/xattr_trusted.c
index 2a3c6f9b8cb8..60652fa24cbc 100644
--- a/fs/ext4/xattr_trusted.c
+++ b/fs/ext4/xattr_trusted.c
@@ -20,10 +20,10 @@ ext4_xattr_trusted_list(struct dentry *dentry)
 
 static int
 ext4_xattr_trusted_get(const struct xattr_handler *handler,
-                       struct dentry *dentry, const char *name, void *buffer,
-                       size_t size)
+                       struct dentry *unused, struct inode *inode,
+                       const char *name, void *buffer, size_t size)
 {
-        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED,
+        return ext4_xattr_get(inode, EXT4_XATTR_INDEX_TRUSTED,
                               name, buffer, size);
 }
 
diff --git a/fs/ext4/xattr_user.c b/fs/ext4/xattr_user.c
index d152f431e432..17a446ffecd3 100644
--- a/fs/ext4/xattr_user.c
+++ b/fs/ext4/xattr_user.c
@@ -19,12 +19,12 @@ ext4_xattr_user_list(struct dentry *dentry)
 
 static int
 ext4_xattr_user_get(const struct xattr_handler *handler,
-                    struct dentry *dentry, const char *name,
-                    void *buffer, size_t size)
+                    struct dentry *unused, struct inode *inode,
+                    const char *name, void *buffer, size_t size)
 {
-        if (!test_opt(dentry->d_sb, XATTR_USER))
+        if (!test_opt(inode->i_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_USER,
+        return ext4_xattr_get(inode, EXT4_XATTR_INDEX_USER,
                               name, buffer, size);
 }
 
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index c8f25f7241f0..6f1fdda977b3 100644
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -190,9 +190,6 @@ static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type,
                 acl = ERR_PTR(retval);
         kfree(value);
 
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
-
         return acl;
 }
 
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 013e57932d61..324ed3812f30 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -202,7 +202,7 @@ struct dentry *f2fs_get_parent(struct dentry *child)
         unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(f2fs_iget(d_inode(child)->i_sb, ino));
+        return d_obtain_alias(f2fs_iget(child->d_sb, ino));
 }
 
 static int __recover_dot_dentries(struct inode *dir, nid_t pino)
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 06a72dc0191a..17fd2b1a6848 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -26,10 +26,10 @@
 #include "xattr.h"
 
 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
-                struct dentry *dentry, const char *name, void *buffer,
-                size_t size)
+                struct dentry *unused, struct inode *inode,
+                const char *name, void *buffer, size_t size)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
+        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 
         switch (handler->flags) {
         case F2FS_XATTR_INDEX_USER:
@@ -45,7 +45,7 @@ static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
         default:
                 return -EINVAL;
         }
-        return f2fs_getxattr(d_inode(dentry), handler->flags, name,
+        return f2fs_getxattr(inode, handler->flags, name,
                              buffer, size, NULL);
 }
 
@@ -86,11 +86,9 @@ static bool f2fs_xattr_trusted_list(struct dentry *dentry)
 }
 
 static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
-                struct dentry *dentry, const char *name, void *buffer,
-                size_t size)
+                struct dentry *unused, struct inode *inode,
+                const char *name, void *buffer, size_t size)
 {
-        struct inode *inode = d_inode(dentry);
-
         if (buffer)
                 *((char *)buffer) = F2FS_I(inode)->i_advise;
         return sizeof(char);
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 4b855b65d457..b618527c05c6 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1759,10 +1759,9 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
         return err;
 }
 
-static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
-                             void *value, size_t size)
+static ssize_t fuse_getxattr(struct dentry *entry, struct inode *inode,
+                             const char *name, void *value, size_t size)
 {
-        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         struct fuse_getxattr_in inarg;
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index bb30f9a72c65..45f516cada78 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -1968,22 +1968,21 @@ static int gfs2_setxattr(struct dentry *dentry, const char *name,
         return ret;
 }
 
-static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
-                             void *data, size_t size)
+static ssize_t gfs2_getxattr(struct dentry *dentry, struct inode *inode,
+                             const char *name, void *data, size_t size)
 {
-        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int ret;
 
         /* For selinux during lookup */
         if (gfs2_glock_is_locked_by_me(ip->i_gl))
-                return generic_getxattr(dentry, name, data, size);
+                return generic_getxattr(dentry, inode, name, data, size);
 
         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
         ret = gfs2_glock_nq(&gh);
         if (ret == 0) {
-                ret = generic_getxattr(dentry, name, data, size);
+                ret = generic_getxattr(dentry, inode, name, data, size);
                 gfs2_glock_dq(&gh);
         }
         gfs2_holder_uninit(&gh);
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 49b0bff18fe3..c09c63dcd7a2 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1360,7 +1360,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
                 return ERR_PTR(error);
         }
         s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
-                 d_inode(path.dentry)->i_sb->s_bdev);
+                 path.dentry->d_sb->s_bdev);
         path_put(&path);
         if (IS_ERR(s)) {
                 pr_warn("gfs2 mount does not exist\n");
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index f8a0cd821290..9b2ff353e45f 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -1176,7 +1176,7 @@ static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *s
 
 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct super_block *sb = d_inode(dentry)->i_sb;
+        struct super_block *sb = dentry->d_sb;
         struct gfs2_sbd *sdp = sb->s_fs_info;
         struct gfs2_statfs_change_host sc;
         int error;
diff --git a/fs/gfs2/xattr.c b/fs/gfs2/xattr.c
index e8dfb4740c04..619886ba6e78 100644
--- a/fs/gfs2/xattr.c
+++ b/fs/gfs2/xattr.c
@@ -584,10 +584,10 @@ out:
  * Returns: actual size of data on success, -errno on error
  */
 static int gfs2_xattr_get(const struct xattr_handler *handler,
-                          struct dentry *dentry, const char *name,
-                          void *buffer, size_t size)
+                          struct dentry *unused, struct inode *inode,
+                          const char *name, void *buffer, size_t size)
 {
-        struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
+        struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_ea_location el;
         int type = handler->flags;
         int error;
diff --git a/fs/hfs/attr.c b/fs/hfs/attr.c
index 8d931b157bbe..064f92f17efc 100644
--- a/fs/hfs/attr.c
+++ b/fs/hfs/attr.c
@@ -56,10 +56,9 @@ out:
         return res;
 }
 
-ssize_t hfs_getxattr(struct dentry *dentry, const char *name,
-                         void *value, size_t size)
+ssize_t hfs_getxattr(struct dentry *unused, struct inode *inode,
+                     const char *name, void *value, size_t size)
 {
-        struct inode *inode = d_inode(dentry);
         struct hfs_find_data fd;
         hfs_cat_rec rec;
         struct hfs_cat_file *file;
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 1f1c7dcbcc2f..79daa097929a 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -213,8 +213,8 @@ extern void hfs_delete_inode(struct inode *);
 /* attr.c */
 extern int hfs_setxattr(struct dentry *dentry, const char *name,
                         const void *value, size_t size, int flags);
-extern ssize_t hfs_getxattr(struct dentry *dentry, const char *name,
-                            void *value, size_t size);
+extern ssize_t hfs_getxattr(struct dentry *dentry, struct inode *inode,
+                            const char *name, void *value, size_t size);
 extern ssize_t hfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 
 /* mdb.c */
diff --git a/fs/hfsplus/posix_acl.c b/fs/hfsplus/posix_acl.c
index afb33eda6d7d..ab7ea2506b4d 100644
--- a/fs/hfsplus/posix_acl.c
+++ b/fs/hfsplus/posix_acl.c
@@ -48,9 +48,6 @@ struct posix_acl *hfsplus_get_posix_acl(struct inode *inode, int type)
 
         hfsplus_destroy_attr_entry((hfsplus_attr_entry *)value);
 
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
-
         return acl;
 }
 
diff --git a/fs/hfsplus/xattr.c b/fs/hfsplus/xattr.c
index 70e445ff0cff..4f118d282a7a 100644
--- a/fs/hfsplus/xattr.c
+++ b/fs/hfsplus/xattr.c
@@ -579,7 +579,7 @@ failed_getxattr_init:
         return res;
 }
 
-ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
+ssize_t hfsplus_getxattr(struct inode *inode, const char *name,
                          void *value, size_t size,
                          const char *prefix, size_t prefixlen)
 {
@@ -594,7 +594,7 @@ ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
         strcpy(xattr_name, prefix);
         strcpy(xattr_name + prefixlen, name);
 
-        res = __hfsplus_getxattr(d_inode(dentry), xattr_name, value, size);
+        res = __hfsplus_getxattr(inode, xattr_name, value, size);
         kfree(xattr_name);
         return res;
 
@@ -844,8 +844,8 @@ end_removexattr:
 }
 
 static int hfsplus_osx_getxattr(const struct xattr_handler *handler,
-                                struct dentry *dentry, const char *name,
-                                void *buffer, size_t size)
+                                struct dentry *unused, struct inode *inode,
+                                const char *name, void *buffer, size_t size)
 {
         /*
          * Don't allow retrieving properly prefixed attributes
@@ -860,7 +860,7 @@ static int hfsplus_osx_getxattr(const struct xattr_handler *handler,
          * creates), so we pass the name through unmodified (after
          * ensuring it doesn't conflict with another namespace).
          */
-        return __hfsplus_getxattr(d_inode(dentry), name, buffer, size);
+        return __hfsplus_getxattr(inode, name, buffer, size);
 }
 
 static int hfsplus_osx_setxattr(const struct xattr_handler *handler,
diff --git a/fs/hfsplus/xattr.h b/fs/hfsplus/xattr.h
index f9b0955b3d28..d04ba6f58df2 100644
--- a/fs/hfsplus/xattr.h
+++ b/fs/hfsplus/xattr.h
@@ -28,7 +28,7 @@ int hfsplus_setxattr(struct dentry *dentry, const char *name,
 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
                            void *value, size_t size);
 
-ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
+ssize_t hfsplus_getxattr(struct inode *inode, const char *name,
                          void *value, size_t size,
                          const char *prefix, size_t prefixlen);
 
diff --git a/fs/hfsplus/xattr_security.c b/fs/hfsplus/xattr_security.c
index 72a68a3a0c99..ae2ca8c2e335 100644
--- a/fs/hfsplus/xattr_security.c
+++ b/fs/hfsplus/xattr_security.c
@@ -14,10 +14,10 @@
 #include "acl.h"
 
 static int hfsplus_security_getxattr(const struct xattr_handler *handler,
-                                     struct dentry *dentry, const char *name,
-                                     void *buffer, size_t size)
+                                     struct dentry *unused, struct inode *inode,
+                                     const char *name, void *buffer, size_t size)
 {
-        return hfsplus_getxattr(dentry, name, buffer, size,
+        return hfsplus_getxattr(inode, name, buffer, size,
                                 XATTR_SECURITY_PREFIX,
                                 XATTR_SECURITY_PREFIX_LEN);
 }
diff --git a/fs/hfsplus/xattr_trusted.c b/fs/hfsplus/xattr_trusted.c
index 95a7704c7abb..eae2947060aa 100644
--- a/fs/hfsplus/xattr_trusted.c
+++ b/fs/hfsplus/xattr_trusted.c
@@ -12,10 +12,10 @@
 #include "xattr.h"
 
 static int hfsplus_trusted_getxattr(const struct xattr_handler *handler,
-                                    struct dentry *dentry, const char *name,
-                                    void *buffer, size_t size)
+                                    struct dentry *unused, struct inode *inode,
+                                    const char *name, void *buffer, size_t size)
 {
-        return hfsplus_getxattr(dentry, name, buffer, size,
+        return hfsplus_getxattr(inode, name, buffer, size,
                                 XATTR_TRUSTED_PREFIX,
                                 XATTR_TRUSTED_PREFIX_LEN);
 }
diff --git a/fs/hfsplus/xattr_user.c b/fs/hfsplus/xattr_user.c
index 6fc269baf959..3c9eec3e4c7b 100644
--- a/fs/hfsplus/xattr_user.c
+++ b/fs/hfsplus/xattr_user.c
@@ -12,11 +12,11 @@
 #include "xattr.h"
 
 static int hfsplus_user_getxattr(const struct xattr_handler *handler,
-                                 struct dentry *dentry, const char *name,
-                                 void *buffer, size_t size)
+                                 struct dentry *unused, struct inode *inode,
+                                 const char *name, void *buffer, size_t size)
 {
 
-        return hfsplus_getxattr(dentry, name, buffer, size,
+        return hfsplus_getxattr(inode, name, buffer, size,
                                 XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
 }
 
diff --git a/fs/inode.c b/fs/inode.c
index 69b8b526c194..4202aac99464 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -238,9 +238,9 @@ void __destroy_inode(struct inode *inode)
         }
 
 #ifdef CONFIG_FS_POSIX_ACL
-        if (inode->i_acl && inode->i_acl != ACL_NOT_CACHED)
+        if (inode->i_acl && !is_uncached_acl(inode->i_acl))
                 posix_acl_release(inode->i_acl);
-        if (inode->i_default_acl && inode->i_default_acl != ACL_NOT_CACHED)
+        if (inode->i_default_acl && !is_uncached_acl(inode->i_default_acl))
                 posix_acl_release(inode->i_default_acl);
 #endif
         this_cpu_dec(nr_inodes);
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 2f7a3c090489..bc2693d56298 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -203,8 +203,6 @@ struct posix_acl *jffs2_get_acl(struct inode *inode, int type)
                 acl = ERR_PTR(rc);
         }
         kfree(value);
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
         return acl;
 }
 
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 30c4c9ebb693..7a9579e03dbb 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -241,7 +241,7 @@ static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
 
 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
 {
-        struct jffs2_sb_info *c = JFFS2_SB_INFO(d_inode(old_dentry)->i_sb);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb);
         struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
         struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
         int ret;
diff --git a/fs/jffs2/security.c b/fs/jffs2/security.c
index 7a28facd7175..3ed9a4b49778 100644
--- a/fs/jffs2/security.c
+++ b/fs/jffs2/security.c
@@ -49,10 +49,10 @@ int jffs2_init_security(struct inode *inode, struct inode *dir,
 
 /* ---- XATTR Handler for "security.*" ----------------- */
 static int jffs2_security_getxattr(const struct xattr_handler *handler,
-                                   struct dentry *dentry, const char *name,
-                                   void *buffer, size_t size)
+                                   struct dentry *unused, struct inode *inode,
+                                   const char *name, void *buffer, size_t size)
 {
-        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY,
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_SECURITY,
                                  name, buffer, size);
 }
 
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 0a9a114bb9d1..5ef21f4c4c77 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -147,7 +147,7 @@ static struct dentry *jffs2_get_parent(struct dentry *child)
         JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
                     f->inocache->ino, pino);
 
-        return d_obtain_alias(jffs2_iget(d_inode(child)->i_sb, pino));
+        return d_obtain_alias(jffs2_iget(child->d_sb, pino));
 }
 
 static const struct export_operations jffs2_export_ops = {
diff --git a/fs/jffs2/xattr_trusted.c b/fs/jffs2/xattr_trusted.c
index b2555ef07a12..4ebecff1d922 100644
--- a/fs/jffs2/xattr_trusted.c
+++ b/fs/jffs2/xattr_trusted.c
@@ -17,10 +17,10 @@
 #include "nodelist.h"
 
 static int jffs2_trusted_getxattr(const struct xattr_handler *handler,
-                                  struct dentry *dentry, const char *name,
-                                  void *buffer, size_t size)
+                                  struct dentry *unused, struct inode *inode,
+                                  const char *name, void *buffer, size_t size)
 {
-        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED,
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_TRUSTED,
                                  name, buffer, size);
 }
 
diff --git a/fs/jffs2/xattr_user.c b/fs/jffs2/xattr_user.c
index 539bd630b5e4..bce249e1b277 100644
--- a/fs/jffs2/xattr_user.c
+++ b/fs/jffs2/xattr_user.c
@@ -17,10 +17,10 @@
 #include "nodelist.h"
 
 static int jffs2_user_getxattr(const struct xattr_handler *handler,
-                               struct dentry *dentry, const char *name,
-                               void *buffer, size_t size)
+                               struct dentry *unused, struct inode *inode,
+                               const char *name, void *buffer, size_t size)
 {
-        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_USER,
+        return do_jffs2_getxattr(inode, JFFS2_XPREFIX_USER,
                                  name, buffer, size);
 }
 
diff --git a/fs/jfs/acl.c b/fs/jfs/acl.c
index 49456853e9de..21fa92ba2c19 100644
--- a/fs/jfs/acl.c
+++ b/fs/jfs/acl.c
@@ -34,10 +34,6 @@ struct posix_acl *jfs_get_acl(struct inode *inode, int type)
         int size;
         char *value = NULL;
 
-        acl = get_cached_acl(inode, type);
-        if (acl != ACL_NOT_CACHED)
-                return acl;
-
         switch(type) {
                 case ACL_TYPE_ACCESS:
                         ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
@@ -67,8 +63,6 @@ struct posix_acl *jfs_get_acl(struct inode *inode, int type)
                 acl = posix_acl_from_xattr(&init_user_ns, value, size);
         }
         kfree(value);
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
         return acl;
 }
 
diff --git a/fs/jfs/jfs_xattr.h b/fs/jfs/jfs_xattr.h
index e8d717dabca3..e69e14f3777b 100644
--- a/fs/jfs/jfs_xattr.h
+++ b/fs/jfs/jfs_xattr.h
@@ -57,7 +57,7 @@ extern int __jfs_setxattr(tid_t, struct inode *, const char *, const void *,
 extern int jfs_setxattr(struct dentry *, const char *, const void *, size_t,
                         int);
 extern ssize_t __jfs_getxattr(struct inode *, const char *, void *, size_t);
-extern ssize_t jfs_getxattr(struct dentry *, const char *, void *, size_t);
+extern ssize_t jfs_getxattr(struct dentry *, struct inode *, const char *, void *, size_t);
 extern ssize_t jfs_listxattr(struct dentry *, char *, size_t);
 extern int jfs_removexattr(struct dentry *, const char *);
 
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 701f89370de7..8a40941ac9a6 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -1524,7 +1524,7 @@ struct dentry *jfs_get_parent(struct dentry *dentry)
         parent_ino =
                 le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot);
 
-        return d_obtain_alias(jfs_iget(d_inode(dentry)->i_sb, parent_ino));
+        return d_obtain_alias(jfs_iget(dentry->d_sb, parent_ino));
 }
 
 const struct inode_operations jfs_dir_inode_operations = {
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index 48b15a6e5558..5becc6a3ff8c 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -933,8 +933,8 @@ ssize_t __jfs_getxattr(struct inode *inode, const char *name, void *data,
         return size;
 }
 
-ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
-                     size_t buf_size)
+ssize_t jfs_getxattr(struct dentry *dentry, struct inode *inode,
+                     const char *name, void *data, size_t buf_size)
 {
         int err;
 
@@ -944,7 +944,7 @@ ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
          * for it via sb->s_xattr.
          */
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
-                return generic_getxattr(dentry, name, data, buf_size);
+                return generic_getxattr(dentry, inode, name, data, buf_size);
 
         if (strncmp(name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
                 /*
@@ -959,7 +959,7 @@ ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
                         return -EOPNOTSUPP;
         }
 
-        err = __jfs_getxattr(d_inode(dentry), name, data, buf_size);
+        err = __jfs_getxattr(inode, name, data, buf_size);
 
         return err;
 }
diff --git a/fs/kernfs/inode.c b/fs/kernfs/inode.c
index 16405ae88d2d..b5247226732b 100644
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -208,10 +208,10 @@ int kernfs_iop_removexattr(struct dentry *dentry, const char *name)
         return simple_xattr_set(&attrs->xattrs, name, NULL, 0, XATTR_REPLACE);
 }
 
-ssize_t kernfs_iop_getxattr(struct dentry *dentry, const char *name, void *buf,
-                            size_t size)
+ssize_t kernfs_iop_getxattr(struct dentry *unused, struct inode *inode,
+                            const char *name, void *buf, size_t size)
 {
-        struct kernfs_node *kn = dentry->d_fsdata;
+        struct kernfs_node *kn = inode->i_private;
         struct kernfs_iattrs *attrs;
 
         attrs = kernfs_iattrs(kn);
diff --git a/fs/kernfs/kernfs-internal.h b/fs/kernfs/kernfs-internal.h
index 6762bfbd8207..45c9192c276e 100644
--- a/fs/kernfs/kernfs-internal.h
+++ b/fs/kernfs/kernfs-internal.h
@@ -84,8 +84,8 @@ int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry,
 int kernfs_iop_setxattr(struct dentry *dentry, const char *name, const void *value,
                         size_t size, int flags);
 int kernfs_iop_removexattr(struct dentry *dentry, const char *name);
-ssize_t kernfs_iop_getxattr(struct dentry *dentry, const char *name, void *buf,
-                            size_t size);
+ssize_t kernfs_iop_getxattr(struct dentry *dentry, struct inode *inode,
+                            const char *name, void *buf, size_t size);
 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size);
 
 /*
diff --git a/fs/libfs.c b/fs/libfs.c
index f3fa82ce9b70..43dd28031a1a 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -1127,8 +1127,8 @@ static int empty_dir_setxattr(struct dentry *dentry, const char *name,
         return -EOPNOTSUPP;
 }
 
-static ssize_t empty_dir_getxattr(struct dentry *dentry, const char *name,
-                                  void *value, size_t size)
+static ssize_t empty_dir_getxattr(struct dentry *dentry, struct inode *inode,
+                                  const char *name, void *value, size_t size)
 {
         return -EOPNOTSUPP;
 }
diff --git a/fs/namei.c b/fs/namei.c
index 1d9ca2d5dff6..bdcea8a018b8 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -265,7 +265,7 @@ static int check_acl(struct inode *inode, int mask)
                 if (!acl)
                         return -EAGAIN;
                 /* no ->get_acl() calls in RCU mode... */
-                if (acl == ACL_NOT_CACHED)
+                if (is_uncached_acl(acl))
                         return -ECHILD;
                 return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
         }
@@ -2655,7 +2655,7 @@ struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
                 return NULL;
         }
 
-        mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
+        mutex_lock(&p1->d_sb->s_vfs_rename_mutex);
 
         p = d_ancestor(p2, p1);
         if (p) {
@@ -2682,7 +2682,7 @@ void unlock_rename(struct dentry *p1, struct dentry *p2)
         inode_unlock(p1->d_inode);
         if (p1 != p2) {
                 inode_unlock(p2->d_inode);
-                mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
+                mutex_unlock(&p1->d_sb->s_vfs_rename_mutex);
         }
 }
 EXPORT_SYMBOL(unlock_rename);
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index c93826e4a8c6..438d4e70742f 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -396,7 +396,7 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
 static void nfs_direct_readpage_release(struct nfs_page *req)
 {
         dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",
-                d_inode(req->wb_context->dentry)->i_sb->s_id,
+                req->wb_context->dentry->d_sb->s_id,
                 (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
                 req->wb_bytes,
                 (long long)req_offset(req));
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 17c0fa1eccfa..720d92f5abfb 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -11,6 +11,38 @@
 
 #define NFSDBG_FACILITY NFSDBG_PROC
 
+/*
+ * nfs3_prepare_get_acl, nfs3_complete_get_acl, nfs3_abort_get_acl: Helpers for
+ * caching get_acl results in a race-free way.  See fs/posix_acl.c:get_acl()
+ * for explanations.
+ */
+static void nfs3_prepare_get_acl(struct posix_acl **p)
+{
+        struct posix_acl *sentinel = uncached_acl_sentinel(current);
+
+        if (cmpxchg(p, ACL_NOT_CACHED, sentinel) != ACL_NOT_CACHED) {
+                /* Not the first reader or sentinel already in place. */
+        }
+}
+
+static void nfs3_complete_get_acl(struct posix_acl **p, struct posix_acl *acl)
+{
+        struct posix_acl *sentinel = uncached_acl_sentinel(current);
+
+        /* Only cache the ACL if our sentinel is still in place. */
+        posix_acl_dup(acl);
+        if (cmpxchg(p, sentinel, acl) != sentinel)
+                posix_acl_release(acl);
+}
+
+static void nfs3_abort_get_acl(struct posix_acl **p)
+{
+        struct posix_acl *sentinel = uncached_acl_sentinel(current);
+
+        /* Remove our sentinel upon failure. */
+        cmpxchg(p, sentinel, ACL_NOT_CACHED);
+}
+
 struct posix_acl *nfs3_get_acl(struct inode *inode, int type)
 {
         struct nfs_server *server = NFS_SERVER(inode);
@@ -55,6 +87,11 @@ struct posix_acl *nfs3_get_acl(struct inode *inode, int type)
         if (res.fattr == NULL)
                 return ERR_PTR(-ENOMEM);
 
+        if (args.mask & NFS_ACL)
+                nfs3_prepare_get_acl(&inode->i_acl);
+        if (args.mask & NFS_DFACL)
+                nfs3_prepare_get_acl(&inode->i_default_acl);
+
         status = rpc_call_sync(server->client_acl, &msg, 0);
         dprintk("NFS reply getacl: %d\n", status);
 
@@ -89,12 +126,12 @@ struct posix_acl *nfs3_get_acl(struct inode *inode, int type)
         }
 
         if (res.mask & NFS_ACL)
-                set_cached_acl(inode, ACL_TYPE_ACCESS, res.acl_access);
+                nfs3_complete_get_acl(&inode->i_acl, res.acl_access);
         else
                 forget_cached_acl(inode, ACL_TYPE_ACCESS);
 
         if (res.mask & NFS_DFACL)
-                set_cached_acl(inode, ACL_TYPE_DEFAULT, res.acl_default);
+                nfs3_complete_get_acl(&inode->i_default_acl, res.acl_default);
         else
                 forget_cached_acl(inode, ACL_TYPE_DEFAULT);
 
@@ -108,6 +145,8 @@ struct posix_acl *nfs3_get_acl(struct inode *inode, int type)
         }
 
 getout:
+        nfs3_abort_get_acl(&inode->i_acl);
+        nfs3_abort_get_acl(&inode->i_default_acl);
         posix_acl_release(res.acl_access);
         posix_acl_release(res.acl_default);
         nfs_free_fattr(res.fattr);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 327b8c34d360..7a7ac1dafa02 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -6263,10 +6263,10 @@ static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
 }
 
 static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
-                                   struct dentry *dentry, const char *key,
-                                   void *buf, size_t buflen)
+                                   struct dentry *unused, struct inode *inode,
+                                   const char *key, void *buf, size_t buflen)
 {
-        return nfs4_proc_get_acl(d_inode(dentry), buf, buflen);
+        return nfs4_proc_get_acl(inode, buf, buflen);
 }
 
 static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
@@ -6288,11 +6288,11 @@ static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
 }
 
 static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
-                                     struct dentry *dentry, const char *key,
-                                     void *buf, size_t buflen)
+                                     struct dentry *unused, struct inode *inode,
+                                     const char *key, void *buf, size_t buflen)
 {
         if (security_ismaclabel(key))
-                return nfs4_get_security_label(d_inode(dentry), buf, buflen);
+                return nfs4_get_security_label(inode, buf, buflen);
         return -EOPNOTSUPP;
 }
 
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 51c3b06e8036..d818e4ffd79f 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -552,7 +552,7 @@ nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
          * different read/write sizes for file systems known to have
          * problems with large blocks */
         if (nfserr == 0) {
-                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
+                struct super_block *sb = argp->fh.fh_dentry->d_sb;
 
                 /* Note that we don't care for remote fs's here */
                 if (sb->s_magic == MSDOS_SUPER_MAGIC) {
@@ -588,7 +588,7 @@ nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
         nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP);
 
         if (nfserr == 0) {
-                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
+                struct super_block *sb = argp->fh.fh_dentry->d_sb;
 
                 /* Note that we don't care for remote fs's here */
                 switch (sb->s_magic) {
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 2246454dec76..93d5853f8c99 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -146,7 +146,7 @@ static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
         default:
         case FSIDSOURCE_DEV:
                 p = xdr_encode_hyper(p, (u64)huge_encode_dev
-                                     (d_inode(fhp->fh_dentry)->i_sb->s_dev));
+                                     (fhp->fh_dentry->d_sb->s_dev));
                 break;
         case FSIDSOURCE_FSID:
                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index c1681ce894c5..a8919444c460 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -426,7 +426,7 @@ static bool is_root_export(struct svc_export *exp)
 
 static struct super_block *exp_sb(struct svc_export *exp)
 {
-        return d_inode(exp->ex_path.dentry)->i_sb;
+        return exp->ex_path.dentry->d_sb;
 }
 
 static bool fsid_type_ok_for_exp(u8 fsid_type, struct svc_export *exp)
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 151bc19d47c0..3b2af05f9fb4 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -457,7 +457,7 @@ static struct dentry *nilfs_get_parent(struct dentry *child)
 
         root = NILFS_I(d_inode(child))->i_root;
 
-        inode = nilfs_iget(d_inode(child)->i_sb, root, ino);
+        inode = nilfs_iget(child->d_sb, root, ino);
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 474e57f834e6..1eaa9100c889 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -54,6 +54,7 @@
 #include "uptodate.h"
 #include "quota.h"
 #include "refcounttree.h"
+#include "acl.h"
 
 #include "buffer_head_io.h"
 
@@ -3623,6 +3624,8 @@ static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
                 filemap_fdatawait(mapping);
         }
 
+        forget_all_cached_acls(inode);
+
 out:
         return UNBLOCK_CONTINUE;
 }
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 5308841756be..2bf23fd333ed 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1290,7 +1290,7 @@ int ocfs2_getattr(struct vfsmount *mnt,
                   struct kstat *stat)
 {
         struct inode *inode = d_inode(dentry);
-        struct super_block *sb = d_inode(dentry)->i_sb;
+        struct super_block *sb = dentry->d_sb;
         struct ocfs2_super *osb = sb->s_fs_info;
         int err;
 
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 7d3d979f57d9..72eef4cfe8a9 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -7250,10 +7250,10 @@ leave:
  * 'security' attributes support
  */
 static int ocfs2_xattr_security_get(const struct xattr_handler *handler,
-                                    struct dentry *dentry, const char *name,
-                                    void *buffer, size_t size)
+                                    struct dentry *unused, struct inode *inode,
+                                    const char *name, void *buffer, size_t size)
 {
-        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
+        return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_SECURITY,
                                name, buffer, size);
 }
 
@@ -7321,10 +7321,10 @@ const struct xattr_handler ocfs2_xattr_security_handler = {
  * 'trusted' attributes support
  */
 static int ocfs2_xattr_trusted_get(const struct xattr_handler *handler,
-                                   struct dentry *dentry, const char *name,
-                                   void *buffer, size_t size)
+                                   struct dentry *unused, struct inode *inode,
+                                   const char *name, void *buffer, size_t size)
 {
-        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
+        return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED,
                                name, buffer, size);
 }
 
@@ -7346,14 +7346,14 @@ const struct xattr_handler ocfs2_xattr_trusted_handler = {
  * 'user' attributes support
  */
 static int ocfs2_xattr_user_get(const struct xattr_handler *handler,
-                                struct dentry *dentry, const char *name,
-                                void *buffer, size_t size)
+                                struct dentry *unusde, struct inode *inode,
+                                const char *name, void *buffer, size_t size)
 {
-        struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 
         if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                 return -EOPNOTSUPP;
-        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_USER, name,
+        return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name,
                                buffer, size);
 }
 
diff --git a/fs/orangefs/xattr.c b/fs/orangefs/xattr.c
index 63a6280d8c3a..99c19545752c 100644
--- a/fs/orangefs/xattr.c
+++ b/fs/orangefs/xattr.c
@@ -463,12 +463,13 @@ static int orangefs_xattr_set_default(const struct xattr_handler *handler,
 }
 
 static int orangefs_xattr_get_default(const struct xattr_handler *handler,
-                                      struct dentry *dentry,
+                                      struct dentry *unused,
+                                      struct inode *inode,
                                       const char *name,
                                       void *buffer,
                                       size_t size)
 {
-        return orangefs_inode_getxattr(dentry->d_inode,
+        return orangefs_inode_getxattr(inode,
                                     ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
                                     name,
                                     buffer,
@@ -492,12 +493,13 @@ static int orangefs_xattr_set_trusted(const struct xattr_handler *handler,
 }
 
 static int orangefs_xattr_get_trusted(const struct xattr_handler *handler,
-                                      struct dentry *dentry,
+                                      struct dentry *unused,
+                                      struct inode *inode,
                                       const char *name,
                                       void *buffer,
                                       size_t size)
 {
-        return orangefs_inode_getxattr(dentry->d_inode,
+        return orangefs_inode_getxattr(inode,
                                     ORANGEFS_XATTR_NAME_TRUSTED_PREFIX,
                                     name,
                                     buffer,
diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c
index a4ff5d0d7db9..c7b31a03dc9c 100644
--- a/fs/overlayfs/inode.c
+++ b/fs/overlayfs/inode.c
@@ -246,8 +246,8 @@ static bool ovl_need_xattr_filter(struct dentry *dentry,
                 return false;
 }
 
-ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
-                     void *value, size_t size)
+ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode,
+                     const char *name, void *value, size_t size)
 {
         struct path realpath;
         enum ovl_path_type type = ovl_path_real(dentry, &realpath);
diff --git a/fs/overlayfs/overlayfs.h b/fs/overlayfs/overlayfs.h
index 6a7090f4a441..99ec4b035237 100644
--- a/fs/overlayfs/overlayfs.h
+++ b/fs/overlayfs/overlayfs.h
@@ -173,8 +173,8 @@ int ovl_setattr(struct dentry *dentry, struct iattr *attr);
 int ovl_permission(struct inode *inode, int mask);
 int ovl_setxattr(struct dentry *dentry, const char *name,
                  const void *value, size_t size, int flags);
-ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
-                     void *value, size_t size);
+ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode,
+                     const char *name, void *value, size_t size);
 ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size);
 int ovl_removexattr(struct dentry *dentry, const char *name);
 struct inode *ovl_d_select_inode(struct dentry *dentry, unsigned file_flags);
diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index 5d972e6cd3fe..29c4d3250725 100644
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -274,7 +274,7 @@ static bool ovl_is_opaquedir(struct dentry *dentry)
         if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr)
                 return false;
 
-        res = inode->i_op->getxattr(dentry, OVL_XATTR_OPAQUE, &val, 1);
+        res = inode->i_op->getxattr(dentry, inode, OVL_XATTR_OPAQUE, &val, 1);
         if (res == 1 && val == 'y')
                 return true;
 
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
index 711dd5170376..2c60f17e7d92 100644
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -21,7 +21,7 @@
 #include <linux/export.h>
 #include <linux/user_namespace.h>
 
-struct posix_acl **acl_by_type(struct inode *inode, int type)
+static struct posix_acl **acl_by_type(struct inode *inode, int type)
 {
         switch (type) {
         case ACL_TYPE_ACCESS:
@@ -32,19 +32,22 @@ struct posix_acl **acl_by_type(struct inode *inode, int type)
                 BUG();
         }
 }
-EXPORT_SYMBOL(acl_by_type);
 
 struct posix_acl *get_cached_acl(struct inode *inode, int type)
 {
         struct posix_acl **p = acl_by_type(inode, type);
-        struct posix_acl *acl = ACCESS_ONCE(*p);
-        if (acl) {
-                spin_lock(&inode->i_lock);
-                acl = *p;
-                if (acl != ACL_NOT_CACHED)
-                        acl = posix_acl_dup(acl);
-                spin_unlock(&inode->i_lock);
+        struct posix_acl *acl;
+
+        for (;;) {
+                rcu_read_lock();
+                acl = rcu_dereference(*p);
+                if (!acl || is_uncached_acl(acl) ||
+                    atomic_inc_not_zero(&acl->a_refcount))
+                        break;
+                rcu_read_unlock();
+                cpu_relax();
         }
+        rcu_read_unlock();
         return acl;
 }
 EXPORT_SYMBOL(get_cached_acl);
@@ -59,58 +62,72 @@ void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl)
 {
         struct posix_acl **p = acl_by_type(inode, type);
         struct posix_acl *old;
-        spin_lock(&inode->i_lock);
-        old = *p;
-        rcu_assign_pointer(*p, posix_acl_dup(acl));
-        spin_unlock(&inode->i_lock);
-        if (old != ACL_NOT_CACHED)
+
+        old = xchg(p, posix_acl_dup(acl));
+        if (!is_uncached_acl(old))
                 posix_acl_release(old);
 }
 EXPORT_SYMBOL(set_cached_acl);
 
-void forget_cached_acl(struct inode *inode, int type)
+static void __forget_cached_acl(struct posix_acl **p)
 {
-        struct posix_acl **p = acl_by_type(inode, type);
         struct posix_acl *old;
-        spin_lock(&inode->i_lock);
-        old = *p;
-        *p = ACL_NOT_CACHED;
-        spin_unlock(&inode->i_lock);
-        if (old != ACL_NOT_CACHED)
+
+        old = xchg(p, ACL_NOT_CACHED);
+        if (!is_uncached_acl(old))
                 posix_acl_release(old);
 }
+
+void forget_cached_acl(struct inode *inode, int type)
+{
+        __forget_cached_acl(acl_by_type(inode, type));
+}
 EXPORT_SYMBOL(forget_cached_acl);
 
 void forget_all_cached_acls(struct inode *inode)
 {
-        struct posix_acl *old_access, *old_default;
-        spin_lock(&inode->i_lock);
-        old_access = inode->i_acl;
-        old_default = inode->i_default_acl;
-        inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
-        spin_unlock(&inode->i_lock);
-        if (old_access != ACL_NOT_CACHED)
-                posix_acl_release(old_access);
-        if (old_default != ACL_NOT_CACHED)
-                posix_acl_release(old_default);
+        __forget_cached_acl(&inode->i_acl);
+        __forget_cached_acl(&inode->i_default_acl);
 }
 EXPORT_SYMBOL(forget_all_cached_acls);
 
 struct posix_acl *get_acl(struct inode *inode, int type)
 {
+        void *sentinel;
+        struct posix_acl **p;
         struct posix_acl *acl;
 
+        /*
+         * The sentinel is used to detect when another operation like
+         * set_cached_acl() or forget_cached_acl() races with get_acl().
+         * It is guaranteed that is_uncached_acl(sentinel) is true.
+         */
+
         acl = get_cached_acl(inode, type);
-        if (acl != ACL_NOT_CACHED)
+        if (!is_uncached_acl(acl))
                 return acl;
 
         if (!IS_POSIXACL(inode))
                 return NULL;
 
+        sentinel = uncached_acl_sentinel(current);
+        p = acl_by_type(inode, type);
+
         /*
-         * A filesystem can force a ACL callback by just never filling the
-         * ACL cache. But normally you'd fill the cache either at inode
-         * instantiation time, or on the first ->get_acl call.
+         * If the ACL isn't being read yet, set our sentinel.  Otherwise, the
+         * current value of the ACL will not be ACL_NOT_CACHED and so our own
+         * sentinel will not be set; another task will update the cache.  We
+         * could wait for that other task to complete its job, but it's easier
+         * to just call ->get_acl to fetch the ACL ourself.  (This is going to
+         * be an unlikely race.)
+         */
+        if (cmpxchg(p, ACL_NOT_CACHED, sentinel) != ACL_NOT_CACHED)
+                /* fall through */ ;
+
+        /*
+         * Normally, the ACL returned by ->get_acl will be cached.
+         * A filesystem can prevent that by calling
+         * forget_cached_acl(inode, type) in ->get_acl.
          *
          * If the filesystem doesn't have a get_acl() function at all, we'll
          * just create the negative cache entry.
@@ -119,7 +136,24 @@ struct posix_acl *get_acl(struct inode *inode, int type)
                 set_cached_acl(inode, type, NULL);
                 return NULL;
         }
-        return inode->i_op->get_acl(inode, type);
+        acl = inode->i_op->get_acl(inode, type);
+
+        if (IS_ERR(acl)) {
+                /*
+                 * Remove our sentinel so that we don't block future attempts
+                 * to cache the ACL.
+                 */
+                cmpxchg(p, sentinel, ACL_NOT_CACHED);
+                return acl;
+        }
+
+        /*
+         * Cache the result, but only if our sentinel is still in place.
+         */
+        posix_acl_dup(acl);
+        if (unlikely(cmpxchg(p, sentinel, acl) != sentinel))
+                posix_acl_release(acl);
+        return acl;
 }
 EXPORT_SYMBOL(get_acl);
 
@@ -763,18 +797,18 @@ EXPORT_SYMBOL (posix_acl_to_xattr);
 
 static int
 posix_acl_xattr_get(const struct xattr_handler *handler,
-                    struct dentry *dentry, const char *name,
-                    void *value, size_t size)
+                    struct dentry *unused, struct inode *inode,
+                    const char *name, void *value, size_t size)
 {
         struct posix_acl *acl;
         int error;
 
-        if (!IS_POSIXACL(d_backing_inode(dentry)))
+        if (!IS_POSIXACL(inode))
                 return -EOPNOTSUPP;
-        if (d_is_symlink(dentry))
+        if (S_ISLNK(inode->i_mode))
                 return -EOPNOTSUPP;
 
-        acl = get_acl(d_backing_inode(dentry), handler->flags);
+        acl = get_acl(inode, handler->flags);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl == NULL)
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 389773711de4..90f815bdfa8a 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -260,10 +260,10 @@ const struct file_operations reiserfs_file_operations = {
 
 const struct inode_operations reiserfs_file_inode_operations = {
         .setattr = reiserfs_setattr,
-        .setxattr = reiserfs_setxattr,
-        .getxattr = reiserfs_getxattr,
+        .setxattr = generic_setxattr,
+        .getxattr = generic_getxattr,
         .listxattr = reiserfs_listxattr,
-        .removexattr = reiserfs_removexattr,
+        .removexattr = generic_removexattr,
         .permission = reiserfs_permission,
         .get_acl = reiserfs_get_acl,
         .set_acl = reiserfs_set_acl,
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 2a12d46d7fb4..8a36696d6df9 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -1650,10 +1650,10 @@ const struct inode_operations reiserfs_dir_inode_operations = {
         .mknod = reiserfs_mknod,
         .rename = reiserfs_rename,
         .setattr = reiserfs_setattr,
-        .setxattr = reiserfs_setxattr,
-        .getxattr = reiserfs_getxattr,
+        .setxattr = generic_setxattr,
+        .getxattr = generic_getxattr,
         .listxattr = reiserfs_listxattr,
-        .removexattr = reiserfs_removexattr,
+        .removexattr = generic_removexattr,
         .permission = reiserfs_permission,
         .get_acl = reiserfs_get_acl,
         .set_acl = reiserfs_set_acl,
@@ -1667,10 +1667,10 @@ const struct inode_operations reiserfs_symlink_inode_operations = {
         .readlink = generic_readlink,
         .get_link       = page_get_link,
         .setattr = reiserfs_setattr,
-        .setxattr = reiserfs_setxattr,
-        .getxattr = reiserfs_getxattr,
+        .setxattr = generic_setxattr,
+        .getxattr = generic_getxattr,
         .listxattr = reiserfs_listxattr,
-        .removexattr = reiserfs_removexattr,
+        .removexattr = generic_removexattr,
         .permission = reiserfs_permission,
 };
 
@@ -1679,10 +1679,10 @@ const struct inode_operations reiserfs_symlink_inode_operations = {
  */
 const struct inode_operations reiserfs_special_inode_operations = {
         .setattr = reiserfs_setattr,
-        .setxattr = reiserfs_setxattr,
-        .getxattr = reiserfs_getxattr,
+        .setxattr = generic_setxattr,
+        .getxattr = generic_getxattr,
         .listxattr = reiserfs_listxattr,
-        .removexattr = reiserfs_removexattr,
+        .removexattr = generic_removexattr,
         .permission = reiserfs_permission,
         .get_acl = reiserfs_get_acl,
         .set_acl = reiserfs_set_acl,
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 28f5f8b11370..a33812ae9fad 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -764,60 +764,6 @@ find_xattr_handler_prefix(const struct xattr_handler **handlers,
         return xah;
 }
 
-
-/*
- * Inode operation getxattr()
- */
-ssize_t
-reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
-                  size_t size)
-{
-        const struct xattr_handler *handler;
-
-        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
-
-        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
-                return -EOPNOTSUPP;
-
-        return handler->get(handler, dentry, name, buffer, size);
-}
-
-/*
- * Inode operation setxattr()
- *
- * d_inode(dentry)->i_mutex down
- */
-int
-reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
-                  size_t size, int flags)
-{
-        const struct xattr_handler *handler;
-
-        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
-
-        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
-                return -EOPNOTSUPP;
-
-        return handler->set(handler, dentry, name, value, size, flags);
-}
-
-/*
- * Inode operation removexattr()
- *
- * d_inode(dentry)->i_mutex down
- */
-int reiserfs_removexattr(struct dentry *dentry, const char *name)
-{
-        const struct xattr_handler *handler;
-
-        handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
-
-        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
-                return -EOPNOTSUPP;
-
-        return handler->set(handler, dentry, name, NULL, 0, XATTR_REPLACE);
-}
-
 struct listxattr_buf {
         struct dir_context ctx;
         size_t size;
diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h
index 15dde6262c00..613ff5aef94e 100644
--- a/fs/reiserfs/xattr.h
+++ b/fs/reiserfs/xattr.h
@@ -2,6 +2,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/rwsem.h>
+#include <linux/xattr.h>
 
 struct inode;
 struct dentry;
@@ -18,12 +19,7 @@ int reiserfs_permission(struct inode *inode, int mask);
 
 #ifdef CONFIG_REISERFS_FS_XATTR
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
-ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name,
-                          void *buffer, size_t size);
-int reiserfs_setxattr(struct dentry *dentry, const char *name,
-                      const void *value, size_t size, int flags);
 ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
-int reiserfs_removexattr(struct dentry *dentry, const char *name);
 
 int reiserfs_xattr_get(struct inode *, const char *, void *, size_t);
 int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int);
@@ -92,10 +88,7 @@ static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
 
 #else
 
-#define reiserfs_getxattr NULL
-#define reiserfs_setxattr NULL
 #define reiserfs_listxattr NULL
-#define reiserfs_removexattr NULL
 
 static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
 {
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index 558a16beaacb..dbed42f755e0 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -197,10 +197,8 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
 
         size = reiserfs_xattr_get(inode, name, NULL, 0);
         if (size < 0) {
-                if (size == -ENODATA || size == -ENOSYS) {
-                        set_cached_acl(inode, type, NULL);
+                if (size == -ENODATA || size == -ENOSYS)
                         return NULL;
-                }
                 return ERR_PTR(size);
         }
 
@@ -220,8 +218,6 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
         } else {
                 acl = reiserfs_posix_acl_from_disk(value, retval);
         }
-        if (!IS_ERR(acl))
-                set_cached_acl(inode, type, acl);
 
         kfree(value);
         return acl;
@@ -370,7 +366,7 @@ int reiserfs_cache_default_acl(struct inode *inode)
         if (IS_PRIVATE(inode))
                 return 0;
 
-        acl = reiserfs_get_acl(inode, ACL_TYPE_DEFAULT);
+        acl = get_acl(inode, ACL_TYPE_DEFAULT);
 
         if (acl && !IS_ERR(acl)) {
                 int size = reiserfs_acl_size(acl->a_count);
diff --git a/fs/reiserfs/xattr_security.c b/fs/reiserfs/xattr_security.c
index ab0217d32039..86aeb9dd805a 100644
--- a/fs/reiserfs/xattr_security.c
+++ b/fs/reiserfs/xattr_security.c
@@ -9,29 +9,26 @@
 #include <linux/uaccess.h>
 
 static int
-security_get(const struct xattr_handler *handler, struct dentry *dentry,
-             const char *name, void *buffer, size_t size)
+security_get(const struct xattr_handler *handler, struct dentry *unused,
+             struct inode *inode, const char *name, void *buffer, size_t size)
 {
-        if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
-                return -EINVAL;
-
-        if (IS_PRIVATE(d_inode(dentry)))
+        if (IS_PRIVATE(inode))
                 return -EPERM;
 
-        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
+        return reiserfs_xattr_get(inode, xattr_full_name(handler, name),
+                                  buffer, size);
 }
 
 static int
 security_set(const struct xattr_handler *handler, struct dentry *dentry,
              const char *name, const void *buffer, size_t size, int flags)
 {
-        if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
-                return -EINVAL;
-
         if (IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry),
+                                  xattr_full_name(handler, name),
+                                  buffer, size, flags);
 }
 
 static bool security_list(struct dentry *dentry)
diff --git a/fs/reiserfs/xattr_trusted.c b/fs/reiserfs/xattr_trusted.c
index 64b67aa643a9..31837f031f59 100644
--- a/fs/reiserfs/xattr_trusted.c
+++ b/fs/reiserfs/xattr_trusted.c
@@ -8,29 +8,26 @@
 #include <linux/uaccess.h>
 
 static int
-trusted_get(const struct xattr_handler *handler, struct dentry *dentry,
-            const char *name, void *buffer, size_t size)
+trusted_get(const struct xattr_handler *handler, struct dentry *unused,
+            struct inode *inode, const char *name, void *buffer, size_t size)
 {
-        if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
-                return -EINVAL;
-
-        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
+        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(inode))
                 return -EPERM;
 
-        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
+        return reiserfs_xattr_get(inode, xattr_full_name(handler, name),
+                                  buffer, size);
 }
 
 static int
 trusted_set(const struct xattr_handler *handler, struct dentry *dentry,
             const char *name, const void *buffer, size_t size, int flags)
 {
-        if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
-                return -EINVAL;
-
         if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry),
+                                  xattr_full_name(handler, name),
+                                  buffer, size, flags);
 }
 
 static bool trusted_list(struct dentry *dentry)
diff --git a/fs/reiserfs/xattr_user.c b/fs/reiserfs/xattr_user.c
index 12e6306f562a..f7c39731684b 100644
--- a/fs/reiserfs/xattr_user.c
+++ b/fs/reiserfs/xattr_user.c
@@ -7,27 +7,24 @@
 #include <linux/uaccess.h>
 
 static int
-user_get(const struct xattr_handler *handler, struct dentry *dentry,
-         const char *name, void *buffer, size_t size)
+user_get(const struct xattr_handler *handler, struct dentry *unused,
+         struct inode *inode, const char *name, void *buffer, size_t size)
 {
-
-        if (strlen(name) < sizeof(XATTR_USER_PREFIX))
-                return -EINVAL;
-        if (!reiserfs_xattrs_user(dentry->d_sb))
+        if (!reiserfs_xattrs_user(inode->i_sb))
                 return -EOPNOTSUPP;
-        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
+        return reiserfs_xattr_get(inode, xattr_full_name(handler, name),
+                                  buffer, size);
 }
 
 static int
 user_set(const struct xattr_handler *handler, struct dentry *dentry,
          const char *name, const void *buffer, size_t size, int flags)
 {
-        if (strlen(name) < sizeof(XATTR_USER_PREFIX))
-                return -EINVAL;
-
         if (!reiserfs_xattrs_user(dentry->d_sb))
                 return -EOPNOTSUPP;
-        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry),
+                                  xattr_full_name(handler, name),
+                                  buffer, size, flags);
 }
 
 static bool user_list(struct dentry *dentry)
diff --git a/fs/squashfs/xattr.c b/fs/squashfs/xattr.c
index 1e9de96288d8..1548b3784548 100644
--- a/fs/squashfs/xattr.c
+++ b/fs/squashfs/xattr.c
@@ -214,10 +214,12 @@ failed:
 
 
 static int squashfs_xattr_handler_get(const struct xattr_handler *handler,
-                                      struct dentry *d, const char *name,
+                                      struct dentry *unused,
+                                      struct inode *inode,
+                                      const char *name,
                                       void *buffer, size_t size)
 {
-        return squashfs_xattr_get(d_inode(d), handler->flags, name,
+        return squashfs_xattr_get(inode, handler->flags, name,
                 buffer, size);
 }
 
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 4cd7e569cd00..12e79e60c176 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -1734,8 +1734,8 @@ int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 /* xattr.c */
 int ubifs_setxattr(struct dentry *dentry, const char *name,
                    const void *value, size_t size, int flags);
-ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
-                       size_t size);
+ssize_t ubifs_getxattr(struct dentry *dentry, struct inode *host,
+                       const char *name, void *buf, size_t size);
 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 int ubifs_removexattr(struct dentry *dentry, const char *name);
 int ubifs_init_security(struct inode *dentry, struct inode *inode,
diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c
index b043e044121d..413d650c9476 100644
--- a/fs/ubifs/xattr.c
+++ b/fs/ubifs/xattr.c
@@ -372,10 +372,10 @@ int ubifs_setxattr(struct dentry *dentry, const char *name,
         return setxattr(d_inode(dentry), name, value, size, flags);
 }
 
-ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
-                       size_t size)
+ssize_t ubifs_getxattr(struct dentry *dentry, struct inode *host,
+                       const char *name, void *buf, size_t size)
 {
-        struct inode *inode, *host = d_inode(dentry);
+        struct inode *inode;
         struct ubifs_info *c = host->i_sb->s_fs_info;
         struct qstr nm = QSTR_INIT(name, strlen(name));
         struct ubifs_inode *ui;
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index a2ba11eca995..c3e5c9679371 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -1250,7 +1250,7 @@ static struct dentry *udf_get_parent(struct dentry *child)
         brelse(fibh.sbh);
 
         tloc = lelb_to_cpu(cfi.icb.extLocation);
-        inode = udf_iget(d_inode(child)->i_sb, &tloc);
+        inode = udf_iget(child->d_sb, &tloc);
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 442fd52ebffe..f04ab232d08d 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -132,7 +132,7 @@ static struct dentry *ufs_get_parent(struct dentry *child)
         ino = ufs_inode_by_name(d_inode(child), &dot_dot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(ufs_iget(d_inode(child)->i_sb, ino));
+        return d_obtain_alias(ufs_iget(child->d_sb, ino));
 }
 
 static const struct export_operations ufs_export_ops = {
diff --git a/fs/xattr.c b/fs/xattr.c
index 4861322e28e8..b11945e15fde 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -192,7 +192,7 @@ vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
         if (!inode->i_op->getxattr)
                 return -EOPNOTSUPP;
 
-        error = inode->i_op->getxattr(dentry, name, NULL, 0);
+        error = inode->i_op->getxattr(dentry, inode, name, NULL, 0);
         if (error < 0)
                 return error;
 
@@ -203,7 +203,7 @@ vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
                 memset(value, 0, error + 1);
         }
 
-        error = inode->i_op->getxattr(dentry, name, value, error);
+        error = inode->i_op->getxattr(dentry, inode, name, value, error);
         *xattr_value = value;
         return error;
 }
@@ -236,7 +236,7 @@ vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
         }
 nolsm:
         if (inode->i_op->getxattr)
-                error = inode->i_op->getxattr(dentry, name, value, size);
+                error = inode->i_op->getxattr(dentry, inode, name, value, size);
         else
                 error = -EOPNOTSUPP;
 
@@ -691,14 +691,16 @@ xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
  * Find the handler for the prefix and dispatch its get() operation.
  */
 ssize_t
-generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
+generic_getxattr(struct dentry *dentry, struct inode *inode,
+                 const char *name, void *buffer, size_t size)
 {
         const struct xattr_handler *handler;
 
         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
         if (IS_ERR(handler))
                 return PTR_ERR(handler);
-        return handler->get(handler, dentry, name, buffer, size);
+        return handler->get(handler, dentry, inode,
+                            name, buffer, size);
 }
 
 /*
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 2d5df1f23bbc..b6e527b8eccb 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -158,22 +158,14 @@ xfs_get_acl(struct inode *inode, int type)
         if (error) {
                 /*
                  * If the attribute doesn't exist make sure we have a negative
-                 * cache entry, for any other error assume it is transient and
-                 * leave the cache entry as ACL_NOT_CACHED.
+                 * cache entry, for any other error assume it is transient.
                  */
-                if (error == -ENOATTR)
-                        goto out_update_cache;
-                acl = ERR_PTR(error);
-                goto out;
+                if (error != -ENOATTR)
+                        acl = ERR_PTR(error);
+        } else  {
+                acl = xfs_acl_from_disk(xfs_acl, len,
+                                        XFS_ACL_MAX_ENTRIES(ip->i_mount));
         }
-
-        acl = xfs_acl_from_disk(xfs_acl, len, XFS_ACL_MAX_ENTRIES(ip->i_mount));
-        if (IS_ERR(acl))
-                goto out;
-
-out_update_cache:
-        set_cached_acl(inode, type, acl);
-out:
         kmem_free(xfs_acl);
         return acl;
 }
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 110f1d7d86b0..d111f691f313 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -32,11 +32,11 @@
 
 
 static int
-xfs_xattr_get(const struct xattr_handler *handler, struct dentry *dentry,
-                const char *name, void *value, size_t size)
+xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused,
+                struct inode *inode, const char *name, void *value, size_t size)
 {
         int xflags = handler->flags;
-        struct xfs_inode *ip = XFS_I(d_inode(dentry));
+        struct xfs_inode *ip = XFS_I(inode);
         int error, asize = size;
 
         /* Convert Linux syscall to XFS internal ATTR flags */