new helper: file_inode(file)

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

158 files changed, 373 insertions, 375 deletions

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index c2483e97beee..3356e3ed5115 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -133,7 +133,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);
 
@@ -302,7 +302,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",
@@ -338,7 +338,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",
@@ -529,7 +529,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 */
@@ -604,7 +604,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/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/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..3cdf835e8b49 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -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 0c42cdbabecf..11e078a747a5 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1140,7 +1140,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 dc84732e554f..30de01ca3eeb 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 172f8491a2bd..7d6bdfc6b7bc 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/file.c b/fs/btrfs/file.c
index 77061bf43edb..4118e0b6e339 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1211,7 +1211,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;
@@ -1298,7 +1298,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;
@@ -1486,7 +1486,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;
@@ -2087,7 +2087,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 16d9e8e191e6..02d946a61ddd 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4342,7 +4342,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;
@@ -6737,7 +6737,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 4b4516770f05..61045adc3075 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);
 }
@@ -1317,7 +1317,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;
@@ -1483,8 +1483,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;
@@ -1576,7 +1576,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;
@@ -1598,7 +1598,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;
@@ -1892,7 +1892,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;
@@ -2002,7 +2002,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;
@@ -2178,7 +2178,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;
@@ -2237,7 +2237,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;
@@ -2285,7 +2285,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;
 
@@ -2408,7 +2408,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;
@@ -2454,7 +2454,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)
@@ -2816,7 +2816,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;
@@ -2856,7 +2856,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;
@@ -3080,7 +3080,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;
 
@@ -3142,7 +3142,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;
 
@@ -3433,7 +3433,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;
@@ -3573,7 +3573,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;
@@ -3632,7 +3632,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;
@@ -3679,7 +3679,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;
@@ -3725,7 +3725,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;
@@ -3775,7 +3775,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;
@@ -3855,7 +3855,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 54454542ad40..f80df6b04648 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -4542,7 +4542,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 7a75c3e0fd58..b8a8b4d64d8c 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/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/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 de7f9168a118..8b35365c70be 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -677,7 +677,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;
 
@@ -701,7 +701,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
@@ -733,7 +733,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 8ea6ca50a665..1a5c2911b043 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 ed6208ff85a7..1fc864b92cf2 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -289,7 +289,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);
@@ -558,7 +558,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);
@@ -1678,7 +1678,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))
@@ -1735,7 +1735,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..7255b0c7aa7e 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -505,7 +505,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 +778,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 be2aa4909487..6df708c7b3e8 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -129,7 +129,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 712b10f64c70..90d222f11e36 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -1625,7 +1625,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/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/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..7b6f4d59b26c 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;
@@ -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 890b8947c546..61fa09eb2501 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -624,7 +624,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)
@@ -638,7 +638,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 80a28b297279..dc149d123de5 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;
@@ -494,7 +494,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;
 
@@ -526,7 +526,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 5ae1674ec12f..7817ca7c2bbf 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4386,7 +4386,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;
@@ -4643,7 +4643,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 405565a62277..c00ea7945eb5 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 387c47c6cda9..8106dca95456 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 cbfe13bf5b2a..521bd4ab8abe 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2959,7 +2959,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 */
@@ -3553,7 +3553,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;
 
@@ -4926,7 +4926,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 5747f52f7c72..c2f8e060f636 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 d9cc5ee42f53..796f7ac03706 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 f9ed946a448e..bb97ad6905b2 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -937,7 +937,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 3d4fb81bacd5..4df78dd3f523 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -553,7 +553,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 951ed52748f6..fda0bcc0907f 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -603,7 +603,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..0f607ce89acc 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -447,7 +447,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 b7c09f9eb40c..80ba3950c40d 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1160,7 +1160,7 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
         int 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;
 
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 991ab2d484dd..44543df9f400 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 b7eff078fe90..04af1cf7ae34 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/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..ba6de25771ac 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)
 {
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..edb42ea60c76 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);
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/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 54f9e6ce0430..d7e1ec1c6827 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..df00b754631d 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2778,7 +2778,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);
diff --git a/fs/namespace.c b/fs/namespace.c
index 269919fa116d..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);
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 1acdad7fcec7..c41e02932542 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -525,7 +525,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);
@@ -564,7 +564,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 6958adfaff08..5c1e9262219c 100644
--- a/fs/ncpfs/ioctl.c
+++ b/fs/ncpfs/ioctl.c
@@ -808,7 +808,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);
         uid_t uid = current_uid();
         int need_drop_write = 0;
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..a8bd28cde7e2 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",
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 bc3968fa81e5..2ad8deaf7dbf 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -764,7 +764,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 ebeb94ce1b0b..548ae3113005 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -714,7 +714,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);
@@ -747,7 +747,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/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/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/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/vfs.c b/fs/nfsd/vfs.c
index d586117fa94a..a94245b4045f 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/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 61946883025c..89dc0886387d 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 fdb180769485..ef61c749641d 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -793,7 +793,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/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 657743254eb9..db1ad26e02a7 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);
 
@@ -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 8fe4e2892ab9..ac0d4a0e8a41 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -2015,7 +2015,7 @@ 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);
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/file.c b/fs/ocfs2/file.c
index 37d313ede159..04098af9dbc8 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1949,7 +1949,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;
 
@@ -1977,7 +1977,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;
@@ -2232,7 +2232,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);
@@ -2516,7 +2516,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,
@@ -2546,7 +2546,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,
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..07c585b85000 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,
+        ret = ocfs2_inode_lock_atime(file_inode(file),
                                     file->f_vfsmnt, &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 30a055049e16..1baffaadda41 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/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..e08643feb574 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)
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..39baf6c3ebb0 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;
 
@@ -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..760268d6cba6 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];
 
@@ -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;
 
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 76ddae83daa5..7dfe548a28e8 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) {
@@ -460,7 +460,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 +522,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..38f5c119b806 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 *);
 
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 fe72cd073dea..75df0d731110 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/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..963213d56403 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1170,7 +1170,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/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 5bc77817f382..fa5b347ec729 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..4257a1f5302a 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;
 
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 d0e9c74d3d96..75d854b0c439 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_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;