Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs pile (part one) from Al Viro:
 "Assorted stuff - cleaning namei.c up a bit, fixing ->d_name/->d_parent
  locking violations, etc.

  The most visible changes here are death of FS_REVAL_DOT (replaced with
  "has ->d_weak_revalidate()") and a new helper getting from struct file
  to inode.  Some bits of preparation to xattr method interface changes.

  Misc patches by various people sent this cycle *and* ocfs2 fixes from
  several cycles ago that should've been upstream right then.

  PS: the next vfs pile will be xattr stuff."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (46 commits)
  saner proc_get_inode() calling conventions
  proc: avoid extra pde_put() in proc_fill_super()
  fs: change return values from -EACCES to -EPERM
  fs/exec.c: make bprm_mm_init() static
  ocfs2/dlm: use GFP_ATOMIC inside a spin_lock
  ocfs2: fix possible use-after-free with AIO
  ocfs2: Fix oops in ocfs2_fast_symlink_readpage() code path
  get_empty_filp()/alloc_file() leave both ->f_pos and ->f_version zero
  target: writev() on single-element vector is pointless
  export kernel_write(), convert open-coded instances
  fs: encode_fh: return FILEID_INVALID if invalid fid_type
  kill f_vfsmnt
  vfs: kill FS_REVAL_DOT by adding a d_weak_revalidate dentry op
  nfsd: handle vfs_getattr errors in acl protocol
  switch vfs_getattr() to struct path
  default SET_PERSONALITY() in linux/elf.h
  ceph: prepopulate inodes only when request is aborted
  d_hash_and_lookup(): export, switch open-coded instances
  9p: switch v9fs_set_create_acl() to inode+fid, do it before d_instantiate()
  9p: split dropping the acls from v9fs_set_create_acl()
  ...

199 files changed, 793 insertions, 775 deletions

diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 15b679166201..7af425f53bee 100644
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -23,6 +23,7 @@
 #include "acl.h"
 #include "v9fs.h"
 #include "v9fs_vfs.h"
+#include "fid.h"
 
 static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
 {
@@ -113,16 +114,12 @@ struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type)
 
 }
 
-static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
+static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl)
 {
         int retval;
         char *name;
         size_t size;
         void *buffer;
-        struct inode *inode = dentry->d_inode;
-
-        set_cached_acl(inode, type, acl);
-
         if (!acl)
                 return 0;
 
@@ -144,17 +141,16 @@ static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
         default:
                 BUG();
         }
-        retval = v9fs_xattr_set(dentry, name, buffer, size, 0);
+        retval = v9fs_fid_xattr_set(fid, name, buffer, size, 0);
 err_free_out:
         kfree(buffer);
         return retval;
 }
 
-int v9fs_acl_chmod(struct dentry *dentry)
+int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid)
 {
         int retval = 0;
         struct posix_acl *acl;
-        struct inode *inode = dentry->d_inode;
 
         if (S_ISLNK(inode->i_mode))
                 return -EOPNOTSUPP;
@@ -163,25 +159,30 @@ int v9fs_acl_chmod(struct dentry *dentry)
                 retval = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
                 if (retval)
                         return retval;
-                retval = v9fs_set_acl(dentry, ACL_TYPE_ACCESS, acl);
+                set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
+                retval = v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
                 posix_acl_release(acl);
         }
         return retval;
 }
 
-int v9fs_set_create_acl(struct dentry *dentry,
-                        struct posix_acl **dpacl, struct posix_acl **pacl)
+int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid,
+                        struct posix_acl *dacl, struct posix_acl *acl)
 {
-        if (dentry) {
-                v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, *dpacl);
-                v9fs_set_acl(dentry, ACL_TYPE_ACCESS, *pacl);
-        }
-        posix_acl_release(*dpacl);
-        posix_acl_release(*pacl);
-        *dpacl = *pacl = NULL;
+        set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
+        set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
+        v9fs_set_acl(fid, ACL_TYPE_DEFAULT, dacl);
+        v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
         return 0;
 }
 
+void v9fs_put_acl(struct posix_acl *dacl,
+                  struct posix_acl *acl)
+{
+        posix_acl_release(dacl);
+        posix_acl_release(acl);
+}
+
 int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                   struct posix_acl **dpacl, struct posix_acl **pacl)
 {
diff --git a/fs/9p/acl.h b/fs/9p/acl.h
index 559556411965..e4f7e882272b 100644
--- a/fs/9p/acl.h
+++ b/fs/9p/acl.h
@@ -17,27 +17,33 @@
 #ifdef CONFIG_9P_FS_POSIX_ACL
 extern int v9fs_get_acl(struct inode *, struct p9_fid *);
 extern struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type);
-extern int v9fs_acl_chmod(struct dentry *);
-extern int v9fs_set_create_acl(struct dentry *,
-                               struct posix_acl **, struct posix_acl **);
+extern int v9fs_acl_chmod(struct inode *, struct p9_fid *);
+extern int v9fs_set_create_acl(struct inode *, struct p9_fid *,
+                               struct posix_acl *, struct posix_acl *);
 extern int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                          struct posix_acl **dpacl, struct posix_acl **pacl);
+extern void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);
 #else
 #define v9fs_iop_get_acl NULL
 static inline int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
 {
         return 0;
 }
-static inline int v9fs_acl_chmod(struct dentry *dentry)
+static inline int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid)
 {
         return 0;
 }
-static inline int v9fs_set_create_acl(struct dentry *dentry,
-                                      struct posix_acl **dpacl,
-                                      struct posix_acl **pacl)
+static inline int v9fs_set_create_acl(struct inode *inode,
+                                      struct p9_fid *fid,
+                                      struct posix_acl *dacl,
+                                      struct posix_acl *acl)
 {
         return 0;
 }
+static inline void v9fs_put_acl(struct posix_acl *dacl,
+                                struct posix_acl *acl)
+{
+}
 static inline int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                                 struct posix_acl **dpacl,
                                 struct posix_acl **pacl)
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index 64600b5d0522..9ad68628522c 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -137,6 +137,7 @@ out_valid:
 
 const struct dentry_operations v9fs_cached_dentry_operations = {
         .d_revalidate = v9fs_lookup_revalidate,
+        .d_weak_revalidate = v9fs_lookup_revalidate,
         .d_delete = v9fs_cached_dentry_delete,
         .d_release = v9fs_dentry_release,
 };
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index c921ac92ea4c..d384a8b77ee8 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -129,7 +129,7 @@ out_error:
 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
         int res = 0;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 
@@ -298,7 +298,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
 
 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = -ENOLCK;
 
         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
@@ -334,7 +334,7 @@ out_err:
 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
         struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = -ENOLCK;
 
         p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
@@ -525,7 +525,7 @@ v9fs_file_write(struct file *filp, const char __user * data,
         if (!count)
                 goto out;
 
-        retval = v9fs_file_write_internal(filp->f_path.dentry->d_inode,
+        retval = v9fs_file_write_internal(file_inode(filp),
                                         filp->private_data,
                                         data, count, &origin, 1);
         /* update offset on successful write */
@@ -600,7 +600,7 @@ v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         struct v9fs_inode *v9inode;
         struct page *page = vmf->page;
         struct file *filp = vma->vm_file;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
 
         p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n",
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 07f409288d1b..61e4fa70a6fa 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -330,14 +330,14 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
                 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", err);
                 goto error;
         }
+        /* Now set the ACL based on the default value */
+        v9fs_set_create_acl(inode, fid, dacl, pacl);
+
         err = v9fs_fid_add(dentry, fid);
         if (err < 0)
                 goto error;
         d_instantiate(dentry, inode);
 
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
-
         v9inode = V9FS_I(inode);
         mutex_lock(&v9inode->v_mutex);
         if (v9ses->cache && !v9inode->writeback_fid &&
@@ -369,6 +369,7 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
 #endif
         *opened |= FILE_CREATED;
 out:
+        v9fs_put_acl(dacl, pacl);
         dput(res);
         return err;
 
@@ -378,7 +379,6 @@ error:
 err_clunk_old_fid:
         if (ofid)
                 p9_client_clunk(ofid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
         goto out;
 }
 
@@ -435,17 +435,17 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
         if (err < 0)
                 goto error;
 
+        fid = p9_client_walk(dfid, 1, &name, 1);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
+                         err);
+                fid = NULL;
+                goto error;
+        }
+
         /* instantiate inode and assign the unopened fid to the dentry */
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                fid = p9_client_walk(dfid, 1, &name, 1);
-                if (IS_ERR(fid)) {
-                        err = PTR_ERR(fid);
-                        p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
-                                 err);
-                        fid = NULL;
-                        goto error;
-                }
-
                 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                 if (IS_ERR(inode)) {
                         err = PTR_ERR(inode);
@@ -456,6 +456,7 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
                         goto error;
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
                 fid = NULL;
         } else {
@@ -469,16 +470,15 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                         err = PTR_ERR(inode);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
         }
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
         inc_nlink(dir);
         v9fs_invalidate_inode_attr(dir);
 error:
         if (fid)
                 p9_client_clunk(fid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
+        v9fs_put_acl(dacl, pacl);
         return err;
 }
 
@@ -572,10 +572,11 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
         struct v9fs_session_info *v9ses;
         struct p9_fid *fid;
         struct p9_iattr_dotl p9attr;
+        struct inode *inode = dentry->d_inode;
 
         p9_debug(P9_DEBUG_VFS, "\n");
 
-        retval = inode_change_ok(dentry->d_inode, iattr);
+        retval = inode_change_ok(inode, iattr);
         if (retval)
                 return retval;
 
@@ -596,23 +597,23 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
                 return PTR_ERR(fid);
 
         /* Write all dirty data */
-        if (S_ISREG(dentry->d_inode->i_mode))
-                filemap_write_and_wait(dentry->d_inode->i_mapping);
+        if (S_ISREG(inode->i_mode))
+                filemap_write_and_wait(inode->i_mapping);
 
         retval = p9_client_setattr(fid, &p9attr);
         if (retval < 0)
                 return retval;
 
         if ((iattr->ia_valid & ATTR_SIZE) &&
-            iattr->ia_size != i_size_read(dentry->d_inode))
-                truncate_setsize(dentry->d_inode, iattr->ia_size);
+            iattr->ia_size != i_size_read(inode))
+                truncate_setsize(inode, iattr->ia_size);
 
-        v9fs_invalidate_inode_attr(dentry->d_inode);
-        setattr_copy(dentry->d_inode, iattr);
-        mark_inode_dirty(dentry->d_inode);
+        v9fs_invalidate_inode_attr(inode);
+        setattr_copy(inode, iattr);
+        mark_inode_dirty(inode);
         if (iattr->ia_valid & ATTR_MODE) {
                 /* We also want to update ACL when we update mode bits */
-                retval = v9fs_acl_chmod(dentry);
+                retval = v9fs_acl_chmod(inode, fid);
                 if (retval < 0)
                         return retval;
         }
@@ -880,17 +881,17 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                 goto error;
 
         v9fs_invalidate_inode_attr(dir);
+        fid = p9_client_walk(dfid, 1, &name, 1);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
+                         err);
+                fid = NULL;
+                goto error;
+        }
+
         /* instantiate inode and assign the unopened fid to the dentry */
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                fid = p9_client_walk(dfid, 1, &name, 1);
-                if (IS_ERR(fid)) {
-                        err = PTR_ERR(fid);
-                        p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
-                                 err);
-                        fid = NULL;
-                        goto error;
-                }
-
                 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
                 if (IS_ERR(inode)) {
                         err = PTR_ERR(inode);
@@ -898,6 +899,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                                  err);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
                         goto error;
@@ -913,14 +915,13 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
                         err = PTR_ERR(inode);
                         goto error;
                 }
+                v9fs_set_create_acl(inode, fid, dacl, pacl);
                 d_instantiate(dentry, inode);
         }
-        /* Now set the ACL based on the default value */
-        v9fs_set_create_acl(dentry, &dacl, &pacl);
 error:
         if (fid)
                 p9_client_clunk(fid);
-        v9fs_set_create_acl(NULL, &dacl, &pacl);
+        v9fs_put_acl(dacl, pacl);
         return err;
 }
 
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 137d50396898..91dad63e5a2d 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -363,5 +363,5 @@ struct file_system_type v9fs_fs_type = {
         .mount = v9fs_mount,
         .kill_sb = v9fs_kill_super,
         .owner = THIS_MODULE,
-        .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT,
+        .fs_flags = FS_RENAME_DOES_D_MOVE,
 };
diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index 29653b70a9c3..c45e016b190f 100644
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -111,19 +111,26 @@ ssize_t v9fs_xattr_get(struct dentry *dentry, const char *name,
 int v9fs_xattr_set(struct dentry *dentry, const char *name,
                    const void *value, size_t value_len, int flags)
 {
+        struct p9_fid *fid = v9fs_fid_lookup(dentry);
+        if (IS_ERR(fid))
+                return PTR_ERR(fid);
+        return v9fs_fid_xattr_set(fid, name, value, value_len, flags);
+}
+
+int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
+                   const void *value, size_t value_len, int flags)
+{
         u64 offset = 0;
         int retval, msize, write_count;
-        struct p9_fid *fid = NULL;
 
         p9_debug(P9_DEBUG_VFS, "name = %s value_len = %zu flags = %d\n",
                  name, value_len, flags);
 
-        fid = v9fs_fid_clone(dentry);
-        if (IS_ERR(fid)) {
-                retval = PTR_ERR(fid);
-                fid = NULL;
-                goto error;
-        }
+        /* Clone it */
+        fid = p9_client_walk(fid, 0, NULL, 1);
+        if (IS_ERR(fid))
+                return PTR_ERR(fid);
+
         /*
          * On success fid points to xattr
          */
@@ -131,7 +138,8 @@ int v9fs_xattr_set(struct dentry *dentry, const char *name,
         if (retval < 0) {
                 p9_debug(P9_DEBUG_VFS, "p9_client_xattrcreate failed %d\n",
                          retval);
-                goto error;
+                p9_client_clunk(fid);
+                return retval;
         }
         msize = fid->clnt->msize;
         while (value_len) {
@@ -144,17 +152,12 @@ int v9fs_xattr_set(struct dentry *dentry, const char *name,
                 if (write_count < 0) {
                         /* error in xattr write */
                         retval = write_count;
-                        goto error;
+                        break;
                 }
                 offset += write_count;
                 value_len -= write_count;
         }
-        /* Total read xattr bytes */
-        retval = offset;
-error:
-        if (fid)
-                retval = p9_client_clunk(fid);
-        return retval;
+        return p9_client_clunk(fid);
 }
 
 ssize_t v9fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
diff --git a/fs/9p/xattr.h b/fs/9p/xattr.h
index eaa837c53bd5..eec348a3df71 100644
--- a/fs/9p/xattr.h
+++ b/fs/9p/xattr.h
@@ -27,6 +27,8 @@ extern ssize_t v9fs_fid_xattr_get(struct p9_fid *, const char *,
                                   void *, size_t);
 extern ssize_t v9fs_xattr_get(struct dentry *, const char *,
                               void *, size_t);
+extern int v9fs_fid_xattr_set(struct p9_fid *, const char *,
+                          const void *, size_t, int);
 extern int v9fs_xattr_set(struct dentry *, const char *,
                           const void *, size_t, int);
 extern ssize_t v9fs_listxattr(struct dentry *, char *, size_t);
diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index b3be2e7c5643..9cf874ce8336 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -19,7 +19,7 @@ static DEFINE_RWLOCK(adfs_dir_lock);
 static int
 adfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
         struct object_info obj;
diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index 8ca8f3a55599..fd11a6d608ee 100644
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -42,7 +42,7 @@ const struct inode_operations affs_dir_inode_operations = {
 static int
 affs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode            *inode = filp->f_path.dentry->d_inode;
+        struct inode            *inode = file_inode(filp);
         struct super_block      *sb = inode->i_sb;
         struct buffer_head      *dir_bh;
         struct buffer_head      *fh_bh;
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index db477906ba4f..7a465ed04444 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -393,12 +393,12 @@ static int afs_readdir(struct file *file, void *cookie, filldir_t filldir)
         int ret;
 
         _enter("{%Ld,{%lu}}",
-               file->f_pos, file->f_path.dentry->d_inode->i_ino);
+               file->f_pos, file_inode(file)->i_ino);
 
         ASSERT(file->private_data != NULL);
 
         fpos = file->f_pos;
-        ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos,
+        ret = afs_dir_iterate(file_inode(file), &fpos,
                               cookie, filldir, file->private_data);
         file->f_pos = fpos;
 
diff --git a/fs/afs/flock.c b/fs/afs/flock.c
index 757d664575dd..2497bf306c70 100644
--- a/fs/afs/flock.c
+++ b/fs/afs/flock.c
@@ -514,7 +514,7 @@ error:
  */
 int afs_lock(struct file *file, int cmd, struct file_lock *fl)
 {
-        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
 
         _enter("{%x:%u},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
                vnode->fid.vid, vnode->fid.vnode, cmd,
@@ -537,7 +537,7 @@ int afs_lock(struct file *file, int cmd, struct file_lock *fl)
  */
 int afs_flock(struct file *file, int cmd, struct file_lock *fl)
 {
-        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
 
         _enter("{%x:%u},%d,{t=%x,fl=%x}",
                vnode->fid.vid, vnode->fid.vnode, cmd,
diff --git a/fs/afs/write.c b/fs/afs/write.c
index 9aa52d93c73c..7e03eadb40c0 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -120,7 +120,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
                     struct page **pagep, void **fsdata)
 {
         struct afs_writeback *candidate, *wb;
-        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
         struct page *page;
         struct key *key = file->private_data;
         unsigned from = pos & (PAGE_CACHE_SIZE - 1);
@@ -245,7 +245,7 @@ int afs_write_end(struct file *file, struct address_space *mapping,
                   loff_t pos, unsigned len, unsigned copied,
                   struct page *page, void *fsdata)
 {
-        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
         loff_t i_size, maybe_i_size;
 
         _enter("{%x:%u},{%lx}",
@@ -627,8 +627,7 @@ void afs_pages_written_back(struct afs_vnode *vnode, struct afs_call *call)
 ssize_t afs_file_write(struct kiocb *iocb, const struct iovec *iov,
                        unsigned long nr_segs, loff_t pos)
 {
-        struct dentry *dentry = iocb->ki_filp->f_path.dentry;
-        struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(file_inode(iocb->ki_filp));
         ssize_t result;
         size_t count = iov_length(iov, nr_segs);
 
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 28d39fb84ae3..47a65df8c871 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -131,7 +131,6 @@ struct file *anon_inode_getfile(const char *name,
         struct qstr this;
         struct path path;
         struct file *file;
-        int error;
 
         if (IS_ERR(anon_inode_inode))
                 return ERR_PTR(-ENODEV);
@@ -143,7 +142,7 @@ struct file *anon_inode_getfile(const char *name,
          * Link the inode to a directory entry by creating a unique name
          * using the inode sequence number.
          */
-        error = -ENOMEM;
+        file = ERR_PTR(-ENOMEM);
         this.name = name;
         this.len = strlen(name);
         this.hash = 0;
@@ -160,15 +159,12 @@ struct file *anon_inode_getfile(const char *name,
 
         d_instantiate(path.dentry, anon_inode_inode);
 
-        error = -ENFILE;
         file = alloc_file(&path, OPEN_FMODE(flags), fops);
-        if (!file)
+        if (IS_ERR(file))
                 goto err_dput;
         file->f_mapping = anon_inode_inode->i_mapping;
 
-        file->f_pos = 0;
         file->f_flags = flags & (O_ACCMODE | O_NONBLOCK);
-        file->f_version = 0;
         file->private_data = priv;
 
         return file;
@@ -177,7 +173,7 @@ err_dput:
         path_put(&path);
 err_module:
         module_put(fops->owner);
-        return ERR_PTR(error);
+        return file;
 }
 EXPORT_SYMBOL_GPL(anon_inode_getfile);
 
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index b785e7707959..3f1128b37e46 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -273,7 +273,7 @@ static inline int autofs_prepare_pipe(struct file *pipe)
 {
         if (!pipe->f_op || !pipe->f_op->write)
                 return -EINVAL;
-        if (!S_ISFIFO(pipe->f_dentry->d_inode->i_mode))
+        if (!S_ISFIFO(file_inode(pipe)->i_mode))
                 return -EINVAL;
         /* We want a packet pipe */
         pipe->f_flags |= O_DIRECT;
diff --git a/fs/autofs4/dev-ioctl.c b/fs/autofs4/dev-ioctl.c
index 9f68a37bb2b2..743c7c2c949d 100644
--- a/fs/autofs4/dev-ioctl.c
+++ b/fs/autofs4/dev-ioctl.c
@@ -159,7 +159,7 @@ static struct autofs_sb_info *autofs_dev_ioctl_sbi(struct file *f)
         struct inode *inode;
 
         if (f) {
-                inode = f->f_path.dentry->d_inode;
+                inode = file_inode(f);
                 sbi = autofs4_sbi(inode->i_sb);
         }
         return sbi;
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index c93447604da8..230bd2aad4f4 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -587,7 +587,7 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
         
         /* This allows root to remove symlinks */
         if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         if (atomic_dec_and_test(&ino->count)) {
                 p_ino = autofs4_dentry_ino(dentry->d_parent);
@@ -874,7 +874,7 @@ static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp,
 static long autofs4_root_ioctl(struct file *filp,
                                unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
 }
 
@@ -882,7 +882,7 @@ static long autofs4_root_ioctl(struct file *filp,
 static long autofs4_root_compat_ioctl(struct file *filp,
                              unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret;
 
         if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 2b3bda8d5e68..c8f4e25eb9e2 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -213,7 +213,7 @@ befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 static int
 befs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;
         befs_off_t value;
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 2785ef91191a..3f422f6bb5ca 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -28,7 +28,7 @@ static struct buffer_head *bfs_find_entry(struct inode *dir,
 
 static int bfs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
-        struct inode *dir = f->f_path.dentry->d_inode;
+        struct inode *dir = file_inode(f);
         struct buffer_head *bh;
         struct bfs_dirent *de;
         struct bfs_sb_info *info = BFS_SB(dir->i_sb);
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 6043567b95c2..bbc8f8827eac 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -214,7 +214,7 @@ static int load_aout_binary(struct linux_binprm * bprm)
         if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
              N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
             N_TRSIZE(ex) || N_DRSIZE(ex) ||
-            i_size_read(bprm->file->f_path.dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
+            i_size_read(file_inode(bprm->file)) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
                 return -ENOEXEC;
         }
 
@@ -367,7 +367,7 @@ static int load_aout_library(struct file *file)
         int retval;
         struct exec ex;
 
-        inode = file->f_path.dentry->d_inode;
+        inode = file_inode(file);
 
         retval = -ENOEXEC;
         error = kernel_read(file, 0, (char *) &ex, sizeof(ex));
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index ff9dbc630efa..a5702d74d2bd 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1141,7 +1141,7 @@ static unsigned long vma_dump_size(struct vm_area_struct *vma,
 
         /* By default, dump shared memory if mapped from an anonymous file. */
         if (vma->vm_flags & VM_SHARED) {
-                if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0 ?
+                if (file_inode(vma->vm_file)->i_nlink == 0 ?
                     FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
                         goto whole;
                 return 0;
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index cb240dd3b402..9c13e023e2b7 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -909,7 +909,7 @@ static int elf_fdpic_map_file(struct elf_fdpic_params *params,
 
 dynamic_error:
         printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
-               what, file->f_path.dentry->d_inode->i_ino);
+               what, file_inode(file)->i_ino);
         return -ELIBBAD;
 }
 
@@ -1219,7 +1219,7 @@ static int maydump(struct vm_area_struct *vma, unsigned long mm_flags)
 
         /* By default, dump shared memory if mapped from an anonymous file. */
         if (vma->vm_flags & VM_SHARED) {
-                if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0) {
+                if (file_inode(vma->vm_file)->i_nlink == 0) {
                         dump_ok = test_bit(MMF_DUMP_ANON_SHARED, &mm_flags);
                         kdcore("%08lx: %08lx: %s (share)", vma->vm_start,
                                vma->vm_flags, dump_ok ? "yes" : "no");
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index b56371981d16..2036d21baaef 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -438,7 +438,7 @@ static int load_flat_file(struct linux_binprm * bprm,
         int ret;
 
         hdr = ((struct flat_hdr *) bprm->buf);          /* exec-header */
-        inode = bprm->file->f_path.dentry->d_inode;
+        inode = file_inode(bprm->file);
 
         text_len  = ntohl(hdr->data_start);
         data_len  = ntohl(hdr->data_end) - ntohl(hdr->data_start);
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 0c8869fdd14e..fecbbf3f8ff2 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -531,7 +531,7 @@ static void kill_node(Node *e)
 static ssize_t
 bm_entry_read(struct file * file, char __user * buf, size_t nbytes, loff_t *ppos)
 {
-        Node *e = file->f_path.dentry->d_inode->i_private;
+        Node *e = file_inode(file)->i_private;
         ssize_t res;
         char *page;
 
@@ -550,7 +550,7 @@ static ssize_t bm_entry_write(struct file *file, const char __user *buffer,
                                 size_t count, loff_t *ppos)
 {
         struct dentry *root;
-        Node *e = file->f_path.dentry->d_inode->i_private;
+        Node *e = file_inode(file)->i_private;
         int res = parse_command(buffer, count);
 
         switch (res) {
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 78333a37f49d..53f5fae5cfbe 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -318,7 +318,7 @@ static int blkdev_write_end(struct file *file, struct address_space *mapping,
 
 /*
  * private llseek:
- * for a block special file file->f_path.dentry->d_inode->i_size is zero
+ * for a block special file file_inode(file)->i_size is zero
  * so we compute the size by hand (just as in block_read/write above)
  */
 static loff_t block_llseek(struct file *file, loff_t offset, int whence)
diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index 614f34a899c2..81ee29eeb7ca 100644
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -22,10 +22,10 @@ static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
 
         if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
                 *max_len = BTRFS_FID_SIZE_CONNECTABLE;
-                return 255;
+                return FILEID_INVALID;
         } else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
                 *max_len = BTRFS_FID_SIZE_NON_CONNECTABLE;
-                return 255;
+                return FILEID_INVALID;
         }
 
         len  = BTRFS_FID_SIZE_NON_CONNECTABLE;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index aeb84469d2c4..4b241fe9d2fe 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1225,7 +1225,7 @@ static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
         struct extent_state *cached_state = NULL;
         int i;
         unsigned long index = pos >> PAGE_CACHE_SHIFT;
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
         int err = 0;
         int faili = 0;
@@ -1312,7 +1312,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                                                struct iov_iter *i,
                                                loff_t pos)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct page **pages = NULL;
         unsigned long first_index;
@@ -1500,7 +1500,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                                     unsigned long nr_segs, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         loff_t *ppos = &iocb->ki_pos;
         u64 start_pos;
@@ -2102,7 +2102,7 @@ out:
 static long btrfs_fallocate(struct file *file, int mode,
                             loff_t offset, loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct extent_state *cached_state = NULL;
         u64 cur_offset;
         u64 last_byte;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index cc93b23ca352..55c07b650378 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4391,7 +4391,7 @@ unsigned char btrfs_filetype_table[] = {
 static int btrfs_real_readdir(struct file *filp, void *dirent,
                               filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_item *item;
         struct btrfs_dir_item *di;
@@ -6791,7 +6791,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct page *page = vmf->page;
-        struct inode *inode = fdentry(vma->vm_file)->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_ordered_extent *ordered;
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 338f2597bf7f..c3f09f71bedd 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -152,7 +152,7 @@ void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
 
 static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
 {
-        struct btrfs_inode *ip = BTRFS_I(file->f_path.dentry->d_inode);
+        struct btrfs_inode *ip = BTRFS_I(file_inode(file));
         unsigned int flags = btrfs_flags_to_ioctl(ip->flags);
 
         if (copy_to_user(arg, &flags, sizeof(flags)))
@@ -177,7 +177,7 @@ static int check_flags(unsigned int flags)
 
 static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_inode *ip = BTRFS_I(inode);
         struct btrfs_root *root = ip->root;
         struct btrfs_trans_handle *trans;
@@ -310,7 +310,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 
 static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         return put_user(inode->i_generation, arg);
 }
@@ -1320,7 +1320,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
         u64 new_size;
         u64 old_size;
         u64 devid = 1;
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_vol_args *vol_args;
         struct btrfs_trans_handle *trans;
         struct btrfs_device *device = NULL;
@@ -1489,8 +1489,8 @@ static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
                         goto out_drop_write;
                 }
 
-                src_inode = src.file->f_path.dentry->d_inode;
-                if (src_inode->i_sb != file->f_path.dentry->d_inode->i_sb) {
+                src_inode = file_inode(src.file);
+                if (src_inode->i_sb != file_inode(file)->i_sb) {
                         printk(KERN_INFO "btrfs: Snapshot src from "
                                "another FS\n");
                         ret = -EINVAL;
@@ -1582,7 +1582,7 @@ out:
 static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
                                                 void __user *arg)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret = 0;
         u64 flags = 0;
@@ -1604,7 +1604,7 @@ static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
 static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
                                               void __user *arg)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         u64 root_flags;
@@ -1898,7 +1898,7 @@ static noinline int btrfs_ioctl_tree_search(struct file *file,
         if (IS_ERR(args))
                 return PTR_ERR(args);
 
-        inode = fdentry(file)->d_inode;
+        inode = file_inode(file);
         ret = search_ioctl(inode, args);
         if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
                 ret = -EFAULT;
@@ -2008,7 +2008,7 @@ static noinline int btrfs_ioctl_ino_lookup(struct file *file,
         if (IS_ERR(args))
                 return PTR_ERR(args);
 
-        inode = fdentry(file)->d_inode;
+        inode = file_inode(file);
 
         if (args->treeid == 0)
                 args->treeid = BTRFS_I(inode)->root->root_key.objectid;
@@ -2184,7 +2184,7 @@ out:
 
 static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_ioctl_defrag_range_args *range;
         int ret;
@@ -2244,7 +2244,7 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
                         /* the rest are all set to zero by kzalloc */
                         range->len = (u64)-1;
                 }
-                ret = btrfs_defrag_file(fdentry(file)->d_inode, file,
+                ret = btrfs_defrag_file(file_inode(file), file,
                                         range, 0, 0);
                 if (ret > 0)
                         ret = 0;
@@ -2292,7 +2292,7 @@ out:
 
 static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_vol_args *vol_args;
         int ret;
 
@@ -2415,7 +2415,7 @@ out:
 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                        u64 off, u64 olen, u64 destoff)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct fd src_file;
         struct inode *src;
@@ -2461,7 +2461,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         if (src_file.file->f_path.mnt != file->f_path.mnt)
                 goto out_fput;
 
-        src = src_file.file->f_dentry->d_inode;
+        src = file_inode(src_file.file);
 
         ret = -EINVAL;
         if (src == inode)
@@ -2823,7 +2823,7 @@ static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
  */
 static long btrfs_ioctl_trans_start(struct file *file)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -2863,7 +2863,7 @@ out:
 
 static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_root *new_root;
         struct btrfs_dir_item *di;
@@ -3087,7 +3087,7 @@ out:
  */
 long btrfs_ioctl_trans_end(struct file *file)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
 
@@ -3149,7 +3149,7 @@ static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root,
 
 static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_scrub_args *sa;
         int ret;
 
@@ -3440,7 +3440,7 @@ void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
 
 static long btrfs_ioctl_balance(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_fs_info *fs_info = root->fs_info;
         struct btrfs_ioctl_balance_args *bargs;
         struct btrfs_balance_control *bctl;
@@ -3630,7 +3630,7 @@ out:
 
 static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_quota_ctl_args *sa;
         struct btrfs_trans_handle *trans = NULL;
         int ret;
@@ -3689,7 +3689,7 @@ drop_write:
 
 static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_qgroup_assign_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3736,7 +3736,7 @@ drop_write:
 
 static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_qgroup_create_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3787,7 +3787,7 @@ drop_write:
 
 static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         struct btrfs_ioctl_qgroup_limit_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3837,7 +3837,7 @@ static long btrfs_ioctl_set_received_subvol(struct file *file,
                                             void __user *arg)
 {
         struct btrfs_ioctl_received_subvol_args *sa = NULL;
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_root_item *root_item = &root->root_item;
         struct btrfs_trans_handle *trans;
@@ -3917,7 +3917,7 @@ out:
 long btrfs_ioctl(struct file *file, unsigned int
                 cmd, unsigned long arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
         void __user *argp = (void __user *)arg;
 
         switch (cmd) {
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 321b7fb4e441..f4ab7a9260eb 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -4544,7 +4544,7 @@ long btrfs_ioctl_send(struct file *mnt_file, void __user *arg_)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        send_root = BTRFS_I(fdentry(mnt_file)->d_inode)->root;
+        send_root = BTRFS_I(file_inode(mnt_file))->root;
         fs_info = send_root->fs_info;
 
         arg = memdup_user(arg_, sizeof(*arg));
diff --git a/fs/buffer.c b/fs/buffer.c
index 62169c192c21..8e18281b4077 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2332,7 +2332,7 @@ int __block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
                          get_block_t get_block)
 {
         struct page *page = vmf->page;
-        struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         unsigned long end;
         loff_t size;
         int ret;
@@ -2371,7 +2371,7 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
                    get_block_t get_block)
 {
         int ret;
-        struct super_block *sb = vma->vm_file->f_path.dentry->d_inode->i_sb;
+        struct super_block *sb = file_inode(vma->vm_file)->i_sb;
 
         sb_start_pagefault(sb);
 
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 064d1a68d2c1..d4f81edd9a5d 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -195,7 +195,7 @@ static int ceph_releasepage(struct page *page, gfp_t g)
  */
 static int readpage_nounlock(struct file *filp, struct page *page)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_osd_client *osdc = 
                 &ceph_inode_to_client(inode)->client->osdc;
@@ -370,7 +370,7 @@ out:
 static int ceph_readpages(struct file *file, struct address_space *mapping,
                           struct list_head *page_list, unsigned nr_pages)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         int rc = 0;
         int max = 0;
@@ -977,7 +977,7 @@ static int ceph_update_writeable_page(struct file *file,
                             loff_t pos, unsigned len,
                             struct page *page)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
         loff_t page_off = pos & PAGE_CACHE_MASK;
@@ -1086,7 +1086,7 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
                             loff_t pos, unsigned len, unsigned flags,
                             struct page **pagep, void **fsdata)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_file_info *fi = file->private_data;
         struct page *page;
@@ -1144,7 +1144,7 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
                           loff_t pos, unsigned len, unsigned copied,
                           struct page *page, void *fsdata)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -1228,7 +1228,7 @@ const struct address_space_operations ceph_aops = {
  */
 static int ceph_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct page *page = vmf->page;
         struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
         loff_t off = page_offset(page);
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 8c1aabe93b67..6d797f46d772 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -238,7 +238,7 @@ static int note_last_dentry(struct ceph_file_info *fi, const char *name,
 static int ceph_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         struct ceph_file_info *fi = filp->private_data;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -1138,7 +1138,7 @@ static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size,
                              loff_t *ppos)
 {
         struct ceph_file_info *cf = file->private_data;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         int left;
         const int bufsize = 1024;
@@ -1188,7 +1188,7 @@ static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size,
 static int ceph_dir_fsync(struct file *file, loff_t start, loff_t end,
                           int datasync)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct list_head *head = &ci->i_unsafe_dirops;
         struct ceph_mds_request *req;
diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index ca3ab3f9ca70..16796be53ca5 100644
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -81,7 +81,7 @@ static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
                 if (parent_inode) {
                         /* nfsd wants connectable */
                         *max_len = connected_handle_length;
-                        type = 255;
+                        type = FILEID_INVALID;
                 } else {
                         dout("encode_fh %p\n", dentry);
                         fh->ino = ceph_ino(inode);
@@ -90,7 +90,7 @@ static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
                 }
         } else {
                 *max_len = handle_length;
-                type = 255;
+                type = FILEID_INVALID;
         }
         if (dentry)
                 dput(dentry);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index e51558fca3a3..11b57c2c8f15 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -393,7 +393,7 @@ more:
 static ssize_t ceph_sync_read(struct file *file, char __user *data,
                               unsigned len, loff_t *poff, int *checkeof)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct page **pages;
         u64 off = *poff;
         int num_pages, ret;
@@ -466,7 +466,7 @@ static void sync_write_commit(struct ceph_osd_request *req,
 static ssize_t ceph_sync_write(struct file *file, const char __user *data,
                                size_t left, loff_t *offset)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
         struct ceph_osd_request *req;
@@ -483,7 +483,7 @@ static ssize_t ceph_sync_write(struct file *file, const char __user *data,
         int ret;
         struct timespec mtime = CURRENT_TIME;
 
-        if (ceph_snap(file->f_dentry->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
                 return -EROFS;
 
         dout("sync_write on file %p %lld~%u %s\n", file, *offset,
@@ -637,7 +637,7 @@ static ssize_t ceph_aio_read(struct kiocb *iocb, const struct iovec *iov,
         struct ceph_file_info *fi = filp->private_data;
         loff_t *ppos = &iocb->ki_pos;
         size_t len = iov->iov_len;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ceph_inode_info *ci = ceph_inode(inode);
         void __user *base = iov->iov_base;
         ssize_t ret;
@@ -707,7 +707,7 @@ static ssize_t ceph_aio_write(struct kiocb *iocb, const struct iovec *iov,
 {
         struct file *file = iocb->ki_filp;
         struct ceph_file_info *fi = file->private_data;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_osd_client *osdc =
                 &ceph_sb_to_client(inode->i_sb)->client->osdc;
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index d45895f4a04d..851814d951cd 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -1131,8 +1131,8 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                                             req->r_request_started);
                 dout(" final dn %p\n", dn);
                 i++;
-        } else if (req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
-                   req->r_op == CEPH_MDS_OP_MKSNAP) {
+        } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
+                   req->r_op == CEPH_MDS_OP_MKSNAP) && !req->r_aborted) {
                 struct dentry *dn = req->r_dentry;
 
                 /* fill out a snapdir LOOKUPSNAP dentry */
@@ -1196,6 +1196,39 @@ done:
 /*
  * Prepopulate our cache with readdir results, leases, etc.
  */
+static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req,
+                                           struct ceph_mds_session *session)
+{
+        struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
+        int i, err = 0;
+
+        for (i = 0; i < rinfo->dir_nr; i++) {
+                struct ceph_vino vino;
+                struct inode *in;
+                int rc;
+
+                vino.ino = le64_to_cpu(rinfo->dir_in[i].in->ino);
+                vino.snap = le64_to_cpu(rinfo->dir_in[i].in->snapid);
+
+                in = ceph_get_inode(req->r_dentry->d_sb, vino);
+                if (IS_ERR(in)) {
+                        err = PTR_ERR(in);
+                        dout("new_inode badness got %d\n", err);
+                        continue;
+                }
+                rc = fill_inode(in, &rinfo->dir_in[i], NULL, session,
+                                req->r_request_started, -1,
+                                &req->r_caps_reservation);
+                if (rc < 0) {
+                        pr_err("fill_inode badness on %p got %d\n", in, rc);
+                        err = rc;
+                        continue;
+                }
+        }
+
+        return err;
+}
+
 int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                              struct ceph_mds_session *session)
 {
@@ -1210,6 +1243,9 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
         u64 frag = le32_to_cpu(rhead->args.readdir.frag);
         struct ceph_dentry_info *di;
 
+        if (req->r_aborted)
+                return readdir_prepopulate_inodes_only(req, session);
+
         if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
                 snapdir = ceph_get_snapdir(parent->d_inode);
                 parent = d_find_alias(snapdir);
diff --git a/fs/ceph/ioctl.c b/fs/ceph/ioctl.c
index 36549a46e311..f5ed767806df 100644
--- a/fs/ceph/ioctl.c
+++ b/fs/ceph/ioctl.c
@@ -16,11 +16,11 @@
  */
 static long ceph_ioctl_get_layout(struct file *file, void __user *arg)
 {
-        struct ceph_inode_info *ci = ceph_inode(file->f_dentry->d_inode);
+        struct ceph_inode_info *ci = ceph_inode(file_inode(file));
         struct ceph_ioctl_layout l;
         int err;
 
-        err = ceph_do_getattr(file->f_dentry->d_inode, CEPH_STAT_CAP_LAYOUT);
+        err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT);
         if (!err) {
                 l.stripe_unit = ceph_file_layout_su(ci->i_layout);
                 l.stripe_count = ceph_file_layout_stripe_count(ci->i_layout);
@@ -63,12 +63,12 @@ static long __validate_layout(struct ceph_mds_client *mdsc,
 
 static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct inode *parent_inode;
         struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
         struct ceph_mds_request *req;
         struct ceph_ioctl_layout l;
-        struct ceph_inode_info *ci = ceph_inode(file->f_dentry->d_inode);
+        struct ceph_inode_info *ci = ceph_inode(file_inode(file));
         struct ceph_ioctl_layout nl;
         int err;
 
@@ -76,7 +76,7 @@ static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
                 return -EFAULT;
 
         /* validate changed params against current layout */
-        err = ceph_do_getattr(file->f_dentry->d_inode, CEPH_STAT_CAP_LAYOUT);
+        err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT);
         if (err)
                 return err;
 
@@ -136,7 +136,7 @@ static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
  */
 static long ceph_ioctl_set_layout_policy (struct file *file, void __user *arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_mds_request *req;
         struct ceph_ioctl_layout l;
         int err;
@@ -179,7 +179,7 @@ static long ceph_ioctl_set_layout_policy (struct file *file, void __user *arg)
 static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
 {
         struct ceph_ioctl_dataloc dl;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_osd_client *osdc =
                 &ceph_sb_to_client(inode->i_sb)->client->osdc;
@@ -234,7 +234,7 @@ static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
 static long ceph_ioctl_lazyio(struct file *file)
 {
         struct ceph_file_info *fi = file->private_data;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_inode_info *ci = ceph_inode(inode);
 
         if ((fi->fmode & CEPH_FILE_MODE_LAZY) == 0) {
diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c
index 80576d05d687..202dd3d68be0 100644
--- a/fs/ceph/locks.c
+++ b/fs/ceph/locks.c
@@ -13,7 +13,7 @@
 static int ceph_lock_message(u8 lock_type, u16 operation, struct file *file,
                              int cmd, u8 wait, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ceph_mds_client *mdsc =
                 ceph_sb_to_client(inode->i_sb)->mdsc;
         struct ceph_mds_request *req;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 9be09b21b4e0..4bad7b16271f 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -683,7 +683,7 @@ out_nls:
 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                    unsigned long nr_segs, loff_t pos)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         ssize_t written;
         int rc;
 
@@ -707,7 +707,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
          */
         if (whence != SEEK_SET && whence != SEEK_CUR) {
                 int rc;
-                struct inode *inode = file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(file);
 
                 /*
                  * We need to be sure that all dirty pages are written and the
@@ -739,7 +739,7 @@ static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
 {
         /* note that this is called by vfs setlease with lock_flocks held
            to protect *lease from going away */
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct cifsFileInfo *cfile = file->private_data;
 
         if (!(S_ISREG(inode->i_mode)))
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index a8d8b589ee0e..c16d2a018ab8 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -947,7 +947,7 @@ static int
 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 {
         int rc = 0;
-        struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
         unsigned char saved_type = flock->fl_type;
 
         if ((flock->fl_flags & FL_POSIX) == 0)
@@ -974,7 +974,7 @@ cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 static int
 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
 {
-        struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
         int rc = 1;
 
         if ((flock->fl_flags & FL_POSIX) == 0)
@@ -1548,7 +1548,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
 
         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         netfid = cfile->fid.netfid;
-        cinode = CIFS_I(file->f_path.dentry->d_inode);
+        cinode = CIFS_I(file_inode(file));
 
         if (cap_unix(tcon->ses) &&
             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
@@ -2171,7 +2171,7 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
         struct cifs_tcon *tcon;
         struct TCP_Server_Info *server;
         struct cifsFileInfo *smbfile = file->private_data;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 
         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
@@ -2246,7 +2246,7 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
  */
 int cifs_flush(struct file *file, fl_owner_t id)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         int rc = 0;
 
         if (file->f_mode & FMODE_WRITE)
@@ -2480,7 +2480,7 @@ ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
         ssize_t written;
         struct inode *inode;
 
-        inode = iocb->ki_filp->f_path.dentry->d_inode;
+        inode = file_inode(iocb->ki_filp);
 
         /*
          * BB - optimize the way when signing is disabled. We can drop this
@@ -2543,7 +2543,7 @@ ssize_t
 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
                    unsigned long nr_segs, loff_t pos)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         struct cifsInodeInfo *cinode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
@@ -2915,7 +2915,7 @@ ssize_t
 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
                   unsigned long nr_segs, loff_t pos)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         struct cifsInodeInfo *cinode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
@@ -3063,7 +3063,7 @@ static struct vm_operations_struct cifs_file_vm_ops = {
 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
 {
         int rc, xid;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         xid = get_xid();
 
@@ -3356,7 +3356,7 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
         int rc;
 
         /* Is the page cached? */
-        rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
+        rc = cifs_readpage_from_fscache(file_inode(file), page);
         if (rc == 0)
                 goto read_complete;
 
@@ -3371,8 +3371,8 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
         else
                 cFYI(1, "Bytes read %d", rc);
 
-        file->f_path.dentry->d_inode->i_atime =
-                current_fs_time(file->f_path.dentry->d_inode->i_sb);
+        file_inode(file)->i_atime =
+                current_fs_time(file_inode(file)->i_sb);
 
         if (PAGE_CACHE_SIZE > rc)
                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
@@ -3381,7 +3381,7 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
         SetPageUptodate(page);
 
         /* send this page to the cache */
-        cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
+        cifs_readpage_to_fscache(file_inode(file), page);
 
         rc = 0;
 
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 9638233964fc..d2a833999bcc 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -299,7 +299,7 @@ cifs_get_file_info_unix(struct file *filp)
         unsigned int xid;
         FILE_UNIX_BASIC_INFO find_data;
         struct cifs_fattr fattr;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsFileInfo *cfile = filp->private_data;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
@@ -568,7 +568,7 @@ cifs_get_file_info(struct file *filp)
         unsigned int xid;
         FILE_ALL_INFO find_data;
         struct cifs_fattr fattr;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsFileInfo *cfile = filp->private_data;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
@@ -1688,7 +1688,7 @@ cifs_invalidate_mapping(struct inode *inode)
 int cifs_revalidate_file_attr(struct file *filp)
 {
         int rc = 0;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
 
         if (!cifs_inode_needs_reval(inode))
@@ -1745,7 +1745,7 @@ out:
 int cifs_revalidate_file(struct file *filp)
 {
         int rc;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         rc = cifs_revalidate_file_attr(filp);
         if (rc)
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index fd5009d56f9f..6c9f1214cf0b 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -30,7 +30,7 @@
 
 long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
 {
-        struct inode *inode = filep->f_dentry->d_inode;
+        struct inode *inode = file_inode(filep);
         int rc = -ENOTTY; /* strange error - but the precedent */
         unsigned int xid;
         struct cifs_sb_info *cifs_sb;
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index cdd6ff48246b..df40cc5fd13a 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -82,12 +82,10 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
 
         cFYI(1, "%s: for %s", __func__, name->name);
 
-        if (parent->d_op && parent->d_op->d_hash)
-                parent->d_op->d_hash(parent, parent->d_inode, name);
-        else
-                name->hash = full_name_hash(name->name, name->len);
+        dentry = d_hash_and_lookup(parent, name);
+        if (unlikely(IS_ERR(dentry)))
+                return;
 
-        dentry = d_lookup(parent, name);
         if (dentry) {
                 int err;
 
@@ -505,7 +503,7 @@ static int cifs_entry_is_dot(struct cifs_dirent *de, bool is_unicode)
    whether we can use the cached search results from the previous search */
 static int is_dir_changed(struct file *file)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
 
         if (cifsInfo->time == 0)
@@ -778,7 +776,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
         switch ((int) file->f_pos) {
         case 0:
                 if (filldir(direntry, ".", 1, file->f_pos,
-                     file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
+                     file_inode(file)->i_ino, DT_DIR) < 0) {
                         cERROR(1, "Filldir for current dir failed");
                         rc = -ENOMEM;
                         break;
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 49fe52d25600..b7d3a05c062c 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -397,7 +397,7 @@ static int coda_readdir(struct file *coda_file, void *buf, filldir_t filldir)
                  * We can't use vfs_readdir because we have to keep the file
                  * position in sync between the coda_file and the host_file.
                  * and as such we need grab the inode mutex. */
-                struct inode *host_inode = host_file->f_path.dentry->d_inode;
+                struct inode *host_inode = file_inode(host_file);
 
                 mutex_lock(&host_inode->i_mutex);
                 host_file->f_pos = coda_file->f_pos;
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 8edd404e6419..fa4c100bdc7d 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -66,7 +66,7 @@ coda_file_splice_read(struct file *coda_file, loff_t *ppos,
 static ssize_t
 coda_file_write(struct file *coda_file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct inode *host_inode, *coda_inode = coda_file->f_path.dentry->d_inode;
+        struct inode *host_inode, *coda_inode = file_inode(coda_file);
         struct coda_file_info *cfi;
         struct file *host_file;
         ssize_t ret;
@@ -78,7 +78,7 @@ coda_file_write(struct file *coda_file, const char __user *buf, size_t count, lo
         if (!host_file->f_op || !host_file->f_op->write)
                 return -EINVAL;
 
-        host_inode = host_file->f_path.dentry->d_inode;
+        host_inode = file_inode(host_file);
         mutex_lock(&coda_inode->i_mutex);
 
         ret = host_file->f_op->write(host_file, buf, count, ppos);
@@ -106,8 +106,8 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
         if (!host_file->f_op || !host_file->f_op->mmap)
                 return -ENODEV;
 
-        coda_inode = coda_file->f_path.dentry->d_inode;
-        host_inode = host_file->f_path.dentry->d_inode;
+        coda_inode = file_inode(coda_file);
+        host_inode = file_inode(host_file);
 
         cii = ITOC(coda_inode);
         spin_lock(&cii->c_lock);
@@ -178,7 +178,7 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
         err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
                           coda_flags, coda_file->f_cred->fsuid);
 
-        host_inode = cfi->cfi_container->f_path.dentry->d_inode;
+        host_inode = file_inode(cfi->cfi_container);
         cii = ITOC(coda_inode);
 
         /* did we mmap this file? */
@@ -202,7 +202,7 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
 int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync)
 {
         struct file *host_file;
-        struct inode *coda_inode = coda_file->f_path.dentry->d_inode;
+        struct inode *coda_inode = file_inode(coda_file);
         struct coda_file_info *cfi;
         int err;
 
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index cf674e9179a3..dada9d0abede 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -130,7 +130,7 @@ static int get_device_index(struct coda_mount_data *data)
         f = fdget(data->fd);
         if (!f.file)
                 goto Ebadf;
-        inode = f.file->f_path.dentry->d_inode;
+        inode = file_inode(f.file);
         if (!S_ISCHR(inode->i_mode) || imajor(inode) != CODA_PSDEV_MAJOR) {
                 fdput(f);
                 goto Ebadf;
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index ee0981f1375b..3f5de96bbb58 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -52,7 +52,7 @@ static long coda_pioctl(struct file *filp, unsigned int cmd,
         struct path path;
         int error;
         struct PioctlData data;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct inode *target_inode = NULL;
         struct coda_inode_info *cnp;
 
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index e2f57a007029..3ced75f765ca 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -1582,7 +1582,7 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
         case FIBMAP:
         case FIGETBSZ:
         case FIONREAD:
-                if (S_ISREG(f.file->f_path.dentry->d_inode->i_mode))
+                if (S_ISREG(file_inode(f.file)->i_mode))
                         break;
                 /*FALL THROUGH*/
 
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index e9dcfa3c208c..7aabc6ad4e9b 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -1626,7 +1626,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
+                        mutex_unlock(&file_inode(file)->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
diff --git a/fs/coredump.c b/fs/coredump.c
index 177493272a61..69baf903d3bd 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -411,7 +411,7 @@ static void wait_for_dump_helpers(struct file *file)
 {
         struct pipe_inode_info *pipe;
 
-        pipe = file->f_path.dentry->d_inode->i_pipe;
+        pipe = file_inode(file)->i_pipe;
 
         pipe_lock(pipe);
         pipe->readers++;
@@ -600,7 +600,7 @@ void do_coredump(siginfo_t *siginfo)
                 if (IS_ERR(cprm.file))
                         goto fail_unlock;
 
-                inode = cprm.file->f_path.dentry->d_inode;
+                inode = file_inode(cprm.file);
                 if (inode->i_nlink > 1)
                         goto close_fail;
                 if (d_unhashed(cprm.file->f_path.dentry))
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index c6c3f91ecf06..3ceb9ec976e1 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -351,7 +351,7 @@ static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  */
 static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         char *buf;
         unsigned int offset;
diff --git a/fs/dcache.c b/fs/dcache.c
index 19153a0a810c..68220dd0c135 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1358,6 +1358,7 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
         WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH  |
                                 DCACHE_OP_COMPARE       |
                                 DCACHE_OP_REVALIDATE    |
+                                DCACHE_OP_WEAK_REVALIDATE       |
                                 DCACHE_OP_DELETE ));
         dentry->d_op = op;
         if (!op)
@@ -1368,6 +1369,8 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
                 dentry->d_flags |= DCACHE_OP_COMPARE;
         if (op->d_revalidate)
                 dentry->d_flags |= DCACHE_OP_REVALIDATE;
+        if (op->d_weak_revalidate)
+                dentry->d_flags |= DCACHE_OP_WEAK_REVALIDATE;
         if (op->d_delete)
                 dentry->d_flags |= DCACHE_OP_DELETE;
         if (op->d_prune)
@@ -1672,7 +1675,6 @@ EXPORT_SYMBOL(d_splice_alias);
 struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
                         struct qstr *name)
 {
-        int error;
         struct dentry *found;
         struct dentry *new;
 
@@ -1681,10 +1683,12 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
          * if not go ahead and create it now.
          */
         found = d_hash_and_lookup(dentry->d_parent, name);
+        if (unlikely(IS_ERR(found)))
+                goto err_out;
         if (!found) {
                 new = d_alloc(dentry->d_parent, name);
                 if (!new) {
-                        error = -ENOMEM;
+                        found = ERR_PTR(-ENOMEM);
                         goto err_out;
                 }
 
@@ -1725,7 +1729,7 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
 
 err_out:
         iput(inode);
-        return ERR_PTR(error);
+        return found;
 }
 EXPORT_SYMBOL(d_add_ci);
 
@@ -1889,7 +1893,7 @@ seqretry:
  * dentry is returned. The caller must use dput to free the entry when it has
  * finished using it. %NULL is returned if the dentry does not exist.
  */
-struct dentry *d_lookup(struct dentry *parent, struct qstr *name)
+struct dentry *d_lookup(const struct dentry *parent, const struct qstr *name)
 {
         struct dentry *dentry;
         unsigned seq;
@@ -1919,7 +1923,7 @@ EXPORT_SYMBOL(d_lookup);
  *
  * __d_lookup callers must be commented.
  */
-struct dentry *__d_lookup(struct dentry *parent, struct qstr *name)
+struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name)
 {
         unsigned int len = name->len;
         unsigned int hash = name->hash;
@@ -1997,12 +2001,10 @@ next:
  * @dir: Directory to search in
  * @name: qstr of name we wish to find
  *
- * On hash failure or on lookup failure NULL is returned.
+ * On lookup failure NULL is returned; on bad name - ERR_PTR(-error)
  */
 struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
 {
-        struct dentry *dentry = NULL;
-
         /*
          * Check for a fs-specific hash function. Note that we must
          * calculate the standard hash first, as the d_op->d_hash()
@@ -2010,13 +2012,13 @@ struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
          */
         name->hash = full_name_hash(name->name, name->len);
         if (dir->d_flags & DCACHE_OP_HASH) {
-                if (dir->d_op->d_hash(dir, dir->d_inode, name) < 0)
-                        goto out;
+                int err = dir->d_op->d_hash(dir, dir->d_inode, name);
+                if (unlikely(err < 0))
+                        return ERR_PTR(err);
         }
-        dentry = d_lookup(dir, name);
-out:
-        return dentry;
+        return d_lookup(dir, name);
 }
+EXPORT_SYMBOL(d_hash_and_lookup);
 
 /**
  * d_validate - verify dentry provided from insecure source (deprecated)
@@ -2394,7 +2396,7 @@ out_err:
  */
 static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
 {
-        struct dentry *dparent, *aparent;
+        struct dentry *dparent;
 
         dentry_lock_for_move(anon, dentry);
 
@@ -2402,24 +2404,15 @@ static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
         write_seqcount_begin(&anon->d_seq);
 
         dparent = dentry->d_parent;
-        aparent = anon->d_parent;
 
         switch_names(dentry, anon);
         swap(dentry->d_name.hash, anon->d_name.hash);
 
-        dentry->d_parent = (aparent == anon) ? dentry : aparent;
-        list_del(&dentry->d_u.d_child);
-        if (!IS_ROOT(dentry))
-                list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
-        else
-                INIT_LIST_HEAD(&dentry->d_u.d_child);
-
-        anon->d_parent = (dparent == dentry) ? anon : dparent;
+        dentry->d_parent = dentry;
+        list_del_init(&dentry->d_u.d_child);
+        anon->d_parent = dparent;
         list_del(&anon->d_u.d_child);
-        if (!IS_ROOT(anon))
-                list_add(&anon->d_u.d_child, &anon->d_parent->d_subdirs);
-        else
-                INIT_LIST_HEAD(&anon->d_u.d_child);
+        list_add(&anon->d_u.d_child, &dparent->d_subdirs);
 
         write_seqcount_end(&dentry->d_seq);
         write_seqcount_end(&anon->d_seq);
@@ -2722,37 +2715,6 @@ char *d_path(const struct path *path, char *buf, int buflen)
 }
 EXPORT_SYMBOL(d_path);
 
-/**
- * d_path_with_unreachable - return the path of a dentry
- * @path: path to report
- * @buf: buffer to return value in
- * @buflen: buffer length
- *
- * The difference from d_path() is that this prepends "(unreachable)"
- * to paths which are unreachable from the current process' root.
- */
-char *d_path_with_unreachable(const struct path *path, char *buf, int buflen)
-{
-        char *res = buf + buflen;
-        struct path root;
-        int error;
-
-        if (path->dentry->d_op && path->dentry->d_op->d_dname)
-                return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
-
-        get_fs_root(current->fs, &root);
-        write_seqlock(&rename_lock);
-        error = path_with_deleted(path, &root, &res, &buflen);
-        if (error > 0)
-                error = prepend_unreachable(&res, &buflen);
-        write_sequnlock(&rename_lock);
-        path_put(&root);
-        if (error)
-                res =  ERR_PTR(error);
-
-        return res;
-}
-
 /*
  * Helper function for dentry_operations.d_dname() members
  */
@@ -3035,7 +2997,7 @@ ino_t find_inode_number(struct dentry *dir, struct qstr *name)
         ino_t ino = 0;
 
         dentry = d_hash_and_lookup(dir, name);
-        if (dentry) {
+        if (!IS_ERR_OR_NULL(dentry)) {
                 if (dentry->d_inode)
                         ino = dentry->d_inode->i_ino;
                 dput(dentry);
diff --git a/fs/direct-io.c b/fs/direct-io.c
index cf5b44b10c67..f853263cf74f 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -261,9 +261,9 @@ static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret, bool is
                 dio->end_io(dio->iocb, offset, transferred,
                             dio->private, ret, is_async);
         } else {
+                inode_dio_done(dio->inode);
                 if (is_async)
                         aio_complete(dio->iocb, ret, 0);
-                inode_dio_done(dio->inode);
         }
 
         return ret;
diff --git a/fs/dlm/config.c b/fs/dlm/config.c
index a0387dd8b1f0..7d58d5b112b5 100644
--- a/fs/dlm/config.c
+++ b/fs/dlm/config.c
@@ -158,7 +158,7 @@ static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,
         unsigned int x;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         x = simple_strtoul(buf, NULL, 0);
 
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index cfb4b9fed520..7e2c6f5d7985 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -509,6 +509,12 @@ ecryptfs_dentry_to_lower_mnt(struct dentry *dentry)
         return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.mnt;
 }
 
+static inline struct path *
+ecryptfs_dentry_to_lower_path(struct dentry *dentry)
+{
+        return &((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path;
+}
+
 static inline void
 ecryptfs_set_dentry_lower_mnt(struct dentry *dentry, struct vfsmount *lower_mnt)
 {
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index d45ba4568128..53acc9d0c138 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -118,7 +118,7 @@ static int ecryptfs_readdir(struct file *file, void *dirent, filldir_t filldir)
 
         lower_file = ecryptfs_file_to_lower(file);
         lower_file->f_pos = file->f_pos;
-        inode = file->f_path.dentry->d_inode;
+        inode = file_inode(file);
         memset(&buf, 0, sizeof(buf));
         buf.dirent = dirent;
         buf.dentry = file->f_path.dentry;
@@ -133,7 +133,7 @@ static int ecryptfs_readdir(struct file *file, void *dirent, filldir_t filldir)
                 goto out;
         if (rc >= 0)
                 fsstack_copy_attr_atime(inode,
-                                        lower_file->f_path.dentry->d_inode);
+                                        file_inode(lower_file));
 out:
         return rc;
 }
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index cc7709e7c508..e0f07fb6d56b 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -1027,8 +1027,7 @@ int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         struct kstat lower_stat;
         int rc;
 
-        rc = vfs_getattr(ecryptfs_dentry_to_lower_mnt(dentry),
-                         ecryptfs_dentry_to_lower(dentry), &lower_stat);
+        rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat);
         if (!rc) {
                 fsstack_copy_attr_all(dentry->d_inode,
                                       ecryptfs_inode_to_lower(dentry->d_inode));
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index b2a34a192f4f..6a160539cd23 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -40,16 +40,12 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
                          loff_t offset, size_t size)
 {
         struct file *lower_file;
-        mm_segment_t fs_save;
         ssize_t rc;
 
         lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file;
         if (!lower_file)
                 return -EIO;
-        fs_save = get_fs();
-        set_fs(get_ds());
-        rc = vfs_write(lower_file, data, size, &offset);
-        set_fs(fs_save);
+        rc = kernel_write(lower_file, data, size, offset);
         mark_inode_dirty_sync(ecryptfs_inode);
         return rc;
 }
diff --git a/fs/efs/dir.c b/fs/efs/dir.c
index 7ee6f7e3a608..055a9e9ca747 100644
--- a/fs/efs/dir.c
+++ b/fs/efs/dir.c
@@ -20,7 +20,7 @@ const struct inode_operations efs_dir_inode_operations = {
 };
 
 static int efs_readdir(struct file *filp, void *dirent, filldir_t filldir) {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct buffer_head *bh;
 
         struct efs_dir          *dirblock;
diff --git a/fs/exec.c b/fs/exec.c
index 20df02c1cc70..864c50df660a 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -123,7 +123,7 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
                 goto out;
 
         error = -EINVAL;
-        if (!S_ISREG(file->f_path.dentry->d_inode->i_mode))
+        if (!S_ISREG(file_inode(file)->i_mode))
                 goto exit;
 
         error = -EACCES;
@@ -355,7 +355,7 @@ static bool valid_arg_len(struct linux_binprm *bprm, long len)
  * flags, permissions, and offset, so we use temporary values.  We'll update
  * them later in setup_arg_pages().
  */
-int bprm_mm_init(struct linux_binprm *bprm)
+static int bprm_mm_init(struct linux_binprm *bprm)
 {
         int err;
         struct mm_struct *mm = NULL;
@@ -764,7 +764,7 @@ struct file *open_exec(const char *name)
                 goto out;
 
         err = -EACCES;
-        if (!S_ISREG(file->f_path.dentry->d_inode->i_mode))
+        if (!S_ISREG(file_inode(file)->i_mode))
                 goto exit;
 
         if (file->f_path.mnt->mnt_flags & MNT_NOEXEC)
@@ -1098,7 +1098,7 @@ EXPORT_SYMBOL(flush_old_exec);
 
 void would_dump(struct linux_binprm *bprm, struct file *file)
 {
-        if (inode_permission(file->f_path.dentry->d_inode, MAY_READ) < 0)
+        if (inode_permission(file_inode(file), MAY_READ) < 0)
                 bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
 }
 EXPORT_SYMBOL(would_dump);
@@ -1270,7 +1270,7 @@ static int check_unsafe_exec(struct linux_binprm *bprm)
 int prepare_binprm(struct linux_binprm *bprm)
 {
         umode_t mode;
-        struct inode * inode = bprm->file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(bprm->file);
         int retval;
 
         mode = inode->i_mode;
diff --git a/fs/exofs/dir.c b/fs/exofs/dir.c
index c61e62ac231c..46375896cfc0 100644
--- a/fs/exofs/dir.c
+++ b/fs/exofs/dir.c
@@ -242,7 +242,7 @@ static int
 exofs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         loff_t pos = filp->f_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         unsigned int offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
         unsigned long npages = dir_pages(inode);
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 0f4f5c929257..4237722bfd27 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -290,7 +290,7 @@ static int
 ext2_readdir (struct file * filp, void * dirent, filldir_t filldir)
 {
         loff_t pos = filp->f_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         unsigned int offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index 2de655f5d625..5d46c09863f0 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -19,7 +19,7 @@
 
 long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ext2_inode_info *ei = EXT2_I(inode);
         unsigned int flags;
         unsigned short rsv_window_size;
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index dd91264ba94f..87eccbbca255 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -99,7 +99,7 @@ static int ext3_readdir(struct file * filp,
         int i, stored;
         struct ext3_dir_entry_2 *de;
         int err;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         int ret = 0;
         int dir_has_error = 0;
@@ -114,7 +114,7 @@ static int ext3_readdir(struct file * filp,
                  * We don't set the inode dirty flag since it's not
                  * critical that it get flushed back to the disk.
                  */
-                EXT3_I(filp->f_path.dentry->d_inode)->i_flags &= ~EXT3_INDEX_FL;
+                EXT3_I(file_inode(filp))->i_flags &= ~EXT3_INDEX_FL;
         }
         stored = 0;
         offset = filp->f_pos & (sb->s_blocksize - 1);
@@ -457,7 +457,7 @@ static int call_filldir(struct file * filp, void * dirent,
 {
         struct dir_private_info *info = filp->private_data;
         loff_t  curr_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block * sb;
         int error;
 
@@ -487,7 +487,7 @@ static int ext3_dx_readdir(struct file * filp,
                          void * dirent, filldir_t filldir)
 {
         struct dir_private_info *info = filp->private_data;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct fname *fname;
         int     ret;
 
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 677a5c27dc69..4d96e9a64532 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -14,7 +14,7 @@
 
 long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ext3_inode_info *ei = EXT3_I(inode);
         unsigned int flags;
         unsigned short rsv_window_size;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 88f64eb1b6fa..692de13e3596 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -623,7 +623,7 @@ int ext3_htree_fill_tree(struct file *dir_file, __u32 start_hash,
 
         dxtrace(printk("In htree_fill_tree, start hash: %x:%x\n", start_hash,
                        start_minor_hash));
-        dir = dir_file->f_path.dentry->d_inode;
+        dir = file_inode(dir_file);
         if (!(EXT3_I(dir)->i_flags & EXT3_INDEX_FL)) {
                 hinfo.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version;
                 if (hinfo.hash_version <= DX_HASH_TEA)
@@ -637,7 +637,7 @@ int ext3_htree_fill_tree(struct file *dir_file, __u32 start_hash,
         }
         hinfo.hash = start_hash;
         hinfo.minor_hash = 0;
-        frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo, frames, &err);
+        frame = dx_probe(NULL, file_inode(dir_file), &hinfo, frames, &err);
         if (!frame)
                 return err;
 
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index 3882fbc5e215..6dda04f05ef4 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -110,7 +110,7 @@ static int ext4_readdir(struct file *filp,
         int i, stored;
         struct ext4_dir_entry_2 *de;
         int err;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         int ret = 0;
         int dir_has_error = 0;
@@ -133,7 +133,7 @@ static int ext4_readdir(struct file *filp,
                  * We don't set the inode dirty flag since it's not
                  * critical that it get flushed back to the disk.
                  */
-                ext4_clear_inode_flag(filp->f_path.dentry->d_inode,
+                ext4_clear_inode_flag(file_inode(filp),
                                       EXT4_INODE_INDEX);
         }
         stored = 0;
@@ -495,7 +495,7 @@ static int call_filldir(struct file *filp, void *dirent,
 {
         struct dir_private_info *info = filp->private_data;
         loff_t  curr_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb;
         int error;
 
@@ -527,7 +527,7 @@ static int ext4_dx_readdir(struct file *filp,
                          void *dirent, filldir_t filldir)
 {
         struct dir_private_info *info = filp->private_data;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct fname *fname;
         int     ret;
 
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 372b2cbee07e..28dd8eeea6a9 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4309,7 +4309,7 @@ static void ext4_falloc_update_inode(struct inode *inode,
  */
 long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         handle_t *handle;
         loff_t new_size;
         unsigned int max_blocks;
@@ -4571,7 +4571,7 @@ static int ext4_xattr_fiemap(struct inode *inode,
  */
 int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct super_block *sb = inode->i_sb;
         ext4_lblk_t first_block, stop_block;
         struct address_space *mapping = inode->i_mapping;
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 7e85a10a6f4f..64848b595b24 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -167,7 +167,7 @@ static ssize_t
 ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         ssize_t ret;
 
         /*
diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index bc5f871f0893..c0fd1a123f7d 100644
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -1298,7 +1298,7 @@ int ext4_read_inline_dir(struct file *filp,
         int i, stored;
         struct ext4_dir_entry_2 *de;
         struct super_block *sb;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret, inline_size = 0;
         struct ext4_iloc iloc;
         void *dir_buf = NULL;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 88049d8d30cb..9c4f4b1c97f8 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2948,7 +2948,7 @@ static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
                             ssize_t size, void *private, int ret,
                             bool is_async)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         ext4_io_end_t *io_end = iocb->private;
 
         /* if not async direct IO or dio with 0 bytes write, just return */
@@ -3483,7 +3483,7 @@ int ext4_can_truncate(struct inode *inode)
 
 int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         if (!S_ISREG(inode->i_mode))
                 return -EOPNOTSUPP;
 
@@ -4855,7 +4855,7 @@ int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         unsigned long len;
         int ret;
         struct file *file = vma->vm_file;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct address_space *mapping = inode->i_mapping;
         handle_t *handle;
         get_block_t *get_block;
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 31f4f56a32d6..721f4d33e148 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -22,7 +22,7 @@
 
 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         struct ext4_inode_info *ei = EXT4_I(inode);
         unsigned int flags;
diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index d78c33eed7e5..4e81d47aa8cb 100644
--- a/fs/ext4/move_extent.c
+++ b/fs/ext4/move_extent.c
@@ -900,7 +900,7 @@ move_extent_per_page(struct file *o_filp, struct inode *donor_inode,
                   pgoff_t orig_page_offset, int data_offset_in_page,
                   int block_len_in_page, int uninit, int *err)
 {
-        struct inode *orig_inode = o_filp->f_dentry->d_inode;
+        struct inode *orig_inode = file_inode(o_filp);
         struct page *pagep[2] = {NULL, NULL};
         handle_t *handle;
         ext4_lblk_t orig_blk_offset;
@@ -1279,8 +1279,8 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp,
                  __u64 orig_start, __u64 donor_start, __u64 len,
                  __u64 *moved_len)
 {
-        struct inode *orig_inode = o_filp->f_dentry->d_inode;
-        struct inode *donor_inode = d_filp->f_dentry->d_inode;
+        struct inode *orig_inode = file_inode(o_filp);
+        struct inode *donor_inode = file_inode(d_filp);
         struct ext4_ext_path *orig_path = NULL, *holecheck_path = NULL;
         struct ext4_extent *ext_prev, *ext_cur, *ext_dummy;
         ext4_lblk_t block_start = orig_start;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 2a7015d06a75..3825d6aa8336 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -964,7 +964,7 @@ int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
 
         dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
                        start_hash, start_minor_hash));
-        dir = dir_file->f_path.dentry->d_inode;
+        dir = file_inode(dir_file);
         if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
                 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
                 if (hinfo.hash_version <= DX_HASH_TEA)
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 373d46cd5d3f..620cf5615ba2 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -450,7 +450,7 @@ void ext4_error_file(struct file *file, const char *function,
         va_list args;
         struct va_format vaf;
         struct ext4_super_block *es;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         char pathname[80], *path;
 
         es = EXT4_SB(inode->i_sb)->s_es;
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index c395c5012973..a1f38443ecee 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -600,7 +600,7 @@ bool f2fs_empty_dir(struct inode *dir)
 static int f2fs_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
         unsigned long pos = file->f_pos;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         unsigned long npages = dir_blocks(inode);
         unsigned char *types = NULL;
         unsigned int bit_pos = 0, start_bit_pos = 0;
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 58bf744dbf39..165012ef363a 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -698,7 +698,7 @@ out:
 
 static int fat_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         return __fat_readdir(inode, filp, dirent, filldir, 0, 0);
 }
 
@@ -779,7 +779,7 @@ static int fat_ioctl_readdir(struct inode *inode, struct file *filp,
 static long fat_dir_ioctl(struct file *filp, unsigned int cmd,
                           unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct __fat_dirent __user *d1 = (struct __fat_dirent __user *)arg;
         int short_only, both;
 
@@ -819,7 +819,7 @@ FAT_IOCTL_FILLDIR_FUNC(fat_compat_ioctl_filldir, compat_dirent)
 static long fat_compat_dir_ioctl(struct file *filp, unsigned cmd,
                                  unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct compat_dirent __user *d1 = compat_ptr(arg);
         int short_only, both;
 
diff --git a/fs/fat/file.c b/fs/fat/file.c
index a62e0ecbe2db..3978f8ca1823 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -32,7 +32,7 @@ static int fat_ioctl_get_attributes(struct inode *inode, u32 __user *user_attr)
 
 static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
         int is_dir = S_ISDIR(inode->i_mode);
         u32 attr, oldattr;
@@ -116,7 +116,7 @@ out:
 
 long fat_generic_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         u32 __user *user_attr = (u32 __user *)arg;
 
         switch (cmd) {
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 71a600a19f06..6599222536eb 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -30,7 +30,7 @@
 
 static int setfl(int fd, struct file * filp, unsigned long arg)
 {
-        struct inode * inode = filp->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(filp);
         int error = 0;
 
         /*
diff --git a/fs/file_table.c b/fs/file_table.c
index de9e9653d611..aa07d3684a2e 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -94,8 +94,8 @@ int proc_nr_files(ctl_table *table, int write,
 #endif
 
 /* Find an unused file structure and return a pointer to it.
- * Returns NULL, if there are no more free file structures or
- * we run out of memory.
+ * Returns an error pointer if some error happend e.g. we over file
+ * structures limit, run out of memory or operation is not permitted.
  *
  * Be very careful using this.  You are responsible for
  * getting write access to any mount that you might assign
@@ -107,7 +107,8 @@ struct file *get_empty_filp(void)
 {
         const struct cred *cred = current_cred();
         static long old_max;
-        struct file * f;
+        struct file *f;
+        int error;
 
         /*
          * Privileged users can go above max_files
@@ -122,13 +123,16 @@ struct file *get_empty_filp(void)
         }
 
         f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
-        if (f == NULL)
-                goto fail;
+        if (unlikely(!f))
+                return ERR_PTR(-ENOMEM);
 
         percpu_counter_inc(&nr_files);
         f->f_cred = get_cred(cred);
-        if (security_file_alloc(f))
-                goto fail_sec;
+        error = security_file_alloc(f);
+        if (unlikely(error)) {
+                file_free(f);
+                return ERR_PTR(error);
+        }
 
         INIT_LIST_HEAD(&f->f_u.fu_list);
         atomic_long_set(&f->f_count, 1);
@@ -144,12 +148,7 @@ over:
                 pr_info("VFS: file-max limit %lu reached\n", get_max_files());
                 old_max = get_nr_files();
         }
-        goto fail;
-
-fail_sec:
-        file_free(f);
-fail:
-        return NULL;
+        return ERR_PTR(-ENFILE);
 }
 
 /**
@@ -173,8 +172,8 @@ struct file *alloc_file(struct path *path, fmode_t mode,
         struct file *file;
 
         file = get_empty_filp();
-        if (!file)
-                return NULL;
+        if (IS_ERR(file))
+                return file;
 
         file->f_path = *path;
         file->f_mapping = path->dentry->d_inode->i_mapping;
@@ -447,7 +446,7 @@ void mark_files_ro(struct super_block *sb)
 
         lg_global_lock(&files_lglock);
         do_file_list_for_each_entry(sb, f) {
-                if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
+                if (!S_ISREG(file_inode(f)->i_mode))
                        continue;
                 if (!file_count(f))
                         continue;
diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c
index bd447e88f208..664b07a53870 100644
--- a/fs/freevxfs/vxfs_lookup.c
+++ b/fs/freevxfs/vxfs_lookup.c
@@ -237,7 +237,7 @@ vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags)
 static int
 vxfs_readdir(struct file *fp, void *retp, filldir_t filler)
 {
-        struct inode            *ip = fp->f_path.dentry->d_inode;
+        struct inode            *ip = file_inode(fp);
         struct super_block      *sbp = ip->i_sb;
         u_long                  bsize = sbp->s_blocksize;
         u_long                  page, npages, block, pblocks, nblocks, offset;
diff --git a/fs/fuse/control.c b/fs/fuse/control.c
index 75a20c092dd4..b7978b9f75ef 100644
--- a/fs/fuse/control.c
+++ b/fs/fuse/control.c
@@ -23,7 +23,7 @@ static struct fuse_conn *fuse_ctl_file_conn_get(struct file *file)
 {
         struct fuse_conn *fc;
         mutex_lock(&fuse_mutex);
-        fc = file->f_path.dentry->d_inode->i_private;
+        fc = file_inode(file)->i_private;
         if (fc)
                 fc = fuse_conn_get(fc);
         mutex_unlock(&fuse_mutex);
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 85065221a58a..ff15522481d4 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1325,7 +1325,7 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
         int plus, err;
         size_t nbytes;
         struct page *page;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
         u64 attr_version = 0;
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 01353ed75750..df00993ed108 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -679,7 +679,7 @@ static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
 
         if (*max_len < len) {
                 *max_len = len;
-                return  255;
+                return  FILEID_INVALID;
         }
 
         nodeid = get_fuse_inode(inode)->nodeid;
diff --git a/fs/gfs2/export.c b/fs/gfs2/export.c
index 4767774a5f3e..9973df4ff565 100644
--- a/fs/gfs2/export.c
+++ b/fs/gfs2/export.c
@@ -37,10 +37,10 @@ static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len,
 
         if (parent && (*len < GFS2_LARGE_FH_SIZE)) {
                 *len = GFS2_LARGE_FH_SIZE;
-                return 255;
+                return FILEID_INVALID;
         } else if (*len < GFS2_SMALL_FH_SIZE) {
                 *len = GFS2_SMALL_FH_SIZE;
-                return 255;
+                return FILEID_INVALID;
         }
 
         fh[0] = cpu_to_be32(ip->i_no_formal_ino >> 32);
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 2687f50d98cb..019f45e45097 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -157,7 +157,7 @@ static const u32 gfs2_to_fsflags[32] = {
 
 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int error;
@@ -217,7 +217,7 @@ void gfs2_set_inode_flags(struct inode *inode)
  */
 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct buffer_head *bh;
@@ -293,7 +293,7 @@ out_drop_write:
 
 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         u32 fsflags, gfsflags;
 
         if (get_user(fsflags, ptr))
@@ -336,7 +336,7 @@ static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
 static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
 {
-        struct inode *inode = filep->f_dentry->d_inode;
+        struct inode *inode = file_inode(filep);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct gfs2_inode *ip = GFS2_I(inode);
         size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
@@ -386,7 +386,7 @@ static int gfs2_allocate_page_backing(struct page *page)
 static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct page *page = vmf->page;
-        struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         unsigned long last_index;
@@ -673,8 +673,7 @@ static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 {
         struct file *file = iocb->ki_filp;
         size_t writesize = iov_length(iov, nr_segs);
-        struct dentry *dentry = file->f_dentry;
-        struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(file_inode(file));
         int ret;
 
         ret = gfs2_rs_alloc(ip);
@@ -772,7 +771,7 @@ static void calc_max_reserv(struct gfs2_inode *ip, loff_t max, loff_t *len,
 static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
                            loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct gfs2_inode *ip = GFS2_I(inode);
         unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
@@ -938,7 +937,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
 {
         struct gfs2_file *fp = file->private_data;
         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
-        struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(file_inode(file));
         struct gfs2_glock *gl;
         unsigned int state;
         int flags;
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 52c2aeaf45ce..d1f51fd73f86 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -1257,7 +1257,7 @@ fail:
 
 int gfs2_fitrim(struct file *filp, void __user *argp)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
         struct buffer_head *bh;
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index 597a612834dc..aa5c48044966 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -103,7 +103,7 @@ static ssize_t freeze_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
         int n = simple_strtol(buf, NULL, 0);
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         switch (n) {
         case 0:
@@ -133,7 +133,7 @@ static ssize_t withdraw_show(struct gfs2_sbd *sdp, char *buf)
 static ssize_t withdraw_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 {
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         if (simple_strtol(buf, NULL, 0) != 1)
                 return -EINVAL;
@@ -148,7 +148,7 @@ static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,
                                  size_t len)
 {
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         if (simple_strtol(buf, NULL, 0) != 1)
                 return -EINVAL;
@@ -161,7 +161,7 @@ static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
                                 size_t len)
 {
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         if (simple_strtol(buf, NULL, 0) != 1)
                 return -EINVAL;
@@ -178,7 +178,7 @@ static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf,
         u32 id;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         id = simple_strtoul(buf, NULL, 0);
 
@@ -198,7 +198,7 @@ static ssize_t quota_refresh_group_store(struct gfs2_sbd *sdp, const char *buf,
         u32 id;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         id = simple_strtoul(buf, NULL, 0);
 
@@ -221,7 +221,7 @@ static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len
         int rv;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         rv = sscanf(buf, "%u:%llu %15s", &gltype, &glnum,
                     mode);
@@ -532,7 +532,7 @@ static ssize_t quota_scale_store(struct gfs2_sbd *sdp, const char *buf,
         unsigned int x, y;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         if (sscanf(buf, "%u %u", &x, &y) != 2 || !y)
                 return -EINVAL;
@@ -551,7 +551,7 @@ static ssize_t tune_set(struct gfs2_sbd *sdp, unsigned int *field,
         unsigned int x;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
+                return -EPERM;
 
         x = simple_strtoul(buf, NULL, 0);
 
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 422dde2ec0a1..5f7f1abd5f6d 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -51,7 +51,7 @@ done:
  */
 static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         int len, err;
         char strbuf[HFS_MAX_NAMELEN];
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index d47f11658c17..3031dfdd2358 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -128,7 +128,7 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
 {
         struct file *file = iocb->ki_filp;
         struct address_space *mapping = file->f_mapping;
-        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
+        struct inode *inode = file_inode(file)->i_mapping->host;
         ssize_t ret;
 
         ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 6b9f921ef2fa..074e04589248 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -122,7 +122,7 @@ fail:
 
 static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         int len, err;
         char strbuf[HFSPLUS_MAX_STRLEN + 1];
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 799b336b59f9..dcd05be5344b 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -124,7 +124,7 @@ static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
 {
         struct file *file = iocb->ki_filp;
         struct address_space *mapping = file->f_mapping;
-        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
+        struct inode *inode = file_inode(file)->i_mapping->host;
         ssize_t ret;
 
         ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 09addc8615fa..e3c4c4209428 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -59,7 +59,7 @@ static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
 
 static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
         unsigned int flags = 0;
 
@@ -75,7 +75,7 @@ static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
 
 static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
         unsigned int flags;
         int err = 0;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 457addc5c91f..fbabb906066f 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -30,7 +30,7 @@ static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
         return list_entry(inode, struct hostfs_inode_info, vfs_inode);
 }
 
-#define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode)
+#define FILE_HOSTFS_I(file) HOSTFS_I(file_inode(file))
 
 static int hostfs_d_delete(const struct dentry *dentry)
 {
@@ -861,14 +861,6 @@ int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
 }
 
 static const struct inode_operations hostfs_iops = {
-        .create         = hostfs_create,
-        .link           = hostfs_link,
-        .unlink         = hostfs_unlink,
-        .symlink        = hostfs_symlink,
-        .mkdir          = hostfs_mkdir,
-        .rmdir          = hostfs_rmdir,
-        .mknod          = hostfs_mknod,
-        .rename         = hostfs_rename,
         .permission     = hostfs_permission,
         .setattr        = hostfs_setattr,
 };
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index 78e12b2e0ea2..546f6d39713a 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -25,7 +25,7 @@ static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
         loff_t new_off = off + (whence == 1 ? filp->f_pos : 0);
         loff_t pos;
         struct quad_buffer_head qbh;
-        struct inode *i = filp->f_path.dentry->d_inode;
+        struct inode *i = file_inode(filp);
         struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
         struct super_block *s = i->i_sb;
 
@@ -57,7 +57,7 @@ fail:
 
 static int hpfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
         struct quad_buffer_head qbh;
         struct hpfs_dirent *de;
diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index fbfe2df5624b..9f9dbeceeee7 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -152,7 +152,7 @@ static ssize_t hpfs_file_write(struct file *file, const char __user *buf,
         retval = do_sync_write(file, buf, count, ppos);
         if (retval > 0) {
                 hpfs_lock(file->f_path.dentry->d_sb);
-                hpfs_i(file->f_path.dentry->d_inode)->i_dirty = 1;
+                hpfs_i(file_inode(file))->i_dirty = 1;
                 hpfs_unlock(file->f_path.dentry->d_sb);
         }
         return retval;
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index 43b315f2002b..74f55703be49 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -180,7 +180,7 @@ static ssize_t read_proc(struct file *file, char __user *buf, ssize_t count,
         ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
         ssize_t n;
 
-        read = file->f_path.dentry->d_inode->i_fop->read;
+        read = file_inode(file)->i_fop->read;
 
         if (!is_user)
                 set_fs(KERNEL_DS);
@@ -288,7 +288,7 @@ static ssize_t hppfs_write(struct file *file, const char __user *buf,
         struct file *proc_file = data->proc_file;
         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
 
-        write = proc_file->f_path.dentry->d_inode->i_fop->write;
+        write = file_inode(proc_file)->i_fop->write;
         return (*write)(proc_file, buf, len, ppos);
 }
 
@@ -513,7 +513,7 @@ static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
         loff_t (*llseek)(struct file *, loff_t, int);
         loff_t ret;
 
-        llseek = proc_file->f_path.dentry->d_inode->i_fop->llseek;
+        llseek = file_inode(proc_file)->i_fop->llseek;
         if (llseek != NULL) {
                 ret = (*llseek)(proc_file, off, where);
                 if (ret < 0)
@@ -561,7 +561,7 @@ static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
                                       });
         int err;
 
-        readdir = proc_file->f_path.dentry->d_inode->i_fop->readdir;
+        readdir = file_inode(proc_file)->i_fop->readdir;
 
         proc_file->f_pos = file->f_pos;
         err = (*readdir)(proc_file, &dirent, hppfs_filldir);
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 78bde32ea951..7f94e0cbc69c 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -97,7 +97,7 @@ static void huge_pagevec_release(struct pagevec *pvec)
 
 static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         loff_t len, vma_len;
         int ret;
         struct hstate *h = hstate_file(file);
@@ -918,16 +918,25 @@ static int get_hstate_idx(int page_size_log)
         return h - hstates;
 }
 
+static char *hugetlb_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+        return dynamic_dname(dentry, buffer, buflen, "/%s (deleted)",
+                                dentry->d_name.name);
+}
+
+static struct dentry_operations anon_ops = {
+        .d_dname = hugetlb_dname
+};
+
 struct file *hugetlb_file_setup(const char *name, unsigned long addr,
                                 size_t size, vm_flags_t acctflag,
                                 struct user_struct **user,
                                 int creat_flags, int page_size_log)
 {
-        int error = -ENOMEM;
-        struct file *file;
+        struct file *file = ERR_PTR(-ENOMEM);
         struct inode *inode;
         struct path path;
-        struct dentry *root;
+        struct super_block *sb;
         struct qstr quick_string;
         struct hstate *hstate;
         unsigned long num_pages;
@@ -955,17 +964,18 @@ struct file *hugetlb_file_setup(const char *name, unsigned long addr,
                 }
         }
 
-        root = hugetlbfs_vfsmount[hstate_idx]->mnt_root;
+        sb = hugetlbfs_vfsmount[hstate_idx]->mnt_sb;
         quick_string.name = name;
         quick_string.len = strlen(quick_string.name);
         quick_string.hash = 0;
-        path.dentry = d_alloc(root, &quick_string);
+        path.dentry = d_alloc_pseudo(sb, &quick_string);
         if (!path.dentry)
                 goto out_shm_unlock;
 
+        d_set_d_op(path.dentry, &anon_ops);
         path.mnt = mntget(hugetlbfs_vfsmount[hstate_idx]);
-        error = -ENOSPC;
-        inode = hugetlbfs_get_inode(root->d_sb, NULL, S_IFREG | S_IRWXUGO, 0);
+        file = ERR_PTR(-ENOSPC);
+        inode = hugetlbfs_get_inode(sb, NULL, S_IFREG | S_IRWXUGO, 0);
         if (!inode)
                 goto out_dentry;
 
@@ -973,7 +983,7 @@ struct file *hugetlb_file_setup(const char *name, unsigned long addr,
         size += addr & ~huge_page_mask(hstate);
         num_pages = ALIGN(size, huge_page_size(hstate)) >>
                         huge_page_shift(hstate);
-        error = -ENOMEM;
+        file = ERR_PTR(-ENOMEM);
         if (hugetlb_reserve_pages(inode, 0, num_pages, NULL, acctflag))
                 goto out_inode;
 
@@ -981,10 +991,9 @@ struct file *hugetlb_file_setup(const char *name, unsigned long addr,
         inode->i_size = size;
         clear_nlink(inode);
 
-        error = -ENFILE;
         file = alloc_file(&path, FMODE_WRITE | FMODE_READ,
                         &hugetlbfs_file_operations);
-        if (!file)
+        if (IS_ERR(file))
                 goto out_dentry; /* inode is already attached */
 
         return file;
@@ -998,7 +1007,7 @@ out_shm_unlock:
                 user_shm_unlock(size, *user);
                 *user = NULL;
         }
-        return ERR_PTR(error);
+        return file;
 }
 
 static int __init init_hugetlbfs_fs(void)
diff --git a/fs/inode.c b/fs/inode.c
index 14084b72b259..67880e604399 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1655,7 +1655,7 @@ EXPORT_SYMBOL(file_remove_suid);
 
 int file_update_time(struct file *file)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct timespec now;
         int sync_it = 0;
         int ret;
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 3bdad6d1f268..fd507fb460f8 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -175,7 +175,7 @@ static int ioctl_fiemap(struct file *filp, unsigned long arg)
         struct fiemap fiemap;
         struct fiemap __user *ufiemap = (struct fiemap __user *) arg;
         struct fiemap_extent_info fieinfo = { 0, };
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         u64 len;
         int error;
@@ -424,7 +424,7 @@ EXPORT_SYMBOL(generic_block_fiemap);
  */
 int ioctl_preallocate(struct file *filp, void __user *argp)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct space_resv sr;
 
         if (copy_from_user(&sr, argp, sizeof(sr)))
@@ -449,7 +449,7 @@ int ioctl_preallocate(struct file *filp, void __user *argp)
 static int file_ioctl(struct file *filp, unsigned int cmd,
                 unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int __user *p = (int __user *)arg;
 
         switch (cmd) {
@@ -512,7 +512,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,
 
 static int ioctl_fsfreeze(struct file *filp)
 {
-        struct super_block *sb = filp->f_path.dentry->d_inode->i_sb;
+        struct super_block *sb = file_inode(filp)->i_sb;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -527,7 +527,7 @@ static int ioctl_fsfreeze(struct file *filp)
 
 static int ioctl_fsthaw(struct file *filp)
 {
-        struct super_block *sb = filp->f_path.dentry->d_inode->i_sb;
+        struct super_block *sb = file_inode(filp)->i_sb;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -548,7 +548,7 @@ int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
 {
         int error = 0;
         int __user *argp = (int __user *)arg;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         switch (cmd) {
         case FIOCLEX:
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index 0b3fa7974fa8..592e5115a561 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -296,7 +296,7 @@ static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
  */
 static int zisofs_readpage(struct file *file, struct page *page)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct address_space *mapping = inode->i_mapping;
         int err;
         int i, pcount, full_page;
diff --git a/fs/isofs/dir.c b/fs/isofs/dir.c
index f20437c068a0..a7d5c3c3d4e6 100644
--- a/fs/isofs/dir.c
+++ b/fs/isofs/dir.c
@@ -253,7 +253,7 @@ static int isofs_readdir(struct file *filp,
         int result;
         char *tmpname;
         struct iso_directory_record *tmpde;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         tmpname = (char *)__get_free_page(GFP_KERNEL);
         if (tmpname == NULL)
diff --git a/fs/isofs/export.c b/fs/isofs/export.c
index 2b4f2358eadb..12088d8de3fa 100644
--- a/fs/isofs/export.c
+++ b/fs/isofs/export.c
@@ -125,10 +125,10 @@ isofs_export_encode_fh(struct inode *inode,
          */
         if (parent && (len < 5)) {
                 *max_len = 5;
-                return 255;
+                return FILEID_INVALID;
         } else if (len < 3) {
                 *max_len = 3;
-                return 255;
+                return FILEID_INVALID;
         }
 
         len = 3;
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index ad7774d32095..acd46a4160cb 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -117,12 +117,12 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
 static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         struct jffs2_inode_info *f;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct jffs2_full_dirent *fd;
         unsigned long offset, curofs;
 
         jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n",
-                  filp->f_path.dentry->d_inode->i_ino);
+                  file_inode(filp)->i_ino);
 
         f = JFFS2_INODE_INFO(inode);
 
diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c
index bc555ff417e9..93a1232894f6 100644
--- a/fs/jfs/ioctl.c
+++ b/fs/jfs/ioctl.c
@@ -58,7 +58,7 @@ static long jfs_map_ext2(unsigned long flags, int from)
 
 long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct jfs_inode_info *jfs_inode = JFS_IP(inode);
         unsigned int flags;
 
diff --git a/fs/jfs/jfs_dtree.c b/fs/jfs/jfs_dtree.c
index 9197a1b0d02d..0ddbeceafc62 100644
--- a/fs/jfs/jfs_dtree.c
+++ b/fs/jfs/jfs_dtree.c
@@ -3004,7 +3004,7 @@ static inline struct jfs_dirent *next_jfs_dirent(struct jfs_dirent *dirent)
  */
 int jfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *ip = filp->f_path.dentry->d_inode;
+        struct inode *ip = file_inode(filp);
         struct nls_table *codepage = JFS_SBI(ip->i_sb)->nls_tab;
         int rc = 0;
         loff_t dtpos;   /* legacy OS/2 style position */
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index ca0a08001449..a2717408c478 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -178,7 +178,7 @@ __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock)
                         continue;
                 if (!rpc_cmp_addr(nlm_addr(block->b_host), addr))
                         continue;
-                if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_path.dentry->d_inode) ,fh) != 0)
+                if (nfs_compare_fh(NFS_FH(file_inode(fl_blocked->fl_file)) ,fh) != 0)
                         continue;
                 /* Alright, we found a lock. Set the return status
                  * and wake up the caller
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index 52e5120bb159..366277190b82 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -127,7 +127,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl)
         struct nlm_lock *lock = &argp->lock;
 
         nlmclnt_next_cookie(&argp->cookie);
-        memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), sizeof(struct nfs_fh));
+        memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_file)), sizeof(struct nfs_fh));
         lock->caller  = utsname()->nodename;
         lock->oh.data = req->a_owner;
         lock->oh.len  = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index 8d80c990dffd..e703318c41df 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -406,8 +406,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
         __be32                  ret;
 
         dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
-                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_path.dentry->d_inode->i_ino,
+                                file_inode(file->f_file)->i_sb->s_id,
+                                file_inode(file->f_file)->i_ino,
                                 lock->fl.fl_type, lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end,
@@ -513,8 +513,8 @@ nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
         __be32                  ret;
 
         dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
-                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_path.dentry->d_inode->i_ino,
+                                file_inode(file->f_file)->i_sb->s_id,
+                                file_inode(file->f_file)->i_ino,
                                 lock->fl.fl_type,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
@@ -606,8 +606,8 @@ nlmsvc_unlock(struct net *net, struct nlm_file *file, struct nlm_lock *lock)
         int     error;
 
         dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
-                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_path.dentry->d_inode->i_ino,
+                                file_inode(file->f_file)->i_sb->s_id,
+                                file_inode(file->f_file)->i_ino,
                                 lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
@@ -635,8 +635,8 @@ nlmsvc_cancel_blocked(struct net *net, struct nlm_file *file, struct nlm_lock *l
         int status = 0;
 
         dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
-                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_path.dentry->d_inode->i_ino,
+                                file_inode(file->f_file)->i_sb->s_id,
+                                file_inode(file->f_file)->i_ino,
                                 lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index 0deb5f6c9dd4..b3a24b07d981 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -45,7 +45,7 @@ static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
 
 static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
 {
-        struct inode *inode = file->f_file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file->f_file);
 
         dprintk("lockd: %s %s/%ld\n",
                 msg, inode->i_sb->s_id, inode->i_ino);
diff --git a/fs/locks.c b/fs/locks.c
index a94e331a52a2..cb424a4fed71 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -334,7 +334,7 @@ static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
                 start = filp->f_pos;
                 break;
         case SEEK_END:
-                start = i_size_read(filp->f_path.dentry->d_inode);
+                start = i_size_read(file_inode(filp));
                 break;
         default:
                 return -EINVAL;
@@ -384,7 +384,7 @@ static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
                 start = filp->f_pos;
                 break;
         case SEEK_END:
-                start = i_size_read(filp->f_path.dentry->d_inode);
+                start = i_size_read(file_inode(filp));
                 break;
         default:
                 return -EINVAL;
@@ -627,7 +627,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
         struct file_lock *cfl;
 
         lock_flocks();
-        for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
+        for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) {
                 if (!IS_POSIX(cfl))
                         continue;
                 if (posix_locks_conflict(fl, cfl))
@@ -708,7 +708,7 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
 {
         struct file_lock *new_fl = NULL;
         struct file_lock **before;
-        struct inode * inode = filp->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(filp);
         int error = 0;
         int found = 0;
 
@@ -1002,7 +1002,7 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str
 int posix_lock_file(struct file *filp, struct file_lock *fl,
                         struct file_lock *conflock)
 {
-        return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock);
+        return __posix_lock_file(file_inode(filp), fl, conflock);
 }
 EXPORT_SYMBOL(posix_lock_file);
 
@@ -1326,8 +1326,8 @@ int fcntl_getlease(struct file *filp)
         int type = F_UNLCK;
 
         lock_flocks();
-        time_out_leases(filp->f_path.dentry->d_inode);
-        for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl);
+        time_out_leases(file_inode(filp));
+        for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl);
                         fl = fl->fl_next) {
                 if (fl->fl_file == filp) {
                         type = target_leasetype(fl);
@@ -1843,7 +1843,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
         if (copy_from_user(&flock, l, sizeof(flock)))
                 goto out;
 
-        inode = filp->f_path.dentry->d_inode;
+        inode = file_inode(filp);
 
         /* Don't allow mandatory locks on files that may be memory mapped
          * and shared.
@@ -1961,7 +1961,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
         if (copy_from_user(&flock, l, sizeof(flock)))
                 goto out;
 
-        inode = filp->f_path.dentry->d_inode;
+        inode = file_inode(filp);
 
         /* Don't allow mandatory locks on files that may be memory mapped
          * and shared.
@@ -2030,7 +2030,7 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner)
          * posix_lock_file().  Another process could be setting a lock on this
          * file at the same time, but we wouldn't remove that lock anyway.
          */
-        if (!filp->f_path.dentry->d_inode->i_flock)
+        if (!file_inode(filp)->i_flock)
                 return;
 
         lock.fl_type = F_UNLCK;
@@ -2056,7 +2056,7 @@ EXPORT_SYMBOL(locks_remove_posix);
  */
 void locks_remove_flock(struct file *filp)
 {
-        struct inode * inode = filp->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(filp);
         struct file_lock *fl;
         struct file_lock **before;
 
@@ -2152,7 +2152,7 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl,
                 fl_pid = fl->fl_pid;
 
         if (fl->fl_file != NULL)
-                inode = fl->fl_file->f_path.dentry->d_inode;
+                inode = file_inode(fl->fl_file);
 
         seq_printf(f, "%lld:%s ", id, pfx);
         if (IS_POSIX(fl)) {
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 26e4a941532f..b82751082112 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -284,7 +284,7 @@ static int logfs_rmdir(struct inode *dir, struct dentry *dentry)
 #define IMPLICIT_NODES 2
 static int __logfs_readdir(struct file *file, void *buf, filldir_t filldir)
 {
-        struct inode *dir = file->f_dentry->d_inode;
+        struct inode *dir = file_inode(file);
         loff_t pos = file->f_pos - IMPLICIT_NODES;
         struct page *page;
         struct logfs_disk_dentry *dd;
@@ -320,7 +320,7 @@ static int __logfs_readdir(struct file *file, void *buf, filldir_t filldir)
 
 static int logfs_readdir(struct file *file, void *buf, filldir_t filldir)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         ino_t pino = parent_ino(file->f_dentry);
         int err;
 
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index 3886cded283c..c2219a6dd3c8 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -183,7 +183,7 @@ static int logfs_releasepage(struct page *page, gfp_t only_xfs_uses_this)
 
 long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct logfs_inode *li = logfs_inode(inode);
         unsigned int oldflags, flags;
         int err;
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index 685b2d981b87..a9ed6f36e6ea 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -85,7 +85,7 @@ static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
         unsigned long pos = filp->f_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         unsigned offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/namei.c b/fs/namei.c
index 43a97ee1d4c8..dc984fee5532 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -600,14 +600,10 @@ static int complete_walk(struct nameidata *nd)
         if (likely(!(nd->flags & LOOKUP_JUMPED)))
                 return 0;
 
-        if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
+        if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE)))
                 return 0;
 
-        if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
-                return 0;
-
-        /* Note: we do not d_invalidate() */
-        status = d_revalidate(dentry, nd->flags);
+        status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);
         if (status > 0)
                 return 0;
 
@@ -1342,7 +1338,7 @@ static struct dentry *__lookup_hash(struct qstr *name,
  *  small and for now I'd prefer to have fast path as straight as possible.
  *  It _is_ time-critical.
  */
-static int lookup_fast(struct nameidata *nd, struct qstr *name,
+static int lookup_fast(struct nameidata *nd,
                        struct path *path, struct inode **inode)
 {
         struct vfsmount *mnt = nd->path.mnt;
@@ -1358,7 +1354,7 @@ static int lookup_fast(struct nameidata *nd, struct qstr *name,
          */
         if (nd->flags & LOOKUP_RCU) {
                 unsigned seq;
-                dentry = __d_lookup_rcu(parent, name, &seq, nd->inode);
+                dentry = __d_lookup_rcu(parent, &nd->last, &seq, nd->inode);
                 if (!dentry)
                         goto unlazy;
 
@@ -1400,7 +1396,7 @@ unlazy:
                 if (unlazy_walk(nd, dentry))
                         return -ECHILD;
         } else {
-                dentry = __d_lookup(parent, name);
+                dentry = __d_lookup(parent, &nd->last);
         }
 
         if (unlikely(!dentry))
@@ -1436,8 +1432,7 @@ need_lookup:
 }
 
 /* Fast lookup failed, do it the slow way */
-static int lookup_slow(struct nameidata *nd, struct qstr *name,
-                       struct path *path)
+static int lookup_slow(struct nameidata *nd, struct path *path)
 {
         struct dentry *dentry, *parent;
         int err;
@@ -1446,7 +1441,7 @@ static int lookup_slow(struct nameidata *nd, struct qstr *name,
         BUG_ON(nd->inode != parent->d_inode);
 
         mutex_lock(&parent->d_inode->i_mutex);
-        dentry = __lookup_hash(name, parent, nd->flags);
+        dentry = __lookup_hash(&nd->last, parent, nd->flags);
         mutex_unlock(&parent->d_inode->i_mutex);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
@@ -1519,7 +1514,7 @@ static inline int should_follow_link(struct inode *inode, int follow)
 }
 
 static inline int walk_component(struct nameidata *nd, struct path *path,
-                struct qstr *name, int type, int follow)
+                int follow)
 {
         struct inode *inode;
         int err;
@@ -1528,14 +1523,14 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
          * to be able to know about the current root directory and
          * parent relationships.
          */
-        if (unlikely(type != LAST_NORM))
-                return handle_dots(nd, type);
-        err = lookup_fast(nd, name, path, &inode);
+        if (unlikely(nd->last_type != LAST_NORM))
+                return handle_dots(nd, nd->last_type);
+        err = lookup_fast(nd, path, &inode);
         if (unlikely(err)) {
                 if (err < 0)
                         goto out_err;
 
-                err = lookup_slow(nd, name, path);
+                err = lookup_slow(nd, path);
                 if (err < 0)
                         goto out_err;
 
@@ -1594,8 +1589,7 @@ static inline int nested_symlink(struct path *path, struct nameidata *nd)
                 res = follow_link(&link, nd, &cookie);
                 if (res)
                         break;
-                res = walk_component(nd, path, &nd->last,
-                                     nd->last_type, LOOKUP_FOLLOW);
+                res = walk_component(nd, path, LOOKUP_FOLLOW);
                 put_link(nd, &link, cookie);
         } while (res > 0);
 
@@ -1802,8 +1796,11 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                         }
                 }
 
+                nd->last = this;
+                nd->last_type = type;
+
                 if (!name[len])
-                        goto last_component;
+                        return 0;
                 /*
                  * If it wasn't NUL, we know it was '/'. Skip that
                  * slash, and continue until no more slashes.
@@ -1812,10 +1809,11 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                         len++;
                 } while (unlikely(name[len] == '/'));
                 if (!name[len])
-                        goto last_component;
+                        return 0;
+
                 name += len;
 
-                err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
+                err = walk_component(nd, &next, LOOKUP_FOLLOW);
                 if (err < 0)
                         return err;
 
@@ -1824,16 +1822,10 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                         if (err)
                                 return err;
                 }
-                if (can_lookup(nd->inode))
-                        continue;
-                err = -ENOTDIR; 
-                break;
-                /* here ends the main loop */
-
-last_component:
-                nd->last = this;
-                nd->last_type = type;
-                return 0;
+                if (!can_lookup(nd->inode)) {
+                        err = -ENOTDIR; 
+                        break;
+                }
         }
         terminate_walk(nd);
         return err;
@@ -1932,8 +1924,7 @@ static inline int lookup_last(struct nameidata *nd, struct path *path)
                 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
 
         nd->flags &= ~LOOKUP_PARENT;
-        return walk_component(nd, path, &nd->last, nd->last_type,
-                                        nd->flags & LOOKUP_FOLLOW);
+        return walk_component(nd, path, nd->flags & LOOKUP_FOLLOW);
 }
 
 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
@@ -2732,7 +2723,7 @@ static int do_last(struct nameidata *nd, struct path *path,
                 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
                         symlink_ok = true;
                 /* we _can_ be in RCU mode here */
-                error = lookup_fast(nd, &nd->last, path, &inode);
+                error = lookup_fast(nd, path, &inode);
                 if (likely(!error))
                         goto finish_lookup;
 
@@ -2778,7 +2769,7 @@ retry_lookup:
                         goto out;
 
                 if ((*opened & FILE_CREATED) ||
-                    !S_ISREG(file->f_path.dentry->d_inode->i_mode))
+                    !S_ISREG(file_inode(file)->i_mode))
                         will_truncate = false;
 
                 audit_inode(name, file->f_path.dentry, 0);
@@ -2941,8 +2932,8 @@ static struct file *path_openat(int dfd, struct filename *pathname,
         int error;
 
         file = get_empty_filp();
-        if (!file)
-                return ERR_PTR(-ENFILE);
+        if (IS_ERR(file))
+                return file;
 
         file->f_flags = op->open_flag;
 
diff --git a/fs/namespace.c b/fs/namespace.c
index edac42c6eff2..50ca17d3cb45 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -384,7 +384,7 @@ EXPORT_SYMBOL_GPL(mnt_clone_write);
  */
 int __mnt_want_write_file(struct file *file)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         if (!(file->f_mode & FMODE_WRITE) || special_file(inode->i_mode))
                 return __mnt_want_write(file->f_path.mnt);
@@ -1300,24 +1300,6 @@ SYSCALL_DEFINE1(oldumount, char __user *, name)
 
 #endif
 
-static int mount_is_safe(struct path *path)
-{
-        if (may_mount())
-                return 0;
-        return -EPERM;
-#ifdef notyet
-        if (S_ISLNK(path->dentry->d_inode->i_mode))
-                return -EPERM;
-        if (path->dentry->d_inode->i_mode & S_ISVTX) {
-                if (current_uid() != path->dentry->d_inode->i_uid)
-                        return -EPERM;
-        }
-        if (inode_permission(path->dentry->d_inode, MAY_WRITE))
-                return -EPERM;
-        return 0;
-#endif
-}
-
 static bool mnt_ns_loop(struct path *path)
 {
         /* Could bind mounting the mount namespace inode cause a
@@ -1640,9 +1622,6 @@ static int do_change_type(struct path *path, int flag)
         int type;
         int err = 0;
 
-        if (!may_mount())
-                return -EPERM;
-
         if (path->dentry != path->mnt->mnt_root)
                 return -EINVAL;
 
@@ -1676,9 +1655,7 @@ static int do_loopback(struct path *path, const char *old_name,
         LIST_HEAD(umount_list);
         struct path old_path;
         struct mount *mnt = NULL, *old;
-        int err = mount_is_safe(path);
-        if (err)
-                return err;
+        int err;
         if (!old_name || !*old_name)
                 return -EINVAL;
         err = kern_path(old_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
@@ -1755,9 +1732,6 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
         struct super_block *sb = path->mnt->mnt_sb;
         struct mount *mnt = real_mount(path->mnt);
 
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-
         if (!check_mnt(mnt))
                 return -EINVAL;
 
@@ -1771,6 +1745,8 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
         down_write(&sb->s_umount);
         if (flags & MS_BIND)
                 err = change_mount_flags(path->mnt, flags);
+        else if (!capable(CAP_SYS_ADMIN))
+                err = -EPERM;
         else
                 err = do_remount_sb(sb, flags, data, 0);
         if (!err) {
@@ -1803,9 +1779,7 @@ static int do_move_mount(struct path *path, const char *old_name)
         struct path old_path, parent_path;
         struct mount *p;
         struct mount *old;
-        int err = 0;
-        if (!may_mount())
-                return -EPERM;
+        int err;
         if (!old_name || !*old_name)
                 return -EINVAL;
         err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
@@ -1947,9 +1921,6 @@ static int do_new_mount(struct path *path, const char *fstype, int flags,
         if (!fstype)
                 return -EINVAL;
 
-        if (!may_mount())
-                return -EPERM;
-
         type = get_fs_type(fstype);
         if (!type)
                 return -ENODEV;
@@ -2263,6 +2234,9 @@ long do_mount(const char *dev_name, const char *dir_name,
         if (retval)
                 goto dput_out;
 
+        if (!may_mount())
+                return -EPERM;
+
         /* Default to relatime unless overriden */
         if (!(flags & MS_NOATIME))
                 mnt_flags |= MNT_RELATIME;
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 4117e7b377bb..816326093656 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -593,14 +593,10 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                 return 1; /* I'm not sure */
 
         qname.name = __name;
-        qname.hash = full_name_hash(qname.name, qname.len);
-
-        if (dentry->d_op && dentry->d_op->d_hash)
-                if (dentry->d_op->d_hash(dentry, dentry->d_inode, &qname) != 0)
-                        goto end_advance;
-
-        newdent = d_lookup(dentry, &qname);
 
+        newdent = d_hash_and_lookup(dentry, &qname);
+        if (unlikely(IS_ERR(newdent)))
+                goto end_advance;
         if (!newdent) {
                 newdent = d_alloc(dentry, &qname);
                 if (!newdent)
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index e2be336d1c22..7dafd6899a62 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -538,7 +538,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
         if (!ncp_filp)
                 goto out;
         error = -ENOTSOCK;
-        sock_inode = ncp_filp->f_path.dentry->d_inode;
+        sock_inode = file_inode(ncp_filp);
         if (!S_ISSOCK(sock_inode->i_mode))
                 goto out_fput;
         sock = SOCKET_I(sock_inode);
@@ -577,7 +577,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
                 if (!server->info_filp)
                         goto out_bdi;
                 error = -ENOTSOCK;
-                sock_inode = server->info_filp->f_path.dentry->d_inode;
+                sock_inode = file_inode(server->info_filp);
                 if (!S_ISSOCK(sock_inode->i_mode))
                         goto out_fput2;
                 info_sock = SOCKET_I(sock_inode);
diff --git a/fs/ncpfs/ioctl.c b/fs/ncpfs/ioctl.c
index d44318d27504..60426ccb3b65 100644
--- a/fs/ncpfs/ioctl.c
+++ b/fs/ncpfs/ioctl.c
@@ -811,7 +811,7 @@ outrel:
 
 long ncp_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ncp_server *server = NCP_SERVER(inode);
         kuid_t uid = current_uid();
         int need_drop_write = 0;
@@ -822,7 +822,7 @@ long ncp_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         case NCP_IOC_CONN_LOGGED_IN:
         case NCP_IOC_SETROOT:
                 if (!capable(CAP_SYS_ADMIN)) {
-                        ret = -EACCES;
+                        ret = -EPERM;
                         goto out;
                 }
                 break;
diff --git a/fs/ncpfs/mmap.c b/fs/ncpfs/mmap.c
index 63d14a99483d..ee24df5af1f9 100644
--- a/fs/ncpfs/mmap.c
+++ b/fs/ncpfs/mmap.c
@@ -105,7 +105,7 @@ static const struct vm_operations_struct ncp_file_mmap =
 /* This is used for a general mmap of a ncp file */
 int ncp_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         
         DPRINTK("ncp_mmap: called\n");
 
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 1b2d7eb93796..f23f455be42b 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -281,7 +281,7 @@ int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_des
 
         for (i = 0; i < array->size; i++) {
                 if (array->array[i].cookie == *desc->dir_cookie) {
-                        struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
+                        struct nfs_inode *nfsi = NFS_I(file_inode(desc->file));
                         struct nfs_open_dir_context *ctx = desc->file->private_data;
 
                         new_pos = desc->current_index + i;
@@ -629,7 +629,7 @@ out:
 static
 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
 {
-        struct inode    *inode = desc->file->f_path.dentry->d_inode;
+        struct inode    *inode = file_inode(desc->file);
         int ret;
 
         ret = nfs_readdir_xdr_to_array(desc, page, inode);
@@ -660,7 +660,7 @@ void cache_page_release(nfs_readdir_descriptor_t *desc)
 static
 struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
 {
-        return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
+        return read_cache_page(file_inode(desc->file)->i_mapping,
                         desc->page_index, (filler_t *)nfs_readdir_filler, desc);
 }
 
@@ -764,7 +764,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
 {
         struct page     *page = NULL;
         int             status;
-        struct inode *inode = desc->file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(desc->file);
         struct nfs_open_dir_context *ctx = desc->file->private_data;
 
         dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
@@ -1136,6 +1136,45 @@ out_error:
 }
 
 /*
+ * A weaker form of d_revalidate for revalidating just the dentry->d_inode
+ * when we don't really care about the dentry name. This is called when a
+ * pathwalk ends on a dentry that was not found via a normal lookup in the
+ * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
+ *
+ * In this situation, we just want to verify that the inode itself is OK
+ * since the dentry might have changed on the server.
+ */
+static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
+{
+        int error;
+        struct inode *inode = dentry->d_inode;
+
+        /*
+         * I believe we can only get a negative dentry here in the case of a
+         * procfs-style symlink. Just assume it's correct for now, but we may
+         * eventually need to do something more here.
+         */
+        if (!inode) {
+                dfprintk(LOOKUPCACHE, "%s: %s/%s has negative inode\n",
+                                __func__, dentry->d_parent->d_name.name,
+                                dentry->d_name.name);
+                return 1;
+        }
+
+        if (is_bad_inode(inode)) {
+                dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
+                                __func__, dentry->d_parent->d_name.name,
+                                dentry->d_name.name);
+                return 0;
+        }
+
+        error = nfs_revalidate_inode(NFS_SERVER(inode), inode);
+        dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
+                        __func__, inode->i_ino, error ? "invalid" : "valid");
+        return !error;
+}
+
+/*
  * This is called from dput() when d_count is going to 0.
  */
 static int nfs_dentry_delete(const struct dentry *dentry)
@@ -1202,6 +1241,7 @@ static void nfs_d_release(struct dentry *dentry)
 
 const struct dentry_operations nfs_dentry_operations = {
         .d_revalidate   = nfs_lookup_revalidate,
+        .d_weak_revalidate      = nfs_weak_revalidate,
         .d_delete       = nfs_dentry_delete,
         .d_iput         = nfs_dentry_iput,
         .d_automount    = nfs_d_automount,
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 3c2b893665ba..29f4a48a0ee6 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -292,7 +292,7 @@ static int
 nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         int ret;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         do {
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index b9623d19d599..dc0f98dfa717 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -765,7 +765,7 @@ out:
 static ssize_t
 idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 {
-        struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
+        struct rpc_inode *rpci = RPC_I(file_inode(filp));
         struct idmap *idmap = (struct idmap *)rpci->private;
         struct key_construction *cons;
         struct idmap_msg im;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 468ba8bf0f56..b586fe9af475 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -711,7 +711,7 @@ EXPORT_SYMBOL_GPL(put_nfs_open_context);
  */
 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct nfs_inode *nfsi = NFS_I(inode);
 
         filp->private_data = get_nfs_open_context(ctx);
@@ -744,7 +744,7 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
 
 static void nfs_file_clear_open_context(struct file *filp)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct nfs_open_context *ctx = nfs_file_open_context(filp);
 
         if (ctx) {
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 70efb63b1e42..43ea96ced28c 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -872,7 +872,7 @@ static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_mess
 static int
 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
 }
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 08ddcccb8887..13e6bb3e3fe5 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -94,7 +94,7 @@ static int
 nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         int ret;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         do {
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 84d2e9e2f313..569b166cc050 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -28,7 +28,7 @@ static struct file_system_type nfs4_remote_fs_type = {
         .name           = "nfs4",
         .mount          = nfs4_remote_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 
 static struct file_system_type nfs4_remote_referral_fs_type = {
@@ -36,7 +36,7 @@ static struct file_system_type nfs4_remote_referral_fs_type = {
         .name           = "nfs4",
         .mount          = nfs4_remote_referral_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 
 struct file_system_type nfs4_referral_fs_type = {
@@ -44,7 +44,7 @@ struct file_system_type nfs4_referral_fs_type = {
         .name           = "nfs4",
         .mount          = nfs4_referral_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 
 static const struct super_operations nfs4_sops = {
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index f084dac948e1..fc8de9016acf 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -662,7 +662,7 @@ nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
 static int
 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
 }
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index befbae0cce41..a9dc5fc29955 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -291,7 +291,7 @@ struct file_system_type nfs_fs_type = {
         .name           = "nfs",
         .mount          = nfs_fs_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 EXPORT_SYMBOL_GPL(nfs_fs_type);
 
@@ -300,7 +300,7 @@ struct file_system_type nfs_xdev_fs_type = {
         .name           = "nfs",
         .mount          = nfs_xdev_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 
 const struct super_operations nfs_sops = {
@@ -330,7 +330,7 @@ struct file_system_type nfs4_fs_type = {
         .name           = "nfs4",
         .mount          = nfs_fs_mount,
         .kill_sb        = nfs_kill_super,
-        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+        .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
 };
 EXPORT_SYMBOL_GPL(nfs4_fs_type);
 
diff --git a/fs/nfsd/fault_inject.c b/fs/nfsd/fault_inject.c
index e761ee95617f..497584c70366 100644
--- a/fs/nfsd/fault_inject.c
+++ b/fs/nfsd/fault_inject.c
@@ -101,7 +101,7 @@ static ssize_t fault_inject_read(struct file *file, char __user *buf,
         loff_t pos = *ppos;
 
         if (!pos)
-                nfsd_inject_get(file->f_dentry->d_inode->i_private, &val);
+                nfsd_inject_get(file_inode(file)->i_private, &val);
         size = scnprintf(read_buf, sizeof(read_buf), "%llu\n", val);
 
         if (pos < 0)
@@ -133,10 +133,10 @@ static ssize_t fault_inject_write(struct file *file, const char __user *buf,
 
         size = rpc_pton(net, write_buf, size, (struct sockaddr *)&sa, sizeof(sa));
         if (size > 0)
-                nfsd_inject_set_client(file->f_dentry->d_inode->i_private, &sa, size);
+                nfsd_inject_set_client(file_inode(file)->i_private, &sa, size);
         else {
                 val = simple_strtoll(write_buf, NULL, 0);
-                nfsd_inject_set(file->f_dentry->d_inode->i_private, val);
+                nfsd_inject_set(file_inode(file)->i_private, val);
         }
         return len; /* on success, claim we got the whole input */
 }
diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c
index 9170861c804a..95d76dc6c5da 100644
--- a/fs/nfsd/nfs2acl.c
+++ b/fs/nfsd/nfs2acl.c
@@ -45,6 +45,10 @@ static __be32 nfsacld_proc_getacl(struct svc_rqst * rqstp,
                 RETURN_STATUS(nfserr_inval);
         resp->mask = argp->mask;
 
+        nfserr = fh_getattr(fh, &resp->stat);
+        if (nfserr)
+                goto fail;
+
         if (resp->mask & (NFS_ACL|NFS_ACLCNT)) {
                 acl = nfsd_get_posix_acl(fh, ACL_TYPE_ACCESS);
                 if (IS_ERR(acl)) {
@@ -115,6 +119,9 @@ static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
                 nfserr = nfserrno( nfsd_set_posix_acl(
                         fh, ACL_TYPE_DEFAULT, argp->acl_default) );
         }
+        if (!nfserr) {
+                nfserr = fh_getattr(fh, &resp->stat);
+        }
 
         /* argp->acl_{access,default} may have been allocated in
            nfssvc_decode_setaclargs. */
@@ -129,10 +136,15 @@ static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
 static __be32 nfsacld_proc_getattr(struct svc_rqst * rqstp,
                 struct nfsd_fhandle *argp, struct nfsd_attrstat *resp)
 {
+        __be32 nfserr;
         dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 
         fh_copy(&resp->fh, &argp->fh);
-        return fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
+        nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
+        if (nfserr)
+                return nfserr;
+        nfserr = fh_getattr(&resp->fh, &resp->stat);
+        return nfserr;
 }
 
 /*
@@ -150,6 +162,9 @@ static __be32 nfsacld_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessarg
         fh_copy(&resp->fh, &argp->fh);
         resp->access = argp->access;
         nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
+        if (nfserr)
+                return nfserr;
+        nfserr = fh_getattr(&resp->fh, &resp->stat);
         return nfserr;
 }
 
@@ -243,7 +258,7 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
                 return 0;
         inode = dentry->d_inode;
 
-        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh);
+        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         *p++ = htonl(resp->mask);
         if (!xdr_ressize_check(rqstp, p))
                 return 0;
@@ -274,7 +289,7 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
 static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p,
                 struct nfsd_attrstat *resp)
 {
-        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh);
+        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         return xdr_ressize_check(rqstp, p);
 }
 
@@ -282,7 +297,7 @@ static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p,
 static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
                 struct nfsd3_accessres *resp)
 {
-        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh);
+        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         *p++ = htonl(resp->access);
         return xdr_ressize_check(rqstp, p);
 }
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 1fc02dfdc5c4..401289913130 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -43,7 +43,6 @@ static __be32
 nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
                                            struct nfsd3_attrstat *resp)
 {
-        int     err;
         __be32  nfserr;
 
         dprintk("nfsd: GETATTR(3)  %s\n",
@@ -55,9 +54,7 @@ nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
         if (nfserr)
                 RETURN_STATUS(nfserr);
 
-        err = vfs_getattr(resp->fh.fh_export->ex_path.mnt,
-                          resp->fh.fh_dentry, &resp->stat);
-        nfserr = nfserrno(err);
+        nfserr = fh_getattr(&resp->fh, &resp->stat);
 
         RETURN_STATUS(nfserr);
 }
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 925c944bc0bc..14d9ecb96cff 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -11,6 +11,7 @@
 #include "xdr3.h"
 #include "auth.h"
 #include "netns.h"
+#include "vfs.h"
 
 #define NFSDDBG_FACILITY                NFSDDBG_XDR
 
@@ -206,10 +207,10 @@ encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
         struct dentry *dentry = fhp->fh_dentry;
         if (dentry && dentry->d_inode) {
-                int err;
+                __be32 err;
                 struct kstat stat;
 
-                err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
+                err = fh_getattr(fhp, &stat);
                 if (!err) {
                         *p++ = xdr_one;         /* attributes follow */
                         lease_get_mtime(dentry->d_inode, &stat.mtime);
@@ -256,13 +257,12 @@ encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
  */
 void fill_post_wcc(struct svc_fh *fhp)
 {
-        int err;
+        __be32 err;
 
         if (fhp->fh_post_saved)
                 printk("nfsd: inode locked twice during operation.\n");
 
-        err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
-                        &fhp->fh_post_attr);
+        err = fh_getattr(fhp, &fhp->fh_post_attr);
         fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
         if (err) {
                 fhp->fh_post_saved = 0;
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 2d1d06bae3a7..8ca6d17f6cf3 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2015,7 +2015,7 @@ static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
                 if (path.dentry != path.mnt->mnt_root)
                         break;
         }
-        err = vfs_getattr(path.mnt, path.dentry, stat);
+        err = vfs_getattr(&path, stat);
         path_put(&path);
         return err;
 }
@@ -2068,7 +2068,7 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
                         goto out;
         }
 
-        err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);
+        err = vfs_getattr(&path, &stat);
         if (err)
                 goto out_nfserr;
         if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 74934284d9a7..2db7021b01ae 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -85,7 +85,7 @@ static ssize_t (*write_op[])(struct file *, char *, size_t) = {
 
 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
 {
-        ino_t ino =  file->f_path.dentry->d_inode->i_ino;
+        ino_t ino =  file_inode(file)->i_ino;
         char *data;
         ssize_t rv;
 
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index aad6d457b9e8..54c6b3d3cc79 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -26,17 +26,13 @@ static __be32
 nfsd_return_attrs(__be32 err, struct nfsd_attrstat *resp)
 {
         if (err) return err;
-        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
-                                    resp->fh.fh_dentry,
-                                    &resp->stat));
+        return fh_getattr(&resp->fh, &resp->stat);
 }
 static __be32
 nfsd_return_dirop(__be32 err, struct nfsd_diropres *resp)
 {
         if (err) return err;
-        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
-                                    resp->fh.fh_dentry,
-                                    &resp->stat));
+        return fh_getattr(&resp->fh, &resp->stat);
 }
 /*
  * Get a file's attributes
@@ -150,9 +146,7 @@ nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
                                   &resp->count);
 
         if (nfserr) return nfserr;
-        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
-                                    resp->fh.fh_dentry,
-                                    &resp->stat));
+        return fh_getattr(&resp->fh, &resp->stat);
 }
 
 /*
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 4201ede0ec91..9c769a47ac5a 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -4,6 +4,7 @@
  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  */
 
+#include "vfs.h"
 #include "xdr.h"
 #include "auth.h"
 
@@ -196,11 +197,9 @@ encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
 }
 
 /* Helper function for NFSv2 ACL code */
-__be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
+__be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, struct kstat *stat)
 {
-        struct kstat stat;
-        vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry, &stat);
-        return encode_fattr(rqstp, p, fhp, &stat);
+        return encode_fattr(rqstp, p, fhp, stat);
 }
 
 /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 31ff1d642e31..2a7eb536de0b 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -979,7 +979,7 @@ static void kill_suid(struct dentry *dentry)
  */
 static int wait_for_concurrent_writes(struct file *file)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         static ino_t last_ino;
         static dev_t last_dev;
         int err = 0;
@@ -1070,7 +1070,7 @@ __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (err)
                 return err;
 
-        inode = file->f_path.dentry->d_inode;
+        inode = file_inode(file);
 
         /* Get readahead parameters */
         ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino);
@@ -1957,7 +1957,7 @@ static __be32 nfsd_buffered_readdir(struct file *file, filldir_t func,
         offset = *offsetp;
 
         while (1) {
-                struct inode *dir_inode = file->f_path.dentry->d_inode;
+                struct inode *dir_inode = file_inode(file);
                 unsigned int reclen;
 
                 cdp->err = nfserr_eof; /* will be cleared on successful read */
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index 359594c393d2..5b5894159f22 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -6,6 +6,7 @@
 #define LINUX_NFSD_VFS_H
 
 #include "nfsfh.h"
+#include "nfsd.h"
 
 /*
  * Flags for nfsd_permission
@@ -125,4 +126,11 @@ static inline void fh_drop_write(struct svc_fh *fh)
         }
 }
 
+static inline __be32 fh_getattr(struct svc_fh *fh, struct kstat *stat)
+{
+        struct path p = {.mnt = fh->fh_export->ex_path.mnt,
+                         .dentry = fh->fh_dentry};
+        return nfserrno(vfs_getattr(&p, stat));
+}
+
 #endif /* LINUX_NFSD_VFS_H */
diff --git a/fs/nfsd/xdr.h b/fs/nfsd/xdr.h
index 53b1863dd8f6..4f0481d63804 100644
--- a/fs/nfsd/xdr.h
+++ b/fs/nfsd/xdr.h
@@ -167,7 +167,7 @@ int nfssvc_encode_entry(void *, const char *name,
 int nfssvc_release_fhandle(struct svc_rqst *, __be32 *, struct nfsd_fhandle *);
 
 /* Helper functions for NFSv2 ACL code */
-__be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp);
+__be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, struct kstat *stat);
 __be32 *nfs2svc_decode_fh(__be32 *p, struct svc_fh *fhp);
 
 #endif /* LINUX_NFSD_H */
diff --git a/fs/nfsd/xdr3.h b/fs/nfsd/xdr3.h
index 7df980eb0562..b6d5542a4ac8 100644
--- a/fs/nfsd/xdr3.h
+++ b/fs/nfsd/xdr3.h
@@ -136,6 +136,7 @@ struct nfsd3_accessres {
         __be32                  status;
         struct svc_fh           fh;
         __u32                   access;
+        struct kstat            stat;
 };
 
 struct nfsd3_readlinkres {
@@ -225,6 +226,7 @@ struct nfsd3_getaclres {
         int                     mask;
         struct posix_acl        *acl_access;
         struct posix_acl        *acl_default;
+        struct kstat            stat;
 };
 
 /* dummy type for release */
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index df1a7fb238d1..f30b017740a7 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -259,7 +259,7 @@ static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
 static int nilfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         loff_t pos = filp->f_pos;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         unsigned int offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index bec4af6eab13..08fdb77852ac 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -67,7 +67,7 @@ int nilfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 static int nilfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct page *page = vmf->page;
-        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct nilfs_transaction_info ti;
         int ret = 0;
 
diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
index f3859354e41a..b44bdb291b84 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -796,7 +796,7 @@ static int nilfs_ioctl_get_info(struct inode *inode, struct file *filp,
 
 long nilfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         void __user *argp = (void __user *)arg;
 
         switch (cmd) {
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 1d0c0b84c5a3..9de78f08989e 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -517,11 +517,11 @@ static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
 
         if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
                 *lenp = NILFS_FID_SIZE_CONNECTABLE;
-                return 255;
+                return FILEID_INVALID;
         }
         if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
                 *lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
-                return 255;
+                return FILEID_INVALID;
         }
 
         fid->cno = root->cno;
diff --git a/fs/notify/dnotify/dnotify.c b/fs/notify/dnotify/dnotify.c
index 08b886f119ce..2bfe6dc413a0 100644
--- a/fs/notify/dnotify/dnotify.c
+++ b/fs/notify/dnotify/dnotify.c
@@ -174,7 +174,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
         struct dnotify_struct **prev;
         struct inode *inode;
 
-        inode = filp->f_path.dentry->d_inode;
+        inode = file_inode(filp);
         if (!S_ISDIR(inode->i_mode))
                 return;
 
@@ -296,7 +296,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
         }
 
         /* dnotify only works on directories */
-        inode = filp->f_path.dentry->d_inode;
+        inode = file_inode(filp);
         if (!S_ISDIR(inode->i_mode)) {
                 error = -ENOTDIR;
                 goto out_err;
diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 9ff4a5ee6e20..5d8444268a16 100644
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -466,7 +466,7 @@ static int fanotify_find_path(int dfd, const char __user *filename,
 
                 ret = -ENOTDIR;
                 if ((flags & FAN_MARK_ONLYDIR) &&
-                    !(S_ISDIR(f.file->f_path.dentry->d_inode->i_mode))) {
+                    !(S_ISDIR(file_inode(f.file)->i_mode))) {
                         fdput(f);
                         goto out;
                 }
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 99e36107ff60..aa411c3f20e9 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1101,7 +1101,7 @@ static int ntfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         s64 ia_pos, ia_start, prev_ia_pos, bmp_pos;
         loff_t fpos, i_size;
-        struct inode *bmp_vi, *vdir = filp->f_path.dentry->d_inode;
+        struct inode *bmp_vi, *vdir = file_inode(filp);
         struct super_block *sb = vdir->i_sb;
         ntfs_inode *ndir = NTFS_I(vdir);
         ntfs_volume *vol = NTFS_SB(sb);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 9796330d8f04..20dfec72e903 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -569,7 +569,7 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
                              int ret,
                              bool is_async)
 {
-        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(iocb->ki_filp);
         int level;
         wait_queue_head_t *wq = ocfs2_ioend_wq(inode);
 
@@ -593,9 +593,9 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
         level = ocfs2_iocb_rw_locked_level(iocb);
         ocfs2_rw_unlock(inode, level);
 
+        inode_dio_done(inode);
         if (is_async)
                 aio_complete(iocb, ret, 0);
-        inode_dio_done(inode);
 }
 
 /*
@@ -626,7 +626,7 @@ static ssize_t ocfs2_direct_IO(int rw,
                                unsigned long nr_segs)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
+        struct inode *inode = file_inode(file)->i_mapping->host;
 
         /*
          * Fallback to buffered I/O if we see an inode without
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index fc121350d8cb..f1e1aed8f638 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -2014,12 +2014,12 @@ int ocfs2_dir_foreach(struct inode *inode, loff_t *f_pos, void *priv,
 int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
         int error = 0;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int lock_level = 0;
 
         trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode)->ip_blkno);
 
-        error = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
+        error = ocfs2_inode_lock_atime(inode, filp->f_path.mnt, &lock_level);
         if (lock_level && error >= 0) {
                 /* We release EX lock which used to update atime
                  * and get PR lock again to reduce contention
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index 005261c333b0..33ecbe0e6734 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -2020,7 +2020,7 @@ int dlm_dispatch_assert_master(struct dlm_ctxt *dlm,
                                int ignore_higher, u8 request_from, u32 flags)
 {
         struct dlm_work_item *item;
-        item = kzalloc(sizeof(*item), GFP_NOFS);
+        item = kzalloc(sizeof(*item), GFP_ATOMIC);
         if (!item)
                 return -ENOMEM;
 
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index 16b712d260d4..4c5fc8d77dc2 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -224,7 +224,7 @@ static int dlmfs_file_setattr(struct dentry *dentry, struct iattr *attr)
 static unsigned int dlmfs_file_poll(struct file *file, poll_table *wait)
 {
         int event = 0;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct dlmfs_inode_private *ip = DLMFS_I(inode);
 
         poll_wait(file, &ip->ip_lockres.l_event, wait);
@@ -245,7 +245,7 @@ static ssize_t dlmfs_file_read(struct file *filp,
         int bytes_left;
         ssize_t readlen, got;
         char *lvb_buf;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
                 inode->i_ino, count, *ppos);
@@ -293,7 +293,7 @@ static ssize_t dlmfs_file_write(struct file *filp,
         int bytes_left;
         ssize_t writelen;
         char *lvb_buf;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
                 inode->i_ino, count, *ppos);
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index 322216a5f0dd..29651167190d 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -195,11 +195,11 @@ static int ocfs2_encode_fh(struct inode *inode, u32 *fh_in, int *max_len,
 
         if (parent && (len < 6)) {
                 *max_len = 6;
-                type = 255;
+                type = FILEID_INVALID;
                 goto bail;
         } else if (len < 3) {
                 *max_len = 3;
-                type = 255;
+                type = FILEID_INVALID;
                 goto bail;
         }
 
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 0a2924a2d9e6..6474cb44004d 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1950,7 +1950,7 @@ out:
 int ocfs2_change_file_space(struct file *file, unsigned int cmd,
                             struct ocfs2_space_resv *sr)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
         int ret;
 
@@ -1978,7 +1978,7 @@ int ocfs2_change_file_space(struct file *file, unsigned int cmd,
 static long ocfs2_fallocate(struct file *file, int mode, loff_t offset,
                             loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
         struct ocfs2_space_resv sr;
         int change_size = 1;
@@ -2233,7 +2233,7 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
         loff_t old_size, *ppos = &iocb->ki_pos;
         u32 old_clusters;
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
         int full_coherency = !(osb->s_mount_opt &
                                OCFS2_MOUNT_COHERENCY_BUFFERED);
@@ -2517,7 +2517,7 @@ static ssize_t ocfs2_file_splice_read(struct file *in,
                                       unsigned int flags)
 {
         int ret = 0, lock_level = 0;
-        struct inode *inode = in->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(in);
 
         trace_ocfs2_file_splice_read(inode, in, in->f_path.dentry,
                         (unsigned long long)OCFS2_I(inode)->ip_blkno,
@@ -2527,7 +2527,7 @@ static ssize_t ocfs2_file_splice_read(struct file *in,
         /*
          * See the comment in ocfs2_file_aio_read()
          */
-        ret = ocfs2_inode_lock_atime(inode, in->f_vfsmnt, &lock_level);
+        ret = ocfs2_inode_lock_atime(inode, in->f_path.mnt, &lock_level);
         if (ret < 0) {
                 mlog_errno(ret);
                 goto bail;
@@ -2547,7 +2547,7 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
 {
         int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
         struct file *filp = iocb->ki_filp;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         trace_ocfs2_file_aio_read(inode, filp, filp->f_path.dentry,
                         (unsigned long long)OCFS2_I(inode)->ip_blkno,
@@ -2590,7 +2590,7 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
          * like i_size. This allows the checks down below
          * generic_file_aio_read() a chance of actually working.
          */
-        ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
+        ret = ocfs2_inode_lock_atime(inode, filp->f_path.mnt, &lock_level);
         if (ret < 0) {
                 mlog_errno(ret);
                 goto bail;
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index f20edcbfe700..752f0b26221d 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -881,7 +881,7 @@ bail:
 
 long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         unsigned int flags;
         int new_clusters;
         int status;
@@ -994,7 +994,7 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
         bool preserve;
         struct reflink_arguments args;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ocfs2_info info;
         void __user *argp = (void __user *)arg;
 
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index 47a87dda54ce..10d66c75cecb 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -62,7 +62,7 @@ static int __ocfs2_page_mkwrite(struct file *file, struct buffer_head *di_bh,
                                 struct page *page)
 {
         int ret = VM_FAULT_NOPAGE;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct address_space *mapping = inode->i_mapping;
         loff_t pos = page_offset(page);
         unsigned int len = PAGE_CACHE_SIZE;
@@ -131,7 +131,7 @@ out:
 static int ocfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct page *page = vmf->page;
-        struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct buffer_head *di_bh = NULL;
         sigset_t oldset;
         int ret;
@@ -180,13 +180,13 @@ int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
 {
         int ret = 0, lock_level = 0;
 
-        ret = ocfs2_inode_lock_atime(file->f_dentry->d_inode,
-                                    file->f_vfsmnt, &lock_level);
+        ret = ocfs2_inode_lock_atime(file_inode(file),
+                                    file->f_path.mnt, &lock_level);
         if (ret < 0) {
                 mlog_errno(ret);
                 goto out;
         }
-        ocfs2_inode_unlock(file->f_dentry->d_inode, lock_level);
+        ocfs2_inode_unlock(file_inode(file), lock_level);
 out:
         vma->vm_ops = &ocfs2_file_vm_ops;
         return 0;
diff --git a/fs/ocfs2/move_extents.c b/fs/ocfs2/move_extents.c
index 6083432f667e..9f8dcadd9a50 100644
--- a/fs/ocfs2/move_extents.c
+++ b/fs/ocfs2/move_extents.c
@@ -1055,7 +1055,7 @@ int ocfs2_ioctl_move_extents(struct file *filp, void __user *argp)
 {
         int status;
 
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ocfs2_move_extents range;
         struct ocfs2_move_extents_context *context = NULL;
 
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 934a4ac3e7fc..998b17eda09d 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -2927,7 +2927,7 @@ int ocfs2_duplicate_clusters_by_page(handle_t *handle,
                                      u32 new_cluster, u32 new_len)
 {
         int ret = 0, partial;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ocfs2_caching_info *ci = INODE_CACHE(inode);
         struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
         u64 new_block = ocfs2_clusters_to_blocks(sb, new_cluster);
@@ -3020,7 +3020,7 @@ int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
                                     u32 new_cluster, u32 new_len)
 {
         int ret = 0;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct super_block *sb = inode->i_sb;
         struct ocfs2_caching_info *ci = INODE_CACHE(inode);
         int i, blocks = ocfs2_clusters_to_blocks(sb, new_len);
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c
index f1fbb4b552ad..66edce7ecfd7 100644
--- a/fs/ocfs2/symlink.c
+++ b/fs/ocfs2/symlink.c
@@ -57,7 +57,7 @@
 static int ocfs2_fast_symlink_readpage(struct file *unused, struct page *page)
 {
         struct inode *inode = page->mapping->host;
-        struct buffer_head *bh;
+        struct buffer_head *bh = NULL;
         int status = ocfs2_read_inode_block(inode, &bh);
         struct ocfs2_dinode *fe;
         const char *link;
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index fb5b3ff79dc6..acbaebcad3a8 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -330,7 +330,7 @@ int omfs_is_bad(struct omfs_sb_info *sbi, struct omfs_header *header,
 static int omfs_fill_chain(struct file *filp, void *dirent, filldir_t filldir,
                 u64 fsblock, int hindex)
 {
-        struct inode *dir = filp->f_dentry->d_inode;
+        struct inode *dir = file_inode(filp);
         struct buffer_head *bh;
         struct omfs_inode *oi;
         u64 self;
@@ -405,7 +405,7 @@ out:
 
 static int omfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *dir = filp->f_dentry->d_inode;
+        struct inode *dir = file_inode(filp);
         struct buffer_head *bh;
         loff_t offset, res;
         unsigned int hchain, hindex;
diff --git a/fs/open.c b/fs/open.c
index 9b33c0cbfacf..62f907e3bc36 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -228,7 +228,7 @@ SYSCALL_ALIAS(sys_ftruncate64, SyS_ftruncate64);
 
 int do_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         long ret;
 
         if (offset < 0 || len <= 0)
@@ -426,7 +426,7 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
         if (!f.file)
                 goto out;
 
-        inode = f.file->f_path.dentry->d_inode;
+        inode = file_inode(f.file);
 
         error = -ENOTDIR;
         if (!S_ISDIR(inode->i_mode))
@@ -689,7 +689,7 @@ static int do_dentry_open(struct file *f,
                 f->f_mode = FMODE_PATH;
 
         path_get(&f->f_path);
-        inode = f->f_path.dentry->d_inode;
+        inode = file_inode(f);
         if (f->f_mode & FMODE_WRITE) {
                 error = __get_file_write_access(inode, f->f_path.mnt);
                 if (error)
@@ -699,7 +699,6 @@ static int do_dentry_open(struct file *f,
         }
 
         f->f_mapping = inode->i_mapping;
-        f->f_pos = 0;
         file_sb_list_add(f, inode->i_sb);
 
         if (unlikely(f->f_mode & FMODE_PATH)) {
@@ -810,23 +809,22 @@ struct file *dentry_open(const struct path *path, int flags,
         /* We must always pass in a valid mount pointer. */
         BUG_ON(!path->mnt);
 
-        error = -ENFILE;
         f = get_empty_filp();
-        if (f == NULL)
-                return ERR_PTR(error);
-
-        f->f_flags = flags;
-        f->f_path = *path;
-        error = do_dentry_open(f, NULL, cred);
-        if (!error) {
-                error = open_check_o_direct(f);
-                if (error) {
-                        fput(f);
+        if (!IS_ERR(f)) {
+                f->f_flags = flags;
+                f->f_path = *path;
+                error = do_dentry_open(f, NULL, cred);
+                if (!error) {
+                        /* from now on we need fput() to dispose of f */
+                        error = open_check_o_direct(f);
+                        if (error) {
+                                fput(f);
+                                f = ERR_PTR(error);
+                        }
+                } else { 
+                        put_filp(f);
                         f = ERR_PTR(error);
                 }
-        } else { 
-                put_filp(f);
-                f = ERR_PTR(error);
         }
         return f;
 }
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 2ad080faca34..ae47fa7efb9d 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -262,7 +262,7 @@ found:
 
 static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct op_inode_info *oi = OP_I(inode);
         struct device_node *dp = oi->u.node;
         struct device_node *child;
diff --git a/fs/pipe.c b/fs/pipe.c
index bd3479db4b62..64a494cef0a0 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -361,7 +361,7 @@ pipe_read(struct kiocb *iocb, const struct iovec *_iov,
            unsigned long nr_segs, loff_t pos)
 {
         struct file *filp = iocb->ki_filp;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct pipe_inode_info *pipe;
         int do_wakeup;
         ssize_t ret;
@@ -486,7 +486,7 @@ pipe_write(struct kiocb *iocb, const struct iovec *_iov,
             unsigned long nr_segs, loff_t ppos)
 {
         struct file *filp = iocb->ki_filp;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct pipe_inode_info *pipe;
         ssize_t ret;
         int do_wakeup;
@@ -677,7 +677,7 @@ bad_pipe_w(struct file *filp, const char __user *buf, size_t count,
 
 static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct pipe_inode_info *pipe;
         int count, buf, nrbufs;
 
@@ -705,7 +705,7 @@ static unsigned int
 pipe_poll(struct file *filp, poll_table *wait)
 {
         unsigned int mask;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct pipe_inode_info *pipe = inode->i_pipe;
         int nrbufs;
 
@@ -758,7 +758,7 @@ pipe_release(struct inode *inode, int decr, int decw)
 static int
 pipe_read_fasync(int fd, struct file *filp, int on)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int retval;
 
         mutex_lock(&inode->i_mutex);
@@ -772,7 +772,7 @@ pipe_read_fasync(int fd, struct file *filp, int on)
 static int
 pipe_write_fasync(int fd, struct file *filp, int on)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int retval;
 
         mutex_lock(&inode->i_mutex);
@@ -786,7 +786,7 @@ pipe_write_fasync(int fd, struct file *filp, int on)
 static int
 pipe_rdwr_fasync(int fd, struct file *filp, int on)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct pipe_inode_info *pipe = inode->i_pipe;
         int retval;
 
@@ -1037,13 +1037,13 @@ int create_pipe_files(struct file **res, int flags)
 
         err = -ENFILE;
         f = alloc_file(&path, FMODE_WRITE, &write_pipefifo_fops);
-        if (!f)
+        if (IS_ERR(f))
                 goto err_dentry;
 
         f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
 
         res[0] = alloc_file(&path, FMODE_READ, &read_pipefifo_fops);
-        if (!res[0])
+        if (IS_ERR(res[0]))
                 goto err_file;
 
         path_get(&path);
@@ -1226,7 +1226,7 @@ int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
  */
 struct pipe_inode_info *get_pipe_info(struct file *file)
 {
-        struct inode *i = file->f_path.dentry->d_inode;
+        struct inode *i = file_inode(file);
 
         return S_ISFIFO(i->i_mode) ? i->i_pipe : NULL;
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 9b43ff77a51e..f3b133d79914 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -383,7 +383,7 @@ static int lstats_open(struct inode *inode, struct file *file)
 static ssize_t lstats_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *offs)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
 
         if (!task)
                 return -ESRCH;
@@ -602,7 +602,7 @@ static const struct inode_operations proc_def_inode_operations = {
 static ssize_t proc_info_read(struct file * file, char __user * buf,
                           size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         unsigned long page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -668,7 +668,7 @@ static const struct file_operations proc_single_file_operations = {
 
 static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
 
         if (!task)
@@ -869,7 +869,7 @@ static const struct file_operations proc_environ_operations = {
 static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
                             loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         int oom_adj = OOM_ADJUST_MIN;
         size_t len;
@@ -916,7 +916,7 @@ static ssize_t oom_adj_write(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task) {
                 err = -ESRCH;
                 goto out;
@@ -976,7 +976,7 @@ static const struct file_operations proc_oom_adj_operations = {
 static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
                                         size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         short oom_score_adj = OOM_SCORE_ADJ_MIN;
         unsigned long flags;
@@ -1019,7 +1019,7 @@ static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task) {
                 err = -ESRCH;
                 goto out;
@@ -1067,7 +1067,7 @@ static const struct file_operations proc_oom_score_adj_operations = {
 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         struct task_struct *task = get_proc_task(inode);
         ssize_t length;
         char tmpbuf[TMPBUFLEN];
@@ -1084,7 +1084,7 @@ static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
 static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
                                    size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *page, *tmp;
         ssize_t length;
         uid_t loginuid;
@@ -1142,7 +1142,7 @@ static const struct file_operations proc_loginuid_operations = {
 static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         struct task_struct *task = get_proc_task(inode);
         ssize_t length;
         char tmpbuf[TMPBUFLEN];
@@ -1165,7 +1165,7 @@ static const struct file_operations proc_sessionid_operations = {
 static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
                                       size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         char buffer[PROC_NUMBUF];
         size_t len;
         int make_it_fail;
@@ -1197,7 +1197,7 @@ static ssize_t proc_fault_inject_write(struct file * file,
         make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
         if (*end)
                 return -EINVAL;
-        task = get_proc_task(file->f_dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 return -ESRCH;
         task->make_it_fail = make_it_fail;
@@ -1237,7 +1237,7 @@ static ssize_t
 sched_write(struct file *file, const char __user *buf,
             size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
 
         p = get_proc_task(inode);
@@ -1288,7 +1288,7 @@ static ssize_t
 sched_autogroup_write(struct file *file, const char __user *buf,
             size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
         char buffer[PROC_NUMBUF];
         int nice;
@@ -1343,7 +1343,7 @@ static const struct file_operations proc_pid_sched_autogroup_operations = {
 static ssize_t comm_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *offset)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct task_struct *p;
         char buffer[TASK_COMM_LEN];
 
@@ -1711,7 +1711,7 @@ static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         if (!capable(CAP_SYS_ADMIN)) {
-                status = -EACCES;
+                status = -EPERM;
                 goto out_notask;
         }
 
@@ -1844,7 +1844,7 @@ static struct dentry *proc_map_files_lookup(struct inode *dir,
         struct dentry *result;
         struct mm_struct *mm;
 
-        result = ERR_PTR(-EACCES);
+        result = ERR_PTR(-EPERM);
         if (!capable(CAP_SYS_ADMIN))
                 goto out;
 
@@ -1900,7 +1900,7 @@ proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
         ino_t ino;
         int ret;
 
-        ret = -EACCES;
+        ret = -EPERM;
         if (!capable(CAP_SYS_ADMIN))
                 goto out;
 
@@ -2146,7 +2146,7 @@ out_no_task:
 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *p = NULL;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -2167,7 +2167,7 @@ static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
 static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
                                    size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char *page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -2256,7 +2256,7 @@ static const struct inode_operations proc_attr_dir_inode_operations = {
 static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
                                          size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
         char buffer[PROC_NUMBUF];
         size_t len;
@@ -2308,7 +2308,7 @@ static ssize_t proc_coredump_filter_write(struct file *file,
                 goto out_no_task;
 
         ret = -ESRCH;
-        task = get_proc_task(file->f_dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 goto out_no_task;
 
@@ -2618,6 +2618,7 @@ static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
 
         name.name = buf;
         name.len = snprintf(buf, sizeof(buf), "%d", pid);
+        /* no ->d_hash() rejects on procfs */
         dentry = d_hash_and_lookup(mnt->mnt_root, &name);
         if (dentry) {
                 shrink_dcache_parent(dentry);
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 76ddae83daa5..2983dc52ca25 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -42,7 +42,7 @@ static ssize_t
 __proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                loff_t *ppos)
 {
-        struct inode * inode = file->f_path.dentry->d_inode;
+        struct inode * inode = file_inode(file);
         char    *page;
         ssize_t retval=0;
         int     eof=0;
@@ -188,7 +188,7 @@ static ssize_t
 proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
 
         spin_lock(&pde->pde_unload_lock);
@@ -209,7 +209,7 @@ static ssize_t
 proc_file_write(struct file *file, const char __user *buffer,
                 size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
 
         if (pde->write_proc) {
@@ -412,8 +412,7 @@ static const struct dentry_operations proc_dentry_operations =
 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
                 struct dentry *dentry)
 {
-        struct inode *inode = NULL;
-        int error = -ENOENT;
+        struct inode *inode;
 
         spin_lock(&proc_subdir_lock);
         for (de = de->subdir; de ; de = de->next) {
@@ -422,22 +421,16 @@ struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
                 if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                         pde_get(de);
                         spin_unlock(&proc_subdir_lock);
-                        error = -ENOMEM;
                         inode = proc_get_inode(dir->i_sb, de);
-                        goto out_unlock;
+                        if (!inode)
+                                return ERR_PTR(-ENOMEM);
+                        d_set_d_op(dentry, &proc_dentry_operations);
+                        d_add(dentry, inode);
+                        return NULL;
                 }
         }
         spin_unlock(&proc_subdir_lock);
-out_unlock:
-
-        if (inode) {
-                d_set_d_op(dentry, &proc_dentry_operations);
-                d_add(dentry, inode);
-                return NULL;
-        }
-        if (de)
-                pde_put(de);
-        return ERR_PTR(error);
+        return ERR_PTR(-ENOENT);
 }
 
 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
@@ -460,7 +453,7 @@ int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
 {
         unsigned int ino;
         int i;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int ret = 0;
 
         ino = inode->i_ino;
@@ -522,7 +515,7 @@ out:
 
 int proc_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
 
         return proc_readdir_de(PDE(inode), filp, dirent, filldir);
 }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 439ae6886507..70322e1a4f0f 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -144,7 +144,7 @@ void pde_users_dec(struct proc_dir_entry *pde)
 
 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         loff_t rv = -EINVAL;
         loff_t (*llseek)(struct file *, loff_t, int);
 
@@ -179,7 +179,7 @@ static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
 
 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
         ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
 
@@ -201,7 +201,7 @@ static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count,
 
 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         ssize_t rv = -EIO;
         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
 
@@ -223,7 +223,7 @@ static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t
 
 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         unsigned int rv = DEFAULT_POLLMASK;
         unsigned int (*poll)(struct file *, struct poll_table_struct *);
 
@@ -245,7 +245,7 @@ static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *p
 
 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         long rv = -ENOTTY;
         long (*ioctl)(struct file *, unsigned int, unsigned long);
 
@@ -268,7 +268,7 @@ static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigne
 #ifdef CONFIG_COMPAT
 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         long rv = -ENOTTY;
         long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
 
@@ -291,7 +291,7 @@ static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned
 
 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(file_inode(file));
         int rv = -EIO;
         int (*mmap)(struct file *, struct vm_area_struct *);
 
@@ -445,12 +445,9 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
 
 struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
 {
-        struct inode * inode;
+        struct inode *inode = iget_locked(sb, de->low_ino);
 
-        inode = iget_locked(sb, de->low_ino);
-        if (!inode)
-                return NULL;
-        if (inode->i_state & I_NEW) {
+        if (inode && (inode->i_state & I_NEW)) {
                 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
                 PROC_I(inode)->pde = de;
 
@@ -482,10 +479,12 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
         } else
                pde_put(de);
         return inode;
-}                       
+}
 
 int proc_fill_super(struct super_block *s)
 {
+        struct inode *root_inode;
+
         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
         s->s_blocksize = 1024;
         s->s_blocksize_bits = 10;
@@ -494,11 +493,17 @@ int proc_fill_super(struct super_block *s)
         s->s_time_gran = 1;
         
         pde_get(&proc_root);
-        s->s_root = d_make_root(proc_get_inode(s, &proc_root));
-        if (s->s_root)
-                return 0;
+        root_inode = proc_get_inode(s, &proc_root);
+        if (!root_inode) {
+                printk(KERN_ERR "proc_fill_super: get root inode failed\n");
+                return -ENOMEM;
+        }
 
-        printk("proc_read_super: get root inode failed\n");
-        pde_put(&proc_root);
-        return -ENOMEM;
+        s->s_root = d_make_root(root_inode);
+        if (!s->s_root) {
+                printk(KERN_ERR "proc_fill_super: allocate dentry failed\n");
+                return -ENOMEM;
+        }
+
+        return 0;
 }
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index b1822dde55c2..ccfd99bd1c5a 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -45,7 +45,7 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
         file = region->vm_file;
 
         if (file) {
-                struct inode *inode = region->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(region->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
         }
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 3131a03d7d37..b4ac6572474f 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -163,7 +163,7 @@ static int proc_tgid_net_readdir(struct file *filp, void *dirent,
         struct net *net;
 
         ret = -EINVAL;
-        net = get_proc_task_net(filp->f_path.dentry->d_inode);
+        net = get_proc_task_net(file_inode(filp));
         if (net != NULL) {
                 ret = proc_readdir_de(net->proc_net, filp, dirent, filldir);
                 put_net(net);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 1827d88ad58b..612df79cc6a1 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -478,7 +478,7 @@ out:
 static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
                 size_t count, loff_t *ppos, int write)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ctl_table_header *head = grab_header(inode);
         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
         ssize_t error;
@@ -542,7 +542,7 @@ static int proc_sys_open(struct inode *inode, struct file *filp)
 
 static unsigned int proc_sys_poll(struct file *filp, poll_table *wait)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct ctl_table_header *head = grab_header(inode);
         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
         unsigned int ret = DEFAULT_POLLMASK;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index ca5ce7f9f800..3e636d864d56 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -271,7 +271,7 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma, int is_pid)
         const char *name = NULL;
 
         if (file) {
-                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
                 pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT;
@@ -743,7 +743,7 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                 return rv;
         if (type < CLEAR_REFS_ALL || type > CLEAR_REFS_MAPPED)
                 return -EINVAL;
-        task = get_proc_task(file->f_path.dentry->d_inode);
+        task = get_proc_task(file_inode(file));
         if (!task)
                 return -ESRCH;
         mm = get_task_mm(task);
@@ -1015,7 +1015,7 @@ static int pagemap_hugetlb_range(pte_t *pte, unsigned long hmask,
 static ssize_t pagemap_read(struct file *file, char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+        struct task_struct *task = get_proc_task(file_inode(file));
         struct mm_struct *mm;
         struct pagemapread pm;
         int ret = -ESRCH;
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 1ccfa537f5f5..56123a6f462e 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -149,7 +149,7 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
         file = vma->vm_file;
 
         if (file) {
-                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
                 pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
diff --git a/fs/qnx4/dir.c b/fs/qnx4/dir.c
index 7b0329468a5d..28ce014b3cef 100644
--- a/fs/qnx4/dir.c
+++ b/fs/qnx4/dir.c
@@ -16,7 +16,7 @@
 
 static int qnx4_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         unsigned int offset;
         struct buffer_head *bh;
         struct qnx4_inode_entry *de;
diff --git a/fs/qnx6/dir.c b/fs/qnx6/dir.c
index dc597353db3b..8798d065e400 100644
--- a/fs/qnx6/dir.c
+++ b/fs/qnx6/dir.c
@@ -117,7 +117,7 @@ static int qnx6_dir_longfilename(struct inode *inode,
 
 static int qnx6_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *s = inode->i_sb;
         struct qnx6_sb_info *sbi = QNX6_SB(s);
         loff_t pos = filp->f_pos & (QNX6_DIR_ENTRY_SIZE - 1);
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index d5378d028589..8d5b438cc188 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -202,7 +202,7 @@ unsigned long ramfs_nommu_get_unmapped_area(struct file *file,
                                             unsigned long pgoff, unsigned long flags)
 {
         unsigned long maxpages, lpages, nr, loop, ret;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct page **pages = NULL, **ptr, *page;
         loff_t isize;
 
diff --git a/fs/read_write.c b/fs/read_write.c
index bb34af315280..3ae6dbe828bf 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -163,7 +163,7 @@ EXPORT_SYMBOL(no_llseek);
 
 loff_t default_llseek(struct file *file, loff_t offset, int whence)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         loff_t retval;
 
         mutex_lock(&inode->i_mutex);
@@ -290,7 +290,7 @@ int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count
         loff_t pos;
         int retval = -EINVAL;
 
-        inode = file->f_path.dentry->d_inode;
+        inode = file_inode(file);
         if (unlikely((ssize_t) count < 0))
                 return retval;
         pos = *ppos;
@@ -901,8 +901,8 @@ ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos, size_t count,
         if (!(out.file->f_mode & FMODE_WRITE))
                 goto fput_out;
         retval = -EINVAL;
-        in_inode = in.file->f_path.dentry->d_inode;
-        out_inode = out.file->f_path.dentry->d_inode;
+        in_inode = file_inode(in.file);
+        out_inode = file_inode(out.file);
         retval = rw_verify_area(WRITE, out.file, &out.file->f_pos, count);
         if (retval < 0)
                 goto fput_out;
diff --git a/fs/readdir.c b/fs/readdir.c
index 5e69ef533b77..fee38e04fae4 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -22,7 +22,7 @@
 
 int vfs_readdir(struct file *file, filldir_t filler, void *buf)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         int res = -ENOTDIR;
         if (!file->f_op || !file->f_op->readdir)
                 goto out;
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 50302d6f8895..6165bd4784f6 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -268,7 +268,7 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                                                          * new current position before returning. */
                                    )
 {
-        struct inode *inode = file->f_path.dentry->d_inode;     // Inode of the file that we are writing to.
+        struct inode *inode = file_inode(file); // Inode of the file that we are writing to.
         /* To simplify coding at this time, we store
            locked pages in array for now */
         struct reiserfs_transaction_handle th;
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 95d7680ead47..ea5061fd4f3e 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -1603,10 +1603,10 @@ int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,
 
         if (parent && (maxlen < 5)) {
                 *lenp = 5;
-                return 255;
+                return FILEID_INVALID;
         } else if (maxlen < 3) {
                 *lenp = 3;
-                return 255;
+                return FILEID_INVALID;
         }
 
         data[0] = inode->i_ino;
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index 0c2185042d5f..15cb5fe6b425 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -21,7 +21,7 @@
  */
 long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         unsigned int flags;
         int err = 0;
 
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index e60e87035bb3..9cc0740adffa 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -281,7 +281,7 @@ static int show_oidmap(struct seq_file *m, struct super_block *sb)
         }
 #if defined( REISERFS_USE_OIDMAPF )
         if (sb_info->oidmap.use_file && (sb_info->oidmap.mapf != NULL)) {
-                loff_t size = sb_info->oidmap.mapf->f_path.dentry->d_inode->i_size;
+                loff_t size = file_inode(sb_info->oidmap.mapf)->i_size;
                 total_used += size / sizeof(reiserfs_oidinterval_d_t);
         }
 #endif
diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index fd7c5f60b46b..7e8d3a80bdab 100644
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -147,7 +147,7 @@ static const struct address_space_operations romfs_aops = {
  */
 static int romfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *i = filp->f_dentry->d_inode;
+        struct inode *i = file_inode(filp);
         struct romfs_inode ri;
         unsigned long offset, maxoff;
         int j, ino, nextfh;
diff --git a/fs/splice.c b/fs/splice.c
index 6909d89d0da5..718bd0056384 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -569,7 +569,7 @@ static ssize_t kernel_readv(struct file *file, const struct iovec *vec,
         return res;
 }
 
-static ssize_t kernel_write(struct file *file, const char *buf, size_t count,
+ssize_t kernel_write(struct file *file, const char *buf, size_t count,
                             loff_t pos)
 {
         mm_segment_t old_fs;
@@ -578,11 +578,12 @@ static ssize_t kernel_write(struct file *file, const char *buf, size_t count,
         old_fs = get_fs();
         set_fs(get_ds());
         /* The cast to a user pointer is valid due to the set_fs() */
-        res = vfs_write(file, (const char __user *)buf, count, &pos);
+        res = vfs_write(file, (__force const char __user *)buf, count, &pos);
         set_fs(old_fs);
 
         return res;
 }
+EXPORT_SYMBOL(kernel_write);
 
 ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
                                  struct pipe_inode_info *pipe, size_t len,
@@ -1170,7 +1171,7 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
          * randomly drop data for eg socket -> socket splicing. Use the
          * piped splicing for that!
          */
-        i_mode = in->f_path.dentry->d_inode->i_mode;
+        i_mode = file_inode(in)->i_mode;
         if (unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))
                 return -EINVAL;
 
diff --git a/fs/squashfs/dir.c b/fs/squashfs/dir.c
index b381305c9a47..57dc70ebbb19 100644
--- a/fs/squashfs/dir.c
+++ b/fs/squashfs/dir.c
@@ -102,7 +102,7 @@ static int get_dir_index_using_offset(struct super_block *sb,
 
 static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
         u64 block = squashfs_i(inode)->start + msblk->directory_table;
         int offset = squashfs_i(inode)->offset, length, dir_count, size,
diff --git a/fs/stat.c b/fs/stat.c
index 14f45459c83d..04ce1ac20d20 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -37,17 +37,17 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
 
 EXPORT_SYMBOL(generic_fillattr);
 
-int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+int vfs_getattr(struct path *path, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = path->dentry->d_inode;
         int retval;
 
-        retval = security_inode_getattr(mnt, dentry);
+        retval = security_inode_getattr(path->mnt, path->dentry);
         if (retval)
                 return retval;
 
         if (inode->i_op->getattr)
-                return inode->i_op->getattr(mnt, dentry, stat);
+                return inode->i_op->getattr(path->mnt, path->dentry, stat);
 
         generic_fillattr(inode, stat);
         return 0;
@@ -61,8 +61,7 @@ int vfs_fstat(unsigned int fd, struct kstat *stat)
         int error = -EBADF;
 
         if (f.file) {
-                error = vfs_getattr(f.file->f_path.mnt, f.file->f_path.dentry,
-                                    stat);
+                error = vfs_getattr(&f.file->f_path, stat);
                 fdput(f);
         }
         return error;
@@ -89,7 +88,7 @@ retry:
         if (error)
                 goto out;
 
-        error = vfs_getattr(path.mnt, path.dentry, stat);
+        error = vfs_getattr(&path, stat);
         path_put(&path);
         if (retry_estale(error, lookup_flags)) {
                 lookup_flags |= LOOKUP_REVAL;
diff --git a/fs/sync.c b/fs/sync.c
index 14eefeb44636..2c5d6639a66a 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -332,7 +332,7 @@ SYSCALL_DEFINE(sync_file_range)(int fd, loff_t offset, loff_t nbytes,
         if (!f.file)
                 goto out;
 
-        i_mode = f.file->f_path.dentry->d_inode->i_mode;
+        i_mode = file_inode(f.file)->i_mode;
         ret = -ESPIPE;
         if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) &&
                         !S_ISLNK(i_mode))
diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index 614b2b544880..2ce9a5db6ab5 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -70,7 +70,7 @@ static ssize_t
 read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
 {
         struct bin_buffer *bb = file->private_data;
-        int size = file->f_path.dentry->d_inode->i_size;
+        int size = file_inode(file)->i_size;
         loff_t offs = *off;
         int count = min_t(size_t, bytes, PAGE_SIZE);
         char *temp;
@@ -140,7 +140,7 @@ static ssize_t write(struct file *file, const char __user *userbuf,
                      size_t bytes, loff_t *off)
 {
         struct bin_buffer *bb = file->private_data;
-        int size = file->f_path.dentry->d_inode->i_size;
+        int size = file_inode(file)->i_size;
         loff_t offs = *off;
         int count = min_t(size_t, bytes, PAGE_SIZE);
         char *temp;
@@ -469,7 +469,7 @@ void unmap_bin_file(struct sysfs_dirent *attr_sd)
         mutex_lock(&sysfs_bin_lock);
 
         hlist_for_each_entry(bb, tmp, &attr_sd->s_bin_attr.buffers, list) {
-                struct inode *inode = bb->file->f_path.dentry->d_inode;
+                struct inode *inode = file_inode(bb->file);
 
                 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
         }
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index a77c42157620..3799e8dac3eb 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -68,7 +68,7 @@ static struct page * dir_get_page(struct inode *dir, unsigned long n)
 static int sysv_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
         unsigned long pos = filp->f_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         unsigned offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 8a574776a493..de08c92f2e23 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -352,7 +352,7 @@ static int ubifs_readdir(struct file *file, void *dirent, filldir_t filldir)
         struct qstr nm;
         union ubifs_key key;
         struct ubifs_dent_node *dent;
-        struct inode *dir = file->f_path.dentry->d_inode;
+        struct inode *dir = file_inode(file);
         struct ubifs_info *c = dir->i_sb->s_fs_info;
 
         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 4f6493c130e0..f12189d2db1d 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1444,7 +1444,7 @@ static int ubifs_vm_page_mkwrite(struct vm_area_struct *vma,
                                  struct vm_fault *vmf)
 {
         struct page *page = vmf->page;
-        struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct ubifs_info *c = inode->i_sb->s_fs_info;
         struct timespec now = ubifs_current_time(inode);
         struct ubifs_budget_req req = { .new_page = 1 };
diff --git a/fs/ubifs/ioctl.c b/fs/ubifs/ioctl.c
index 1a7e2d8bdbe9..648b143606cc 100644
--- a/fs/ubifs/ioctl.c
+++ b/fs/ubifs/ioctl.c
@@ -147,7 +147,7 @@ out_unlock:
 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int flags, err;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         switch (cmd) {
         case FS_IOC_GETFLAGS:
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index eb8bfe2b89a5..b3e93f5e17c3 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -186,7 +186,7 @@ out:
 
 static int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *dir = filp->f_path.dentry->d_inode;
+        struct inode *dir = file_inode(filp);
         int result;
 
         if (filp->f_pos == 0) {
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 77b5953eaac8..29569dd08168 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -139,7 +139,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 {
         ssize_t retval;
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         int err, pos;
         size_t count = iocb->ki_left;
         struct udf_inode_info *iinfo = UDF_I(inode);
@@ -178,7 +178,7 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 
 long udf_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         long old_block, new_block;
         int result = -EINVAL;
 
@@ -204,7 +204,7 @@ long udf_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 goto out;
         case UDF_RELOCATE_BLOCKS:
                 if (!capable(CAP_SYS_ADMIN)) {
-                        result = -EACCES;
+                        result = -EPERM;
                         goto out;
                 }
                 if (get_user(old_block, (long __user *)arg)) {
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 95fee278ab9d..102c072c6bbf 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -1270,10 +1270,10 @@ static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
 
         if (parent && (len < 5)) {
                 *lenp = 5;
-                return 255;
+                return FILEID_INVALID;
         } else if (len < 3) {
                 *lenp = 3;
-                return 255;
+                return FILEID_INVALID;
         }
 
         *lenp = 3;
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index dbc90994715a..3a75ca09c506 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -433,7 +433,7 @@ static int
 ufs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         loff_t pos = filp->f_pos;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         struct super_block *sb = inode->i_sb;
         unsigned int offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index a8bd26b82ecb..f852b082a084 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -78,14 +78,14 @@ xfs_swapext(
                 goto out_put_tmp_file;
         }
 
-        if (IS_SWAPFILE(f.file->f_path.dentry->d_inode) ||
-            IS_SWAPFILE(tmp.file->f_path.dentry->d_inode)) {
+        if (IS_SWAPFILE(file_inode(f.file)) ||
+            IS_SWAPFILE(file_inode(tmp.file))) {
                 error = XFS_ERROR(EINVAL);
                 goto out_put_tmp_file;
         }
 
-        ip = XFS_I(f.file->f_path.dentry->d_inode);
-        tip = XFS_I(tmp.file->f_path.dentry->d_inode);
+        ip = XFS_I(file_inode(f.file));
+        tip = XFS_I(file_inode(tmp.file));
 
         if (ip->i_mount != tip->i_mount) {
                 error = XFS_ERROR(EINVAL);
diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
index a83611849cee..c585bc646395 100644
--- a/fs/xfs/xfs_export.c
+++ b/fs/xfs/xfs_export.c
@@ -48,7 +48,7 @@ static int xfs_fileid_length(int fileid_type)
         case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
                 return 6;
         }
-        return 255; /* invalid */
+        return FILEID_INVALID;
 }
 
 STATIC int
@@ -90,7 +90,7 @@ xfs_fs_encode_fh(
         len = xfs_fileid_length(fileid_type);
         if (*max_len < len) {
                 *max_len = len;
-                return 255;
+                return FILEID_INVALID;
         }
         *max_len = len;
 
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 67284edb84d7..f03bf1a456fb 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -811,7 +811,7 @@ xfs_file_fallocate(
         loff_t          offset,
         loff_t          len)
 {
-        struct inode    *inode = file->f_path.dentry->d_inode;
+        struct inode    *inode = file_inode(file);
         long            error;
         loff_t          new_size = 0;
         xfs_flock64_t   bf;
@@ -912,7 +912,7 @@ xfs_file_readdir(
         void            *dirent,
         filldir_t       filldir)
 {
-        struct inode    *inode = filp->f_path.dentry->d_inode;
+        struct inode    *inode = file_inode(filp);
         xfs_inode_t     *ip = XFS_I(inode);
         int             error;
         size_t          bufsize;
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index c1c3ef88a260..d681e34c2950 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -80,7 +80,7 @@ xfs_find_handle(
                 f = fdget(hreq->fd);
                 if (!f.file)
                         return -EBADF;
-                inode = f.file->f_path.dentry->d_inode;
+                inode = file_inode(f.file);
         } else {
                 error = user_lpath((const char __user *)hreq->path, &path);
                 if (error)
@@ -168,7 +168,7 @@ xfs_handle_to_dentry(
         /*
          * Only allow handle opens under a directory.
          */
-        if (!S_ISDIR(parfilp->f_path.dentry->d_inode->i_mode))
+        if (!S_ISDIR(file_inode(parfilp)->i_mode))
                 return ERR_PTR(-ENOTDIR);
 
         if (hlen != sizeof(xfs_handle_t))
@@ -1334,7 +1334,7 @@ xfs_file_ioctl(
         unsigned int            cmd,
         unsigned long           p)
 {
-        struct inode            *inode = filp->f_path.dentry->d_inode;
+        struct inode            *inode = file_inode(filp);
         struct xfs_inode        *ip = XFS_I(inode);
         struct xfs_mount        *mp = ip->i_mount;
         void                    __user *arg = (void __user *)p;
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index 1244274a5674..63b8fc432151 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -530,7 +530,7 @@ xfs_file_compat_ioctl(
         unsigned                cmd,
         unsigned long           p)
 {
-        struct inode            *inode = filp->f_path.dentry->d_inode;
+        struct inode            *inode = file_inode(filp);
         struct xfs_inode        *ip = XFS_I(inode);
         struct xfs_mount        *mp = ip->i_mount;
         void                    __user *arg = (void __user *)p;