171 files changed, 967 insertions, 945 deletions

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 9dfd259a70b4..cc24abf232d5 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -54,7 +54,7 @@ static int v9fs_vfs_readpage(struct file *filp, struct page *page)
         int retval = -EIO;
         loff_t offset = page_offset(page);
         int count = PAGE_CACHE_SIZE;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
         int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
         struct v9fs_fid *v9f = filp->private_data;
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 905c882f4e2f..3129688143ea 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -71,7 +71,7 @@ static inline int dt_type(struct v9fs_stat *mistat)
 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         struct v9fs_fcall *fcall = NULL;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
         struct v9fs_fid *file = filp->private_data;
         unsigned int i, n, s;
@@ -80,7 +80,7 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
         struct v9fs_stat stat;
         int over = 0;
 
-        dprintk(DEBUG_VFS, "name %s\n", filp->f_dentry->d_name.name);
+        dprintk(DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name);
 
         fid = file->fid;
 
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 79e6f9cd7340..e86a07151280 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -60,7 +60,7 @@ int v9fs_file_open(struct inode *inode, struct file *file)
 
         dprintk(DEBUG_VFS, "inode: %p file: %p \n", inode, file);
 
-        vfid = v9fs_fid_lookup(file->f_dentry);
+        vfid = v9fs_fid_lookup(file->f_path.dentry);
         if (!vfid) {
                 dprintk(DEBUG_ERROR, "Couldn't resolve fid from dentry\n");
                 return -EBADF;
@@ -133,7 +133,7 @@ free_fcall:
 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
         int res = 0;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
 
         dprintk(DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 
@@ -161,7 +161,7 @@ static ssize_t
 v9fs_file_read(struct file *filp, char __user * data, size_t count,
                loff_t * offset)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
         struct v9fs_fid *v9f = filp->private_data;
         struct v9fs_fcall *fcall = NULL;
@@ -225,7 +225,7 @@ static ssize_t
 v9fs_file_write(struct file *filp, const char __user * data,
                 size_t count, loff_t * offset)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
         struct v9fs_fid *v9fid = filp->private_data;
         struct v9fs_fcall *fcall;
diff --git a/fs/Makefile b/fs/Makefile
index 9a5ce9323bfd..b9ffa63f77fc 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -10,7 +10,8 @@ obj-y :=	open.o read_write.o file_table.o super.o \
                 ioctl.o readdir.o select.o fifo.o locks.o dcache.o inode.o \
                 attr.o bad_inode.o file.o filesystems.o namespace.o aio.o \
                 seq_file.o xattr.o libfs.o fs-writeback.o \
-                pnode.o drop_caches.o splice.o sync.o utimes.o
+                pnode.o drop_caches.o splice.o sync.o utimes.o \
+                stack.o
 
 ifeq ($(CONFIG_BLOCK),y)
 obj-y +=        buffer.o bio.o block_dev.o direct-io.o mpage.o ioprio.o
diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index d3c7905b2ddc..2b8903893d3f 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -28,7 +28,7 @@ static DEFINE_RWLOCK(adfs_dir_lock);
 static int
 adfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         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 5d9649fa1814..cad3ee340063 100644
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -41,7 +41,7 @@ struct inode_operations affs_dir_inode_operations = {
 static int
 affs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode            *inode = filp->f_dentry->d_inode;
+        struct inode            *inode = filp->f_path.dentry->d_inode;
         struct super_block      *sb = inode->i_sb;
         struct buffer_head      *dir_bh;
         struct buffer_head      *fh_bh;
@@ -71,7 +71,7 @@ affs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 stored++;
         }
         if (f_pos == 1) {
-                if (filldir(dirent, "..", 2, f_pos, parent_ino(filp->f_dentry), DT_DIR) < 0)
+                if (filldir(dirent, "..", 2, f_pos, parent_ino(filp->f_path.dentry), DT_DIR) < 0)
                         return stored;
                 filp->f_pos = f_pos = 2;
                 stored++;
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index a6ec75c56fcf..4acd04134055 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -392,10 +392,10 @@ static int afs_dir_readdir(struct file *file, void *cookie, filldir_t filldir)
         unsigned fpos;
         int ret;
 
-        _enter("{%Ld,{%lu}}", file->f_pos, file->f_dentry->d_inode->i_ino);
+        _enter("{%Ld,{%lu}}", file->f_pos, file->f_path.dentry->d_inode->i_ino);
 
         fpos = file->f_pos;
-        ret = afs_dir_iterate(file->f_dentry->d_inode, &fpos, cookie, filldir);
+        ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos, cookie, filldir);
         file->f_pos = fpos;
 
         _leave(" = %d", ret);
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 99785a79d043..8f74e8450826 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -18,7 +18,7 @@
 #include <linux/pagemap.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include "super.h"
 #include "cell.h"
 #include "volume.h"
@@ -136,11 +136,11 @@ static int afs_mntpt_open(struct inode *inode, struct file *file)
 {
         kenter("%p,%p{%p{%s},%s}",
                inode, file,
-               file->f_dentry->d_parent,
-               file->f_dentry->d_parent ?
-               file->f_dentry->d_parent->d_name.name :
+               file->f_path.dentry->d_parent,
+               file->f_path.dentry->d_parent ?
+               file->f_path.dentry->d_parent->d_name.name :
                (const unsigned char *) "",
-               file->f_dentry->d_name.name);
+               file->f_path.dentry->d_name.name);
 
         return -EREMOTE;
 } /* end afs_mntpt_open() */
diff --git a/fs/autofs/root.c b/fs/autofs/root.c
index 368a1c33a3c8..e698c51d2b02 100644
--- a/fs/autofs/root.c
+++ b/fs/autofs/root.c
@@ -45,7 +45,7 @@ static int autofs_root_readdir(struct file *filp, void *dirent, filldir_t filldi
         struct autofs_dir_ent *ent = NULL;
         struct autofs_dirhash *dirhash;
         struct autofs_sb_info *sbi;
-        struct inode * inode = filp->f_dentry->d_inode;
+        struct inode * inode = filp->f_path.dentry->d_inode;
         off_t onr, nr;
 
         lock_kernel();
@@ -557,7 +557,7 @@ static int autofs_root_ioctl(struct inode *inode, struct file *filp,
         case AUTOFS_IOC_SETTIMEOUT:
                 return autofs_get_set_timeout(sbi, argp);
         case AUTOFS_IOC_EXPIRE:
-                return autofs_expire_run(inode->i_sb, sbi, filp->f_vfsmnt,
+                return autofs_expire_run(inode->i_sb, sbi, filp->f_path.mnt,
                                          argp);
         default:
                 return -ENOSYS;
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index b13f32c8aeee..216b1a364ccb 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -150,7 +150,8 @@ static inline int autofs4_ispending(struct dentry *dentry)
 
 static inline void autofs4_copy_atime(struct file *src, struct file *dst)
 {
-        dst->f_dentry->d_inode->i_atime = src->f_dentry->d_inode->i_atime;
+        dst->f_path.dentry->d_inode->i_atime =
+                src->f_path.dentry->d_inode->i_atime;
         return;
 }
 
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index c1493524da4d..8d05b9f7578d 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -74,7 +74,7 @@ struct inode_operations autofs4_dir_inode_operations = {
 static int autofs4_root_readdir(struct file *file, void *dirent,
                                 filldir_t filldir)
 {
-        struct autofs_sb_info *sbi = autofs4_sbi(file->f_dentry->d_sb);
+        struct autofs_sb_info *sbi = autofs4_sbi(file->f_path.dentry->d_sb);
         int oz_mode = autofs4_oz_mode(sbi);
 
         DPRINTK("called, filp->f_pos = %lld", file->f_pos);
@@ -95,8 +95,8 @@ static int autofs4_root_readdir(struct file *file, void *dirent,
 
 static int autofs4_dir_open(struct inode *inode, struct file *file)
 {
-        struct dentry *dentry = file->f_dentry;
-        struct vfsmount *mnt = file->f_vfsmnt;
+        struct dentry *dentry = file->f_path.dentry;
+        struct vfsmount *mnt = file->f_path.mnt;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct dentry *cursor;
         int status;
@@ -172,7 +172,7 @@ out:
 
 static int autofs4_dir_close(struct inode *inode, struct file *file)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct dentry *cursor = file->private_data;
         int status = 0;
@@ -204,7 +204,7 @@ out:
 
 static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct dentry *cursor = file->private_data;
         int status;
@@ -858,14 +858,14 @@ static int autofs4_root_ioctl(struct inode *inode, struct file *filp,
                 return autofs4_ask_reghost(sbi, p);
 
         case AUTOFS_IOC_ASKUMOUNT:
-                return autofs4_ask_umount(filp->f_vfsmnt, p);
+                return autofs4_ask_umount(filp->f_path.mnt, p);
 
         /* return a single thing to expire */
         case AUTOFS_IOC_EXPIRE:
-                return autofs4_expire_run(inode->i_sb,filp->f_vfsmnt,sbi, p);
+                return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p);
         /* same as above, but can send multiple expires through pipe */
         case AUTOFS_IOC_EXPIRE_MULTI:
-                return autofs4_expire_multi(inode->i_sb,filp->f_vfsmnt,sbi, p);
+                return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p);
 
         default:
                 return -ENOSYS;
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index bce402eee554..481e59b9d91c 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -212,7 +212,7 @@ befs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 static int
 befs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block *sb = inode->i_sb;
         befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;
         befs_off_t value;
@@ -222,7 +222,7 @@ befs_readdir(struct file *filp, void *dirent, filldir_t filldir)
         char keybuf[BEFS_NAME_LEN + 1];
         char *nlsname;
         int nlsnamelen;
-        const char *dirname = filp->f_dentry->d_name.name;
+        const char *dirname = filp->f_path.dentry->d_name.name;
 
         befs_debug(sb, "---> befs_readdir() "
                    "name %s, inode %ld, filp->f_pos %Ld",
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index a650f1d0b85e..2a746e688df5 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -27,7 +27,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_dentry->d_inode;
+        struct inode * dir = f->f_path.dentry->d_inode;
         struct buffer_head * bh;
         struct bfs_dirent * de;
         unsigned int offset;
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 517e111bb7ef..813a887cd2b3 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -274,7 +274,7 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
         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_dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
+            i_size_read(bprm->file->f_path.dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
                 return -ENOEXEC;
         }
 
@@ -389,7 +389,7 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                 {
                         printk(KERN_WARNING 
                                "fd_offset is not page aligned. Please convert program: %s\n",
-                               bprm->file->f_dentry->d_name.name);
+                               bprm->file->f_path.dentry->d_name.name);
                         error_time = jiffies;
                 }
 
@@ -469,7 +469,7 @@ static int load_aout_library(struct file *file)
         int retval;
         struct exec ex;
 
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
 
         retval = -ENOEXEC;
         error = kernel_read(file, 0, (char *) &ex, sizeof(ex));
@@ -506,7 +506,7 @@ static int load_aout_library(struct file *file)
                 {
                         printk(KERN_WARNING 
                                "N_TXTOFF is not page aligned. Please convert library: %s\n",
-                               file->f_dentry->d_name.name);
+                               file->f_path.dentry->d_name.name);
                         error_time = jiffies;
                 }
                 down_write(&current->mm->mmap_sem);
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index be5869d34999..d3adfd353ff9 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1190,7 +1190,7 @@ static int maydump(struct vm_area_struct *vma)
 
         /* Dump shared memory only if mapped from an anonymous file. */
         if (vma->vm_flags & VM_SHARED)
-                return vma->vm_file->f_dentry->d_inode->i_nlink == 0;
+                return vma->vm_file->f_path.dentry->d_inode->i_nlink == 0;
 
         /* If it hasn't been written to, don't write it out */
         if (!vma->anon_vma)
@@ -1317,7 +1317,7 @@ static void fill_prstatus(struct elf_prstatus *prstatus,
         prstatus->pr_pid = p->pid;
         prstatus->pr_ppid = p->parent->pid;
         prstatus->pr_pgrp = process_group(p);
-        prstatus->pr_sid = p->signal->session;
+        prstatus->pr_sid = process_session(p);
         if (thread_group_leader(p)) {
                 /*
                  * This is the record for the group leader.  Add in the
@@ -1363,7 +1363,7 @@ static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
         psinfo->pr_pid = p->pid;
         psinfo->pr_ppid = p->parent->pid;
         psinfo->pr_pgrp = process_group(p);
-        psinfo->pr_sid = p->signal->session;
+        psinfo->pr_sid = process_session(p);
 
         i = p->state ? ffz(~p->state) + 1 : 0;
         psinfo->pr_state = i;
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index ed9a61c6beb3..76f06f6bc2f6 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -855,7 +855,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_dentry->d_inode->i_ino);
+               what, file->f_path.dentry->d_inode->i_ino);
         return -ELIBBAD;
 }
 
@@ -1186,7 +1186,7 @@ static int maydump(struct vm_area_struct *vma)
 
         /* Dump shared memory only if mapped from an anonymous file. */
         if (vma->vm_flags & VM_SHARED) {
-                if (vma->vm_file->f_dentry->d_inode->i_nlink == 0) {
+                if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0) {
                         kdcore("%08lx: %08lx: no (share)", vma->vm_start, vma->vm_flags);
                         return 1;
                 }
@@ -1322,7 +1322,7 @@ static void fill_prstatus(struct elf_prstatus *prstatus,
         prstatus->pr_pid = p->pid;
         prstatus->pr_ppid = p->parent->pid;
         prstatus->pr_pgrp = process_group(p);
-        prstatus->pr_sid = p->signal->session;
+        prstatus->pr_sid = process_session(p);
         if (thread_group_leader(p)) {
                 /*
                  * This is the record for the group leader.  Add in the
@@ -1371,7 +1371,7 @@ static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
         psinfo->pr_pid = p->pid;
         psinfo->pr_ppid = p->parent->pid;
         psinfo->pr_pgrp = process_group(p);
-        psinfo->pr_sid = p->signal->session;
+        psinfo->pr_sid = process_session(p);
 
         i = p->state ? ffz(~p->state) + 1 : 0;
         psinfo->pr_state = i;
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index a62fd4018a20..ae8595d49856 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -429,7 +429,7 @@ static int load_flat_file(struct linux_binprm * bprm,
         int ret;
 
         hdr = ((struct flat_hdr *) bprm->buf);          /* exec-header */
-        inode = bprm->file->f_dentry->d_inode;
+        inode = bprm->file->f_path.dentry->d_inode;
 
         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 1713c48fef54..00687ea62738 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -542,7 +542,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_dentry->d_inode->i_private;
+        Node *e = file->f_path.dentry->d_inode->i_private;
         loff_t pos = *ppos;
         ssize_t res;
         char *page;
@@ -576,7 +576,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_dentry->d_inode->i_private;
+        Node *e = file->f_path.dentry->d_inode->i_private;
         int res = parse_command(buffer, count);
 
         switch (res) {
@@ -584,7 +584,7 @@ static ssize_t bm_entry_write(struct file *file, const char __user *buffer,
                         break;
                 case 2: set_bit(Enabled, &e->flags);
                         break;
-                case 3: root = dget(file->f_vfsmnt->mnt_sb->s_root);
+                case 3: root = dget(file->f_path.mnt->mnt_sb->s_root);
                         mutex_lock(&root->d_inode->i_mutex);
 
                         kill_node(e);
@@ -610,7 +610,7 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
         Node *e;
         struct inode *inode;
         struct dentry *root, *dentry;
-        struct super_block *sb = file->f_vfsmnt->mnt_sb;
+        struct super_block *sb = file->f_path.mnt->mnt_sb;
         int err = 0;
 
         e = create_entry(buffer, count);
@@ -699,7 +699,7 @@ static ssize_t bm_status_write(struct file * file, const char __user * buffer,
         switch (res) {
                 case 1: enabled = 0; break;
                 case 2: enabled = 1; break;
-                case 3: root = dget(file->f_vfsmnt->mnt_sb->s_root);
+                case 3: root = dget(file->f_path.mnt->mnt_sb->s_root);
                         mutex_lock(&root->d_inode->i_mutex);
 
                         while (!list_empty(&entries))
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 13816b4d76f6..197f93921847 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -190,7 +190,7 @@ static int blkdev_commit_write(struct file *file, struct page *page, unsigned fr
 
 /*
  * private llseek:
- * for a block special file file->f_dentry->d_inode->i_size is zero
+ * for a block special file file->f_path.dentry->d_inode->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 origin)
@@ -762,7 +762,7 @@ static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
         if (!bo)
                 return -ENOMEM;
 
-        mutex_lock_nested(&bdev->bd_mutex, BD_MUTEX_PARTITION);
+        mutex_lock(&bdev->bd_mutex);
         res = bd_claim(bdev, holder);
         if (res == 0) {
                 found = find_bd_holder(bdev, bo);
@@ -796,7 +796,7 @@ static void bd_release_from_kobject(struct block_device *bdev,
         if (!kobj)
                 return;
 
-        mutex_lock_nested(&bdev->bd_mutex, BD_MUTEX_PARTITION);
+        mutex_lock(&bdev->bd_mutex);
         bd_release(bdev);
         if ((bo = del_bd_holder(bdev, kobj)))
                 free_bd_holder(bo);
@@ -854,22 +854,6 @@ struct block_device *open_by_devnum(dev_t dev, unsigned mode)
 
 EXPORT_SYMBOL(open_by_devnum);
 
-static int
-blkdev_get_partition(struct block_device *bdev, mode_t mode, unsigned flags);
-
-struct block_device *open_partition_by_devnum(dev_t dev, unsigned mode)
-{
-        struct block_device *bdev = bdget(dev);
-        int err = -ENOMEM;
-        int flags = mode & FMODE_WRITE ? O_RDWR : O_RDONLY;
-        if (bdev)
-                err = blkdev_get_partition(bdev, mode, flags);
-        return err ? ERR_PTR(err) : bdev;
-}
-
-EXPORT_SYMBOL(open_partition_by_devnum);
-
-
 /*
  * This routine checks whether a removable media has been changed,
  * and invalidates all buffer-cache-entries in that case. This
@@ -916,66 +900,11 @@ void bd_set_size(struct block_device *bdev, loff_t size)
 }
 EXPORT_SYMBOL(bd_set_size);
 
-static int __blkdev_put(struct block_device *bdev, unsigned int subclass)
-{
-        int ret = 0;
-        struct inode *bd_inode = bdev->bd_inode;
-        struct gendisk *disk = bdev->bd_disk;
-
-        mutex_lock_nested(&bdev->bd_mutex, subclass);
-        lock_kernel();
-        if (!--bdev->bd_openers) {
-                sync_blockdev(bdev);
-                kill_bdev(bdev);
-        }
-        if (bdev->bd_contains == bdev) {
-                if (disk->fops->release)
-                        ret = disk->fops->release(bd_inode, NULL);
-        } else {
-                mutex_lock_nested(&bdev->bd_contains->bd_mutex,
-                                  subclass + 1);
-                bdev->bd_contains->bd_part_count--;
-                mutex_unlock(&bdev->bd_contains->bd_mutex);
-        }
-        if (!bdev->bd_openers) {
-                struct module *owner = disk->fops->owner;
-
-                put_disk(disk);
-                module_put(owner);
-
-                if (bdev->bd_contains != bdev) {
-                        kobject_put(&bdev->bd_part->kobj);
-                        bdev->bd_part = NULL;
-                }
-                bdev->bd_disk = NULL;
-                bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
-                if (bdev != bdev->bd_contains)
-                        __blkdev_put(bdev->bd_contains, subclass + 1);
-                bdev->bd_contains = NULL;
-        }
-        unlock_kernel();
-        mutex_unlock(&bdev->bd_mutex);
-        bdput(bdev);
-        return ret;
-}
-
-int blkdev_put(struct block_device *bdev)
-{
-        return __blkdev_put(bdev, BD_MUTEX_NORMAL);
-}
-EXPORT_SYMBOL(blkdev_put);
-
-int blkdev_put_partition(struct block_device *bdev)
-{
-        return __blkdev_put(bdev, BD_MUTEX_PARTITION);
-}
-EXPORT_SYMBOL(blkdev_put_partition);
+static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,
+                        int for_part);
+static int __blkdev_put(struct block_device *bdev, int for_part);
 
-static int
-blkdev_get_whole(struct block_device *bdev, mode_t mode, unsigned flags);
-
-static int
-do_open(struct block_device *bdev, struct file *file, unsigned int subclass)
+static int do_open(struct block_device *bdev, struct file *file, int for_part)
 {
         struct module *owner = NULL;
         struct gendisk *disk;
@@ -992,8 +921,7 @@ do_open(struct block_device *bdev, struct file *file, unsigned int subclass)
         }
         owner = disk->fops->owner;
 
-        mutex_lock_nested(&bdev->bd_mutex, subclass);
-
+        mutex_lock_nested(&bdev->bd_mutex, for_part);
         if (!bdev->bd_openers) {
                 bdev->bd_disk = disk;
                 bdev->bd_contains = bdev;
@@ -1020,25 +948,21 @@ do_open(struct block_device *bdev, struct file *file, unsigned int subclass)
                         ret = -ENOMEM;
                         if (!whole)
                                 goto out_first;
-                        ret = blkdev_get_whole(whole, file->f_mode, file->f_flags);
+                        BUG_ON(for_part);
+                        ret = __blkdev_get(whole, file->f_mode, file->f_flags, 1);
                         if (ret)
                                 goto out_first;
                         bdev->bd_contains = whole;
-                        mutex_lock_nested(&whole->bd_mutex, BD_MUTEX_WHOLE);
-                        whole->bd_part_count++;
                         p = disk->part[part - 1];
                         bdev->bd_inode->i_data.backing_dev_info =
                            whole->bd_inode->i_data.backing_dev_info;
                         if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {
-                                whole->bd_part_count--;
-                                mutex_unlock(&whole->bd_mutex);
                                 ret = -ENXIO;
                                 goto out_first;
                         }
                         kobject_get(&p->kobj);
                         bdev->bd_part = p;
                         bd_set_size(bdev, (loff_t) p->nr_sects << 9);
-                        mutex_unlock(&whole->bd_mutex);
                 }
         } else {
                 put_disk(disk);
@@ -1051,14 +975,11 @@ do_open(struct block_device *bdev, struct file *file, unsigned int subclass)
                         }
                         if (bdev->bd_invalidated)
                                 rescan_partitions(bdev->bd_disk, bdev);
-                } else {
-                        mutex_lock_nested(&bdev->bd_contains->bd_mutex,
-                                          BD_MUTEX_WHOLE);
-                        bdev->bd_contains->bd_part_count++;
-                        mutex_unlock(&bdev->bd_contains->bd_mutex);
                 }
         }
         bdev->bd_openers++;
+        if (for_part)
+                bdev->bd_part_count++;
         mutex_unlock(&bdev->bd_mutex);
         unlock_kernel();
         return 0;
@@ -1067,7 +988,7 @@ out_first:
         bdev->bd_disk = NULL;
         bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
         if (bdev != bdev->bd_contains)
-                __blkdev_put(bdev->bd_contains, BD_MUTEX_WHOLE);
+                __blkdev_put(bdev->bd_contains, 1);
         bdev->bd_contains = NULL;
         put_disk(disk);
         module_put(owner);
@@ -1079,7 +1000,8 @@ out:
         return ret;
 }
 
-int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
+static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,
+                        int for_part)
 {
         /*
          * This crockload is due to bad choice of ->open() type.
@@ -1091,51 +1013,17 @@ int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
         struct dentry fake_dentry = {};
         fake_file.f_mode = mode;
         fake_file.f_flags = flags;
-        fake_file.f_dentry = &fake_dentry;
+        fake_file.f_path.dentry = &fake_dentry;
         fake_dentry.d_inode = bdev->bd_inode;
 
-        return do_open(bdev, &fake_file, BD_MUTEX_NORMAL);
+        return do_open(bdev, &fake_file, for_part);
 }
 
-EXPORT_SYMBOL(blkdev_get);
-
-static int
-blkdev_get_whole(struct block_device *bdev, mode_t mode, unsigned flags)
-{
-        /*
-         * This crockload is due to bad choice of ->open() type.
-         * It will go away.
-         * For now, block device ->open() routine must _not_
-         * examine anything in 'inode' argument except ->i_rdev.
-         */
-        struct file fake_file = {};
-        struct dentry fake_dentry = {};
-        fake_file.f_mode = mode;
-        fake_file.f_flags = flags;
-        fake_file.f_dentry = &fake_dentry;
-        fake_dentry.d_inode = bdev->bd_inode;
-
-        return do_open(bdev, &fake_file, BD_MUTEX_WHOLE);
-}
-
-static int
-blkdev_get_partition(struct block_device *bdev, mode_t mode, unsigned flags)
+int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
 {
-        /*
-         * This crockload is due to bad choice of ->open() type.
-         * It will go away.
-         * For now, block device ->open() routine must _not_
-         * examine anything in 'inode' argument except ->i_rdev.
-         */
-        struct file fake_file = {};
-        struct dentry fake_dentry = {};
-        fake_file.f_mode = mode;
-        fake_file.f_flags = flags;
-        fake_file.f_dentry = &fake_dentry;
-        fake_dentry.d_inode = bdev->bd_inode;
-
-        return do_open(bdev, &fake_file, BD_MUTEX_PARTITION);
+        return __blkdev_get(bdev, mode, flags, 0);
 }
+EXPORT_SYMBOL(blkdev_get);
 
 static int blkdev_open(struct inode * inode, struct file * filp)
 {
@@ -1154,7 +1042,7 @@ static int blkdev_open(struct inode * inode, struct file * filp)
         if (bdev == NULL)
                 return -ENOMEM;
 
-        res = do_open(bdev, filp, BD_MUTEX_NORMAL);
+        res = do_open(bdev, filp, 0);
         if (res)
                 return res;
 
@@ -1168,6 +1056,56 @@ static int blkdev_open(struct inode * inode, struct file * filp)
         return res;
 }
 
+static int __blkdev_put(struct block_device *bdev, int for_part)
+{
+        int ret = 0;
+        struct inode *bd_inode = bdev->bd_inode;
+        struct gendisk *disk = bdev->bd_disk;
+        struct block_device *victim = NULL;
+
+        mutex_lock_nested(&bdev->bd_mutex, for_part);
+        lock_kernel();
+        if (for_part)
+                bdev->bd_part_count--;
+
+        if (!--bdev->bd_openers) {
+                sync_blockdev(bdev);
+                kill_bdev(bdev);
+        }
+        if (bdev->bd_contains == bdev) {
+                if (disk->fops->release)
+                        ret = disk->fops->release(bd_inode, NULL);
+        }
+        if (!bdev->bd_openers) {
+                struct module *owner = disk->fops->owner;
+
+                put_disk(disk);
+                module_put(owner);
+
+                if (bdev->bd_contains != bdev) {
+                        kobject_put(&bdev->bd_part->kobj);
+                        bdev->bd_part = NULL;
+                }
+                bdev->bd_disk = NULL;
+                bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
+                if (bdev != bdev->bd_contains)
+                        victim = bdev->bd_contains;
+                bdev->bd_contains = NULL;
+        }
+        unlock_kernel();
+        mutex_unlock(&bdev->bd_mutex);
+        bdput(bdev);
+        if (victim)
+                __blkdev_put(victim, 1);
+        return ret;
+}
+
+int blkdev_put(struct block_device *bdev)
+{
+        return __blkdev_put(bdev, 0);
+}
+EXPORT_SYMBOL(blkdev_put);
+
 static int blkdev_close(struct inode * inode, struct file * filp)
 {
         struct block_device *bdev = I_BDEV(filp->f_mapping->host);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 71bc87a37fc1..10c90294cd18 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -498,7 +498,7 @@ cifs_get_sb(struct file_system_type *fs_type,
 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_dentry->d_inode;
+        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
         ssize_t written;
 
         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
@@ -511,7 +511,7 @@ static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 {
         /* origin == SEEK_END => we must revalidate the cached file length */
         if (origin == SEEK_END) {
-                int retval = cifs_revalidate(file->f_dentry);
+                int retval = cifs_revalidate(file->f_path.dentry);
                 if (retval < 0)
                         return (loff_t)retval;
         }
diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index d91a3d44e9e3..da12b482ebe5 100644
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -83,10 +83,10 @@ int cifs_dir_notify(struct file * file, unsigned long arg)
                 return 0;
 
         xid = GetXid();
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
-        full_path = build_path_from_dentry(file->f_dentry);
+        full_path = build_path_from_dentry(file->f_path.dentry);
 
         if(full_path == NULL) {
                 rc = -ENOMEM;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 2436ed8fc840..1aa95a50cac2 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -122,34 +122,34 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
         /* if not oplocked, invalidate inode pages if mtime or file
            size changed */
         temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
-        if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) && 
-                           (file->f_dentry->d_inode->i_size == 
+        if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
+                           (file->f_path.dentry->d_inode->i_size ==
                             (loff_t)le64_to_cpu(buf->EndOfFile))) {
                 cFYI(1, ("inode unchanged on server"));
         } else {
-                if (file->f_dentry->d_inode->i_mapping) {
+                if (file->f_path.dentry->d_inode->i_mapping) {
                 /* BB no need to lock inode until after invalidate
                    since namei code should already have it locked? */
-                        filemap_write_and_wait(file->f_dentry->d_inode->i_mapping);
+                        filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
                 }
                 cFYI(1, ("invalidating remote inode since open detected it "
                          "changed"));
-                invalidate_remote_inode(file->f_dentry->d_inode);
+                invalidate_remote_inode(file->f_path.dentry->d_inode);
         }
 
 client_can_cache:
         if (pTcon->ses->capabilities & CAP_UNIX)
-                rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
+                rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
                         full_path, inode->i_sb, xid);
         else
-                rc = cifs_get_inode_info(&file->f_dentry->d_inode,
+                rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
                         full_path, buf, inode->i_sb, xid);
 
         if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
                 pCifsInode->clientCanCacheAll = TRUE;
                 pCifsInode->clientCanCacheRead = TRUE;
                 cFYI(1, ("Exclusive Oplock granted on inode %p",
-                         file->f_dentry->d_inode));
+                         file->f_path.dentry->d_inode));
         } else if ((*oplock & 0xF) == OPLOCK_READ)
                 pCifsInode->clientCanCacheRead = TRUE;
 
@@ -178,7 +178,7 @@ int cifs_open(struct inode *inode, struct file *file)
 
         if (file->f_flags & O_CREAT) {
                 /* search inode for this file and fill in file->private_data */
-                pCifsInode = CIFS_I(file->f_dentry->d_inode);
+                pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
                 read_lock(&GlobalSMBSeslock);
                 list_for_each(tmp, &pCifsInode->openFileList) {
                         pCifsFile = list_entry(tmp, struct cifsFileInfo,
@@ -206,7 +206,7 @@ int cifs_open(struct inode *inode, struct file *file)
                 }
         }
 
-        full_path = build_path_from_dentry(file->f_dentry);
+        full_path = build_path_from_dentry(file->f_path.dentry);
         if (full_path == NULL) {
                 FreeXid(xid);
                 return -ENOMEM;
@@ -291,7 +291,7 @@ int cifs_open(struct inode *inode, struct file *file)
         write_lock(&GlobalSMBSeslock);
         list_add(&pCifsFile->tlist, &pTcon->openFileList);
 
-        pCifsInode = CIFS_I(file->f_dentry->d_inode);
+        pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
         if (pCifsInode) {
                 rc = cifs_open_inode_helper(inode, file, pCifsInode,
                                             pCifsFile, pTcon,
@@ -366,7 +366,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
                 return 0;
         }
 
-        if (file->f_dentry == NULL) {
+        if (file->f_path.dentry == NULL) {
                 up(&pCifsFile->fh_sem);
                 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
                 FreeXid(xid);
@@ -378,7 +378,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
    those that already have the rename sem can end up causing writepage
    to get called and if the server was down that means we end up here,
    and we can never tell if the caller already has the rename_sem */
-        full_path = build_path_from_dentry(file->f_dentry);
+        full_path = build_path_from_dentry(file->f_path.dentry);
         if (full_path == NULL) {
                 up(&pCifsFile->fh_sem);
                 FreeXid(xid);
@@ -444,7 +444,7 @@ static int cifs_reopen_file(struct inode *inode, struct file *file,
                                 pCifsInode->clientCanCacheAll = TRUE;
                                 pCifsInode->clientCanCacheRead = TRUE;
                                 cFYI(1, ("Exclusive Oplock granted on inode %p",
-                                         file->f_dentry->d_inode));
+                                         file->f_path.dentry->d_inode));
                         } else if ((oplock & 0xF) == OPLOCK_READ) {
                                 pCifsInode->clientCanCacheRead = TRUE;
                                 pCifsInode->clientCanCacheAll = FALSE;
@@ -551,7 +551,7 @@ int cifs_closedir(struct inode *inode, struct file *file)
 
         if (pCFileStruct) {
                 struct cifsTconInfo *pTcon;
-                struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+                struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 
                 pTcon = cifs_sb->tcon;
 
@@ -664,7 +664,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
         } else
                 cFYI(1, ("Unknown type of lock"));
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
         if (file->private_data == NULL) {
@@ -791,10 +791,10 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
         int xid, long_op;
         struct cifsFileInfo *open_file;
 
-        if (file->f_dentry == NULL)
+        if (file->f_path.dentry == NULL)
                 return -EBADF;
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         if (cifs_sb == NULL)
                 return -EBADF;
 
@@ -802,7 +802,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
 
         /* cFYI(1,
            (" write %d bytes to offset %lld of %s", write_size,
-           *poffset, file->f_dentry->d_name.name)); */
+           *poffset, file->f_path.dentry->d_name.name)); */
 
         if (file->private_data == NULL)
                 return -EBADF;
@@ -810,12 +810,12 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                 open_file = (struct cifsFileInfo *) file->private_data;
         
         xid = GetXid();
-        if (file->f_dentry->d_inode == NULL) {
+        if (file->f_path.dentry->d_inode == NULL) {
                 FreeXid(xid);
                 return -EBADF;
         }
 
-        if (*poffset > file->f_dentry->d_inode->i_size)
+        if (*poffset > file->f_path.dentry->d_inode->i_size)
                 long_op = 2; /* writes past end of file can take a long time */
         else
                 long_op = 1;
@@ -840,8 +840,8 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                                         return -EBADF;
                         }
                         if (open_file->invalidHandle) {
-                                if ((file->f_dentry == NULL) ||
-                                    (file->f_dentry->d_inode == NULL)) {
+                                if ((file->f_path.dentry == NULL) ||
+                                    (file->f_path.dentry->d_inode == NULL)) {
                                         FreeXid(xid);
                                         return total_written;
                                 }
@@ -849,7 +849,7 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                                    filemap_fdatawait from here so tell
                                    reopen_file not to flush data to server
                                    now */
-                                rc = cifs_reopen_file(file->f_dentry->d_inode,
+                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
                                         file, FALSE);
                                 if (rc != 0)
                                         break;
@@ -878,17 +878,17 @@ ssize_t cifs_user_write(struct file *file, const char __user *write_data,
         cifs_stats_bytes_written(pTcon, total_written);
 
         /* since the write may have blocked check these pointers again */
-        if (file->f_dentry) {
-                if (file->f_dentry->d_inode) {
-                        struct inode *inode = file->f_dentry->d_inode;
+        if (file->f_path.dentry) {
+                if (file->f_path.dentry->d_inode) {
+                        struct inode *inode = file->f_path.dentry->d_inode;
                         inode->i_ctime = inode->i_mtime =
                                 current_fs_time(inode->i_sb);
                         if (total_written > 0) {
-                                if (*poffset > file->f_dentry->d_inode->i_size)
-                                        i_size_write(file->f_dentry->d_inode,
+                                if (*poffset > file->f_path.dentry->d_inode->i_size)
+                                        i_size_write(file->f_path.dentry->d_inode,
                                         *poffset);
                         }
-                        mark_inode_dirty_sync(file->f_dentry->d_inode);
+                        mark_inode_dirty_sync(file->f_path.dentry->d_inode);
                 }
         }
         FreeXid(xid);
@@ -906,17 +906,17 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
         int xid, long_op;
         struct cifsFileInfo *open_file;
 
-        if (file->f_dentry == NULL)
+        if (file->f_path.dentry == NULL)
                 return -EBADF;
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         if (cifs_sb == NULL)
                 return -EBADF;
 
         pTcon = cifs_sb->tcon;
 
         cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
-           *poffset, file->f_dentry->d_name.name));
+           *poffset, file->f_path.dentry->d_name.name));
 
         if (file->private_data == NULL)
                 return -EBADF;
@@ -924,12 +924,12 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                 open_file = (struct cifsFileInfo *)file->private_data;
         
         xid = GetXid();
-        if (file->f_dentry->d_inode == NULL) {
+        if (file->f_path.dentry->d_inode == NULL) {
                 FreeXid(xid);
                 return -EBADF;
         }
 
-        if (*poffset > file->f_dentry->d_inode->i_size)
+        if (*poffset > file->f_path.dentry->d_inode->i_size)
                 long_op = 2; /* writes past end of file can take a long time */
         else
                 long_op = 1;
@@ -955,8 +955,8 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                         return -EBADF;
                         }
                         if (open_file->invalidHandle) {
-                                if ((file->f_dentry == NULL) ||
-                                   (file->f_dentry->d_inode == NULL)) {
+                                if ((file->f_path.dentry == NULL) ||
+                                   (file->f_path.dentry->d_inode == NULL)) {
                                         FreeXid(xid);
                                         return total_written;
                                 }
@@ -964,7 +964,7 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                    filemap_fdatawait from here so tell
                                    reopen_file not to flush data to 
                                    server now */
-                                rc = cifs_reopen_file(file->f_dentry->d_inode,
+                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
                                         file, FALSE);
                                 if (rc != 0)
                                         break;
@@ -1011,16 +1011,16 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
         cifs_stats_bytes_written(pTcon, total_written);
 
         /* since the write may have blocked check these pointers again */
-        if (file->f_dentry) {
-                if (file->f_dentry->d_inode) {
-                        file->f_dentry->d_inode->i_ctime = 
-                        file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
+        if (file->f_path.dentry) {
+                if (file->f_path.dentry->d_inode) {
+                        file->f_path.dentry->d_inode->i_ctime =
+                        file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;
                         if (total_written > 0) {
-                                if (*poffset > file->f_dentry->d_inode->i_size)
-                                        i_size_write(file->f_dentry->d_inode, 
+                                if (*poffset > file->f_path.dentry->d_inode->i_size)
+                                        i_size_write(file->f_path.dentry->d_inode,
                                                      *poffset);
                         }
-                        mark_inode_dirty_sync(file->f_dentry->d_inode);
+                        mark_inode_dirty_sync(file->f_path.dentry->d_inode);
                 }
         }
         FreeXid(xid);
@@ -1384,7 +1384,7 @@ static int cifs_commit_write(struct file *file, struct page *page,
                                 if ((open_file->invalidHandle) && 
                                     (!open_file->closePend)) {
                                         rc = cifs_reopen_file(
-                                                file->f_dentry->d_inode, file);
+                                                file->f_path.dentry->d_inode, file);
                                         if (rc != 0)
                                                 break;
                                 }
@@ -1434,7 +1434,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
         int xid;
         int rc = 0;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
 
         xid = GetXid();
 
@@ -1482,7 +1482,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
  */
 int cifs_flush(struct file *file, fl_owner_t id)
 {
-        struct inode * inode = file->f_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         int rc = 0;
 
         /* Rather than do the steps manually:
@@ -1519,7 +1519,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
         struct smb_com_read_rsp *pSMBr;
 
         xid = GetXid();
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
         if (file->private_data == NULL) {
@@ -1542,7 +1542,7 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                         int buf_type = CIFS_NO_BUFFER;
                         if ((open_file->invalidHandle) && 
                             (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_dentry->d_inode,
+                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
                                         file, TRUE);
                                 if (rc != 0)
                                         break;
@@ -1601,7 +1601,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
         int buf_type = CIFS_NO_BUFFER;
 
         xid = GetXid();
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
         if (file->private_data == NULL) {
@@ -1629,7 +1629,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
                 while (rc == -EAGAIN) {
                         if ((open_file->invalidHandle) && 
                             (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_dentry->d_inode,
+                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
                                         file, TRUE);
                                 if (rc != 0)
                                         break;
@@ -1658,7 +1658,7 @@ static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
 
 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         int rc, xid;
 
         xid = GetXid();
@@ -1744,7 +1744,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 return -EBADF;
         }
         open_file = (struct cifsFileInfo *)file->private_data;
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
         pagevec_init(&lru_pvec, 0);
@@ -1786,7 +1786,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 while (rc == -EAGAIN) {
                         if ((open_file->invalidHandle) && 
                             (!open_file->closePend)) {
-                                rc = cifs_reopen_file(file->f_dentry->d_inode,
+                                rc = cifs_reopen_file(file->f_path.dentry->d_inode,
                                         file, TRUE);
                                 if (rc != 0)
                                         break;
@@ -1880,8 +1880,8 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
         else
                 cFYI(1, ("Bytes read %d",rc));
                                                                                                                            
-        file->f_dentry->d_inode->i_atime =
-                current_fs_time(file->f_dentry->d_inode->i_sb);
+        file->f_path.dentry->d_inode->i_atime =
+                current_fs_time(file->f_path.dentry->d_inode->i_sb);
                                                                                                                            
         if (PAGE_CACHE_SIZE > rc)
                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index ed18c3965f7b..99dfb5337e31 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -68,30 +68,30 @@ static int construct_dentry(struct qstr *qstring, struct file *file,
         int rc = 0;
 
         cFYI(1, ("For %s", qstring->name));
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
 
         qstring->hash = full_name_hash(qstring->name, qstring->len);
-        tmp_dentry = d_lookup(file->f_dentry, qstring);
+        tmp_dentry = d_lookup(file->f_path.dentry, qstring);
         if (tmp_dentry) {
                 cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
                 *ptmp_inode = tmp_dentry->d_inode;
 /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
                 if(*ptmp_inode == NULL) {
-                        *ptmp_inode = new_inode(file->f_dentry->d_sb);
+                        *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
                         if(*ptmp_inode == NULL)
                                 return rc;
                         rc = 1;
                 }
         } else {
-                tmp_dentry = d_alloc(file->f_dentry, qstring);
+                tmp_dentry = d_alloc(file->f_path.dentry, qstring);
                 if(tmp_dentry == NULL) {
                         cERROR(1,("Failed allocating dentry"));
                         *ptmp_inode = NULL;
                         return rc;
                 }
 
-                *ptmp_inode = new_inode(file->f_dentry->d_sb);
+                *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
                 if (pTcon->nocase)
                         tmp_dentry->d_op = &cifs_ci_dentry_ops;
                 else
@@ -432,10 +432,10 @@ static int initiate_cifs_search(const int xid, struct file *file)
         cifsFile->invalidHandle = TRUE;
         cifsFile->srch_inf.endOfSearch = FALSE;
 
-        if(file->f_dentry == NULL)
+        if(file->f_path.dentry == NULL)
                 return -ENOENT;
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         if(cifs_sb == NULL)
                 return -EINVAL;
 
@@ -443,7 +443,7 @@ static int initiate_cifs_search(const int xid, struct file *file)
         if(pTcon == NULL)
                 return -EINVAL;
 
-        full_path = build_path_from_dentry(file->f_dentry);
+        full_path = build_path_from_dentry(file->f_path.dentry);
 
         if(full_path == NULL) {
                 return -ENOMEM;
@@ -609,10 +609,10 @@ static int is_dir_changed(struct file * file)
         struct inode * inode;
         struct cifsInodeInfo *cifsInfo;
 
-        if(file->f_dentry == NULL)
+        if(file->f_path.dentry == NULL)
                 return 0;
 
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
 
         if(inode == NULL)
                 return 0;
@@ -839,7 +839,7 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
         if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
                 return -ENOENT;
 
-        if(file->f_dentry == NULL)
+        if(file->f_path.dentry == NULL)
                 return -ENOENT;
 
         rc = cifs_entry_is_dot(pfindEntry,pCifsF);
@@ -847,7 +847,7 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
         if(rc != 0) 
                 return 0;
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 
         qstring.name = scratch_buf;
         rc = cifs_get_name_from_search_buf(&qstring,pfindEntry,
@@ -985,12 +985,12 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
 
         xid = GetXid();
 
-        if(file->f_dentry == NULL) {
+        if(file->f_path.dentry == NULL) {
                 FreeXid(xid);
                 return -EIO;
         }
 
-        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
+        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
         pTcon = cifs_sb->tcon;
         if(pTcon == NULL)
                 return -EINVAL;
@@ -998,7 +998,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_dentry->d_inode->i_ino, DT_DIR) < 0) {
+                     file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
                         cERROR(1, ("Filldir for current dir failed"));
                         rc = -ENOMEM;
                         break;
@@ -1006,7 +1006,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                 file->f_pos++;
         case 1:
                 if (filldir(direntry, "..", 2, file->f_pos,
-                     file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
+                     file->f_path.dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
                         cERROR(1, ("Filldir for parent dir failed"));
                         rc = -ENOMEM;
                         break;
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 0102b28a15fb..0c6f7f3b3dd7 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -441,7 +441,7 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
 /* file operations for directories */
 int coda_readdir(struct file *coda_file, void *dirent, filldir_t filldir)
 {
-        struct dentry *coda_dentry = coda_file->f_dentry;
+        struct dentry *coda_dentry = coda_file->f_path.dentry;
         struct coda_file_info *cfi;
         struct file *host_file;
         struct inode *host_inode;
@@ -453,7 +453,7 @@ int coda_readdir(struct file *coda_file, void *dirent, filldir_t filldir)
 
         coda_vfs_stat.readdir++;
 
-        host_inode = host_file->f_dentry->d_inode;
+        host_inode = host_file->f_path.dentry->d_inode;
         mutex_lock(&host_inode->i_mutex);
         host_file->f_pos = coda_file->f_pos;
 
@@ -544,14 +544,14 @@ static int coda_venus_readdir(struct file *filp, filldir_t filldir,
                 /* catch truncated reads */
                 if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
                         printk("coda_venus_readdir: short read: %ld\n",
-                               filp->f_dentry->d_inode->i_ino);
+                               filp->f_path.dentry->d_inode->i_ino);
                         ret = -EBADF;
                         break;
                 }
                 /* validate whether the directory file actually makes sense */
                 if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
                         printk("coda_venus_readdir: Invalid dir: %ld\n",
-                               filp->f_dentry->d_inode->i_ino);
+                               filp->f_path.dentry->d_inode->i_ino);
                         ret = -EBADF;
                         break;
                 }
diff --git a/fs/coda/file.c b/fs/coda/file.c
index dbfbcfa5b3c0..5ef2b609ec7d 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -66,7 +66,7 @@ coda_file_sendfile(struct file *coda_file, loff_t *ppos, size_t count,
 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_dentry->d_inode;
+        struct inode *host_inode, *coda_inode = coda_file->f_path.dentry->d_inode;
         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_dentry->d_inode;
+        host_inode = host_file->f_path.dentry->d_inode;
         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_dentry->d_inode;
-        host_inode = host_file->f_dentry->d_inode;
+        coda_inode = coda_file->f_path.dentry->d_inode;
+        host_inode = host_file->f_path.dentry->d_inode;
         coda_file->f_mapping = host_file->f_mapping;
         if (coda_inode->i_mapping == &coda_inode->i_data)
                 coda_inode->i_mapping = host_inode->i_mapping;
@@ -190,7 +190,7 @@ int coda_flush(struct file *coda_file, fl_owner_t id)
         cfi = CODA_FTOC(coda_file);
         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
 
-        coda_inode = coda_file->f_dentry->d_inode;
+        coda_inode = coda_file->f_path.dentry->d_inode;
 
         err = venus_store(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
                           coda_file->f_uid);
@@ -233,7 +233,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_uid);
 
-        host_inode = cfi->cfi_container->f_dentry->d_inode;
+        host_inode = cfi->cfi_container->f_path.dentry->d_inode;
         cii = ITOC(coda_inode);
 
         /* did we mmap this file? */
@@ -270,7 +270,7 @@ int coda_fsync(struct file *coda_file, struct dentry *coda_dentry, int datasync)
         coda_vfs_stat.fsync++;
 
         if (host_file->f_op && host_file->f_op->fsync) {
-                host_dentry = host_file->f_dentry;
+                host_dentry = host_file->f_path.dentry;
                 host_inode = host_dentry->d_inode;
                 mutex_lock(&host_inode->i_mutex);
                 err = host_file->f_op->fsync(host_file, host_dentry, datasync);
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index b64659fa82d0..01395defed85 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -119,7 +119,7 @@ static int get_device_index(struct coda_mount_data *data)
         file = fget(data->fd);
         inode = NULL;
         if(file)
-                inode = file->f_dentry->d_inode;
+                inode = file->f_path.dentry->d_inode;
         
         if(!inode || !S_ISCHR(inode->i_mode) ||
            imajor(inode) != CODA_PSDEV_MAJOR) {
diff --git a/fs/compat.c b/fs/compat.c
index a7e3f162fb15..b766964a625c 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -232,7 +232,7 @@ asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user
         file = fget(fd);
         if (!file)
                 goto out;
-        error = vfs_statfs(file->f_dentry, &tmp);
+        error = vfs_statfs(file->f_path.dentry, &tmp);
         if (!error)
                 error = put_compat_statfs(buf, &tmp);
         fput(file);
@@ -303,7 +303,7 @@ asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct c
         file = fget(fd);
         if (!file)
                 goto out;
-        error = vfs_statfs(file->f_dentry, &tmp);
+        error = vfs_statfs(file->f_path.dentry, &tmp);
         if (!error)
                 error = put_compat_statfs64(buf, &tmp);
         fput(file);
@@ -365,7 +365,7 @@ static void compat_ioctl_error(struct file *filp, unsigned int fd,
         /* find the name of the device. */
         path = (char *)__get_free_page(GFP_KERNEL);
         if (path) {
-                fn = d_path(filp->f_dentry, filp->f_vfsmnt, path, PAGE_SIZE);
+                fn = d_path(filp->f_path.dentry, filp->f_path.mnt, path, PAGE_SIZE);
                 if (IS_ERR(fn))
                         fn = "?";
         }
@@ -416,7 +416,7 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
         case FIBMAP:
         case FIGETBSZ:
         case FIONREAD:
-                if (S_ISREG(filp->f_dentry->d_inode->i_mode))
+                if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
                         break;
                 /*FALL THROUGH*/
 
@@ -438,7 +438,7 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
                         goto found_handler;
         }
 
-        if (S_ISSOCK(filp->f_dentry->d_inode->i_mode) &&
+        if (S_ISSOCK(filp->f_path.dentry->d_inode->i_mode) &&
             cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
                 error = siocdevprivate_ioctl(fd, cmd, arg);
         } else {
@@ -1259,7 +1259,7 @@ out:
         if (iov != iovstack)
                 kfree(iov);
         if ((ret + (type == READ)) > 0) {
-                struct dentry *dentry = file->f_dentry;
+                struct dentry *dentry = file->f_path.dentry;
                 if (type == READ)
                         fsnotify_access(dentry);
                 else
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index bcc3caf5d820..c81c958b3e1d 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -1177,7 +1177,7 @@ static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long ar
 static int vt_check(struct file *file)
 {
         struct tty_struct *tty;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         
         if (file->f_op->ioctl != tty_ioctl)
                 return -EINVAL;
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index c398861f78a5..1814ba446809 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -980,7 +980,7 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
 
 static int configfs_dir_open(struct inode *inode, struct file *file)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         struct configfs_dirent * parent_sd = dentry->d_fsdata;
 
         mutex_lock(&dentry->d_inode->i_mutex);
@@ -993,7 +993,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
 
 static int configfs_dir_close(struct inode *inode, struct file *file)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         struct configfs_dirent * cursor = file->private_data;
 
         mutex_lock(&dentry->d_inode->i_mutex);
@@ -1013,7 +1013,7 @@ static inline unsigned char dt_type(struct configfs_dirent *sd)
 
 static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct configfs_dirent * parent_sd = dentry->d_fsdata;
         struct configfs_dirent *cursor = filp->private_data;
         struct list_head *p, *q = &cursor->s_sibling;
@@ -1070,7 +1070,7 @@ static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir
 
 static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
 
         mutex_lock(&dentry->d_inode->i_mutex);
         switch (origin) {
@@ -1080,7 +1080,7 @@ static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index cf33fac68c84..2a7cb086e80c 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -134,7 +134,7 @@ configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *pp
 
         down(&buffer->sem);
         if (buffer->needs_read_fill) {
-                if ((retval = fill_read_buffer(file->f_dentry,buffer)))
+                if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
                         goto out;
         }
         pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
@@ -222,7 +222,7 @@ configfs_write_file(struct file *file, const char __user *buf, size_t count, lof
         down(&buffer->sem);
         len = fill_write_buffer(buffer, buf, count);
         if (len > 0)
-                len = flush_write_buffer(file->f_dentry, buffer, count);
+                len = flush_write_buffer(file->f_path.dentry, buffer, count);
         if (len > 0)
                 *ppos += len;
         up(&buffer->sem);
@@ -231,8 +231,8 @@ configfs_write_file(struct file *file, const char __user *buf, size_t count, lof
 
 static int check_perm(struct inode * inode, struct file * file)
 {
-        struct config_item *item = configfs_get_config_item(file->f_dentry->d_parent);
-        struct configfs_attribute * attr = to_attr(file->f_dentry);
+        struct config_item *item = configfs_get_config_item(file->f_path.dentry->d_parent);
+        struct configfs_attribute * attr = to_attr(file->f_path.dentry);
         struct configfs_buffer * buffer;
         struct configfs_item_operations * ops = NULL;
         int error = 0;
@@ -305,8 +305,8 @@ static int configfs_open_file(struct inode * inode, struct file * filp)
 
 static int configfs_release(struct inode * inode, struct file * filp)
 {
-        struct config_item * item = to_item(filp->f_dentry->d_parent);
-        struct configfs_attribute * attr = to_attr(filp->f_dentry);
+        struct config_item * item = to_item(filp->f_path.dentry->d_parent);
+        struct configfs_attribute * attr = to_attr(filp->f_path.dentry);
         struct module * owner = attr->ca_owner;
         struct configfs_buffer * buffer = filp->private_data;
 
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 0509cedd415c..6db03fb089dc 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -338,7 +338,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block *sb = inode->i_sb;
         char *buf;
         unsigned int offset;
diff --git a/fs/dnotify.c b/fs/dnotify.c
index 1f26a2b9eee1..936409fcd939 100644
--- a/fs/dnotify.c
+++ b/fs/dnotify.c
@@ -42,7 +42,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
         struct dnotify_struct **prev;
         struct inode *inode;
 
-        inode = filp->f_dentry->d_inode;
+        inode = filp->f_path.dentry->d_inode;
         if (!S_ISDIR(inode->i_mode))
                 return;
         spin_lock(&inode->i_lock);
@@ -74,7 +74,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
         }
         if (!dir_notify_enable)
                 return -EINVAL;
-        inode = filp->f_dentry->d_inode;
+        inode = filp->f_path.dentry->d_inode;
         if (!S_ISDIR(inode->i_mode))
                 return -ENOTDIR;
         dn = kmem_cache_alloc(dn_cache, GFP_KERNEL);
diff --git a/fs/dquot.c b/fs/dquot.c
index f9cd5e23ebdf..0952cc474d9a 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -694,9 +694,9 @@ restart:
         file_list_lock();
         list_for_each(p, &sb->s_files) {
                 struct file *filp = list_entry(p, struct file, f_u.fu_list);
-                struct inode *inode = filp->f_dentry->d_inode;
+                struct inode *inode = filp->f_path.dentry->d_inode;
                 if (filp->f_mode & FMODE_WRITE && dqinit_needed(inode, type)) {
-                        struct dentry *dentry = dget(filp->f_dentry);
+                        struct dentry *dentry = dget(filp->f_path.dentry);
                         file_list_unlock();
                         sb->dq_op->initialize(inode, type);
                         dput(dentry);
@@ -828,6 +828,7 @@ static inline int need_print_warning(struct dquot *dquot)
 static void print_warning(struct dquot *dquot, const char warntype)
 {
         char *msg = NULL;
+        struct tty_struct *tty;
         int flag = (warntype == BHARDWARN || warntype == BSOFTLONGWARN) ? DQ_BLKS_B :
           ((warntype == IHARDWARN || warntype == ISOFTLONGWARN) ? DQ_INODES_B : 0);
 
@@ -835,14 +836,15 @@ static void print_warning(struct dquot *dquot, const char warntype)
                 return;
 
         mutex_lock(&tty_mutex);
-        if (!current->signal->tty)
+        tty = get_current_tty();
+        if (!tty)
                 goto out_lock;
-        tty_write_message(current->signal->tty, dquot->dq_sb->s_id);
+        tty_write_message(tty, dquot->dq_sb->s_id);
         if (warntype == ISOFTWARN || warntype == BSOFTWARN)
-                tty_write_message(current->signal->tty, ": warning, ");
+                tty_write_message(tty, ": warning, ");
         else
-                tty_write_message(current->signal->tty, ": write failed, ");
-        tty_write_message(current->signal->tty, quotatypes[dquot->dq_type]);
+                tty_write_message(tty, ": write failed, ");
+        tty_write_message(tty, quotatypes[dquot->dq_type]);
         switch (warntype) {
                 case IHARDWARN:
                         msg = " file limit reached.\r\n";
@@ -863,7 +865,7 @@ static void print_warning(struct dquot *dquot, const char warntype)
                         msg = " block quota exceeded.\r\n";
                         break;
         }
-        tty_write_message(current->signal->tty, msg);
+        tty_write_message(tty, msg);
 out_lock:
         mutex_unlock(&tty_mutex);
 }
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index 52d1e36dc746..329efcd3d8c9 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -25,6 +25,7 @@
 #include <linux/dcache.h>
 #include <linux/namei.h>
 #include <linux/mount.h>
+#include <linux/fs_stack.h>
 #include "ecryptfs_kernel.h"
 
 /**
@@ -61,7 +62,7 @@ static int ecryptfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
                 struct inode *lower_inode =
                         ecryptfs_inode_to_lower(dentry->d_inode);
 
-                ecryptfs_copy_attr_all(dentry->d_inode, lower_inode);
+                fsstack_copy_attr_all(dentry->d_inode, lower_inode, NULL);
         }
 out:
         return rc;
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index f992533d1692..afb64bdbe6ad 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -28,6 +28,8 @@
 
 #include <keys/user-type.h>
 #include <linux/fs.h>
+#include <linux/fs_stack.h>
+#include <linux/namei.h>
 #include <linux/scatterlist.h>
 
 /* Version verification for shared data structures w/ userspace */
@@ -227,8 +229,7 @@ struct ecryptfs_inode_info {
 /* dentry private data. Each dentry must keep track of a lower
  * vfsmount too. */
 struct ecryptfs_dentry_info {
-        struct dentry *wdi_dentry;
-        struct vfsmount *lower_mnt;
+        struct path lower_path;
         struct ecryptfs_crypt_stat *crypt_stat;
 };
 
@@ -355,26 +356,26 @@ ecryptfs_set_dentry_private(struct dentry *dentry,
 static inline struct dentry *
 ecryptfs_dentry_to_lower(struct dentry *dentry)
 {
-        return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->wdi_dentry;
+        return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.dentry;
 }
 
 static inline void
 ecryptfs_set_dentry_lower(struct dentry *dentry, struct dentry *lower_dentry)
 {
-        ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->wdi_dentry =
+        ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.dentry =
                 lower_dentry;
 }
 
 static inline struct vfsmount *
 ecryptfs_dentry_to_lower_mnt(struct dentry *dentry)
 {
-        return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_mnt;
+        return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.mnt;
 }
 
 static inline void
 ecryptfs_set_dentry_lower_mnt(struct dentry *dentry, struct vfsmount *lower_mnt)
 {
-        ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_mnt =
+        ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.mnt =
                 lower_mnt;
 }
 
@@ -413,9 +414,6 @@ int ecryptfs_encode_filename(struct ecryptfs_crypt_stat *crypt_stat,
                              const char *name, int length,
                              char **encoded_name);
 struct dentry *ecryptfs_lower_dentry(struct dentry *this_dentry);
-void ecryptfs_copy_attr_atime(struct inode *dest, const struct inode *src);
-void ecryptfs_copy_attr_all(struct inode *dest, const struct inode *src);
-void ecryptfs_copy_inode_size(struct inode *dst, const struct inode *src);
 void ecryptfs_dump_hex(char *data, int bytes);
 int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
                         int sg_size);
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 42099e779a56..c5a2e5298f15 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -30,6 +30,7 @@
 #include <linux/security.h>
 #include <linux/smp_lock.h>
 #include <linux/compat.h>
+#include <linux/fs_stack.h>
 #include "ecryptfs_kernel.h"
 
 /**
@@ -75,7 +76,7 @@ static loff_t ecryptfs_llseek(struct file *file, loff_t offset, int origin)
         }
         ecryptfs_printk(KERN_DEBUG, "new_end_pos = [0x%.16x]\n", new_end_pos);
         if (expanding_file) {
-                rc = ecryptfs_truncate(file->f_dentry, new_end_pos);
+                rc = ecryptfs_truncate(file->f_path.dentry, new_end_pos);
                 if (rc) {
                         rv = rc;
                         ecryptfs_printk(KERN_ERR, "Error on attempt to "
@@ -116,8 +117,8 @@ static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
         if (-EIOCBQUEUED == rc)
                 rc = wait_on_sync_kiocb(iocb);
         if (rc >= 0) {
-                lower_dentry = ecryptfs_dentry_to_lower(file->f_dentry);
-                lower_vfsmount = ecryptfs_dentry_to_lower_mnt(file->f_dentry);
+                lower_dentry = ecryptfs_dentry_to_lower(file->f_path.dentry);
+                lower_vfsmount = ecryptfs_dentry_to_lower_mnt(file->f_path.dentry);
                 touch_atime(lower_vfsmount, lower_dentry);
         }
         return rc;
@@ -176,10 +177,10 @@ 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_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
         memset(&buf, 0, sizeof(buf));
         buf.dirent = dirent;
-        buf.dentry = file->f_dentry;
+        buf.dentry = file->f_path.dentry;
         buf.filldir = filldir;
 retry:
         buf.filldir_called = 0;
@@ -192,7 +193,7 @@ retry:
                 goto retry;
         file->f_pos = lower_file->f_pos;
         if (rc >= 0)
-                ecryptfs_copy_attr_atime(inode, lower_file->f_dentry->d_inode);
+                fsstack_copy_attr_atime(inode, lower_file->f_path.dentry->d_inode);
         return rc;
 }
 
@@ -239,7 +240,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
         int rc = 0;
         struct ecryptfs_crypt_stat *crypt_stat = NULL;
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
-        struct dentry *ecryptfs_dentry = file->f_dentry;
+        struct dentry *ecryptfs_dentry = file->f_path.dentry;
         /* Private value of ecryptfs_dentry allocated in
          * ecryptfs_lookup() */
         struct dentry *lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 8a1945a84c36..11f5e5076aef 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -30,6 +30,7 @@
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/crypto.h>
+#include <linux/fs_stack.h>
 #include "ecryptfs_kernel.h"
 
 static struct dentry *lock_parent(struct dentry *dentry)
@@ -53,48 +54,6 @@ static void unlock_dir(struct dentry *dir)
         dput(dir);
 }
 
-void ecryptfs_copy_inode_size(struct inode *dst, const struct inode *src)
-{
-        i_size_write(dst, i_size_read((struct inode *)src));
-        dst->i_blocks = src->i_blocks;
-}
-
-void ecryptfs_copy_attr_atime(struct inode *dest, const struct inode *src)
-{
-        dest->i_atime = src->i_atime;
-}
-
-static void ecryptfs_copy_attr_times(struct inode *dest,
-                                     const struct inode *src)
-{
-        dest->i_atime = src->i_atime;
-        dest->i_mtime = src->i_mtime;
-        dest->i_ctime = src->i_ctime;
-}
-
-static void ecryptfs_copy_attr_timesizes(struct inode *dest,
-                                         const struct inode *src)
-{
-        dest->i_atime = src->i_atime;
-        dest->i_mtime = src->i_mtime;
-        dest->i_ctime = src->i_ctime;
-        ecryptfs_copy_inode_size(dest, src);
-}
-
-void ecryptfs_copy_attr_all(struct inode *dest, const struct inode *src)
-{
-        dest->i_mode = src->i_mode;
-        dest->i_nlink = src->i_nlink;
-        dest->i_uid = src->i_uid;
-        dest->i_gid = src->i_gid;
-        dest->i_rdev = src->i_rdev;
-        dest->i_atime = src->i_atime;
-        dest->i_mtime = src->i_mtime;
-        dest->i_ctime = src->i_ctime;
-        dest->i_blkbits = src->i_blkbits;
-        dest->i_flags = src->i_flags;
-}
-
 /**
  * ecryptfs_create_underlying_file
  * @lower_dir_inode: inode of the parent in the lower fs of the new file
@@ -171,8 +130,8 @@ ecryptfs_do_create(struct inode *directory_inode,
                 ecryptfs_printk(KERN_ERR, "Failure in ecryptfs_interpose\n");
                 goto out_lock;
         }
-        ecryptfs_copy_attr_timesizes(directory_inode,
-                                     lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);
+        fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);
 out_lock:
         unlock_dir(lower_dir_dentry);
 out:
@@ -196,7 +155,7 @@ static int grow_file(struct dentry *ecryptfs_dentry, struct file *lower_file,
         struct ecryptfs_file_info tmp_file_info;
 
         memset(&fake_file, 0, sizeof(fake_file));
-        fake_file.f_dentry = ecryptfs_dentry;
+        fake_file.f_path.dentry = ecryptfs_dentry;
         memset(&tmp_file_info, 0, sizeof(tmp_file_info));
         ecryptfs_set_file_private(&fake_file, &tmp_file_info);
         ecryptfs_set_file_lower(&fake_file, lower_file);
@@ -365,7 +324,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 "d_name.name = [%s]\n", lower_dentry,
                 lower_dentry->d_name.name);
         lower_inode = lower_dentry->d_inode;
-        ecryptfs_copy_attr_atime(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_atime(dir, lower_dir_dentry->d_inode);
         BUG_ON(!atomic_read(&lower_dentry->d_count));
         ecryptfs_set_dentry_private(dentry,
                                     kmem_cache_alloc(ecryptfs_dentry_info_cache,
@@ -462,7 +421,8 @@ static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
         rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb, 0);
         if (rc)
                 goto out_lock;
-        ecryptfs_copy_attr_timesizes(dir, lower_new_dentry->d_inode);
+        fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);
+        fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);
         old_dentry->d_inode->i_nlink =
                 ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink;
         i_size_write(new_dentry->d_inode, file_size_save);
@@ -488,7 +448,7 @@ static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
                 printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
                 goto out_unlock;
         }
-        ecryptfs_copy_attr_times(dir, lower_dir_inode);
+        fsstack_copy_attr_times(dir, lower_dir_inode);
         dentry->d_inode->i_nlink =
                 ecryptfs_inode_to_lower(dentry->d_inode)->i_nlink;
         dentry->d_inode->i_ctime = dir->i_ctime;
@@ -527,7 +487,8 @@ static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0);
         if (rc)
                 goto out_lock;
-        ecryptfs_copy_attr_timesizes(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
 out_lock:
         unlock_dir(lower_dir_dentry);
         dput(lower_dentry);
@@ -550,7 +511,8 @@ static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0);
         if (rc)
                 goto out;
-        ecryptfs_copy_attr_timesizes(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
         dir->i_nlink = lower_dir_dentry->d_inode->i_nlink;
 out:
         unlock_dir(lower_dir_dentry);
@@ -573,7 +535,7 @@ static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
         dput(lower_dentry);
         if (!rc)
                 d_delete(lower_dentry);
-        ecryptfs_copy_attr_times(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
         dir->i_nlink = lower_dir_dentry->d_inode->i_nlink;
         unlock_dir(lower_dir_dentry);
         if (!rc)
@@ -597,7 +559,8 @@ ecryptfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0);
         if (rc)
                 goto out;
-        ecryptfs_copy_attr_timesizes(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
 out:
         unlock_dir(lower_dir_dentry);
         if (!dentry->d_inode)
@@ -626,9 +589,9 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         lower_new_dir_dentry->d_inode, lower_new_dentry);
         if (rc)
                 goto out_lock;
-        ecryptfs_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
+        fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode, NULL);
         if (new_dir != old_dir)
-                ecryptfs_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);
+                fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode, NULL);
 out_lock:
         unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
         dput(lower_new_dentry->d_parent);
@@ -684,8 +647,8 @@ ecryptfs_readlink(struct dentry *dentry, char __user * buf, int bufsiz)
                                 rc = -EFAULT;
                 }
                 kfree(decoded_name);
-                ecryptfs_copy_attr_atime(dentry->d_inode,
-                                         lower_dentry->d_inode);
+                fsstack_copy_attr_atime(dentry->d_inode,
+                                        lower_dentry->d_inode);
         }
 out_free_lower_buf:
         kfree(lower_buf);
@@ -791,7 +754,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
          * the file in the underlying filesystem so that the
          * truncation has an effect there as well. */
         memset(&fake_ecryptfs_file, 0, sizeof(fake_ecryptfs_file));
-        fake_ecryptfs_file.f_dentry = dentry;
+        fake_ecryptfs_file.f_path.dentry = dentry;
         /* Released at out_free: label */
         ecryptfs_set_file_private(&fake_ecryptfs_file,
                                   kmem_cache_alloc(ecryptfs_file_info_cache,
@@ -915,7 +878,7 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
         }
         rc = notify_change(lower_dentry, ia);
 out:
-        ecryptfs_copy_attr_all(inode, lower_inode);
+        fsstack_copy_attr_all(inode, lower_inode, NULL);
         return rc;
 }
 
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 3ede12b25933..d0541ae8faba 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -35,6 +35,7 @@
 #include <linux/pagemap.h>
 #include <linux/key.h>
 #include <linux/parser.h>
+#include <linux/fs_stack.h>
 #include "ecryptfs_kernel.h"
 
 /**
@@ -112,10 +113,10 @@ int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
                 d_add(dentry, inode);
         else
                 d_instantiate(dentry, inode);
-        ecryptfs_copy_attr_all(inode, lower_inode);
+        fsstack_copy_attr_all(inode, lower_inode, NULL);
         /* This size will be overwritten for real files w/ headers and
          * other metadata */
-        ecryptfs_copy_inode_size(inode, lower_inode);
+        fsstack_copy_inode_size(inode, lower_inode);
 out:
         return rc;
 }
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 924dd90a4cf5..06843d24f239 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -51,7 +51,7 @@ static struct page *ecryptfs_get1page(struct file *file, int index)
         struct inode *inode;
         struct address_space *mapping;
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         inode = dentry->d_inode;
         mapping = inode->i_mapping;
         page = read_cache_page(mapping, index,
@@ -84,7 +84,7 @@ int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros);
 int ecryptfs_fill_zeros(struct file *file, loff_t new_length)
 {
         int rc = 0;
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         pgoff_t old_end_page_index = 0;
         pgoff_t index = old_end_page_index;
@@ -218,7 +218,7 @@ int ecryptfs_do_readpage(struct file *file, struct page *page,
         char *lower_page_data;
         const struct address_space_operations *lower_a_ops;
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         lower_file = ecryptfs_file_to_lower(file);
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
         inode = dentry->d_inode;
@@ -275,9 +275,9 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
         int rc = 0;
         struct ecryptfs_crypt_stat *crypt_stat;
 
-        BUG_ON(!(file && file->f_dentry && file->f_dentry->d_inode));
-        crypt_stat =
-                &ecryptfs_inode_to_private(file->f_dentry->d_inode)->crypt_stat;
+        BUG_ON(!(file && file->f_path.dentry && file->f_path.dentry->d_inode));
+        crypt_stat = &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)
+                        ->crypt_stat;
         if (!crypt_stat
             || !ECRYPTFS_CHECK_FLAG(crypt_stat->flags, ECRYPTFS_ENCRYPTED)
             || ECRYPTFS_CHECK_FLAG(crypt_stat->flags, ECRYPTFS_NEW_FILE)) {
@@ -638,8 +638,8 @@ static int ecryptfs_commit_write(struct file *file, struct page *page,
         lower_inode = ecryptfs_inode_to_lower(inode);
         lower_file = ecryptfs_file_to_lower(file);
         mutex_lock(&lower_inode->i_mutex);
-        crypt_stat =
-                &ecryptfs_inode_to_private(file->f_dentry->d_inode)->crypt_stat;
+        crypt_stat = &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)
+                                ->crypt_stat;
         if (ECRYPTFS_CHECK_FLAG(crypt_stat->flags, ECRYPTFS_NEW_FILE)) {
                 ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in "
                         "crypt_stat at memory location [%p]\n", crypt_stat);
diff --git a/fs/efs/dir.c b/fs/efs/dir.c
index 17f5b2d3c16a..b46c488eefc8 100644
--- a/fs/efs/dir.c
+++ b/fs/efs/dir.c
@@ -20,7 +20,7 @@ struct inode_operations efs_dir_inode_operations = {
 };
 
 static int efs_readdir(struct file *filp, void *dirent, filldir_t filldir) {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct buffer_head *bh;
 
         struct efs_dir          *dirblock;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 88a6f8d0b88e..3ae644e7e860 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -795,8 +795,8 @@ static int ep_getfd(int *efd, struct inode **einode, struct file **efile,
                 goto eexit_4;
         dentry->d_op = &eventpollfs_dentry_operations;
         d_add(dentry, inode);
-        file->f_vfsmnt = mntget(eventpoll_mnt);
-        file->f_dentry = dentry;
+        file->f_path.mnt = mntget(eventpoll_mnt);
+        file->f_path.dentry = dentry;
         file->f_mapping = inode->i_mapping;
 
         file->f_pos = 0;
diff --git a/fs/exec.c b/fs/exec.c
index add0e03c3ea9..12d8cd461b41 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -38,6 +38,7 @@
 #include <linux/binfmts.h>
 #include <linux/swap.h>
 #include <linux/utsname.h>
+#include <linux/pid_namespace.h>
 #include <linux/module.h>
 #include <linux/namei.h>
 #include <linux/proc_fs.h>
@@ -620,8 +621,8 @@ static int de_thread(struct task_struct *tsk)
          * Reparenting needs write_lock on tasklist_lock,
          * so it is safe to do it under read_lock.
          */
-        if (unlikely(tsk->group_leader == child_reaper))
-                child_reaper = tsk;
+        if (unlikely(tsk->group_leader == child_reaper(tsk)))
+                tsk->nsproxy->pid_ns->child_reaper = tsk;
 
         zap_other_threads(tsk);
         read_unlock(&tasklist_lock);
@@ -912,7 +913,7 @@ EXPORT_SYMBOL(flush_old_exec);
 int prepare_binprm(struct linux_binprm *bprm)
 {
         int mode;
-        struct inode * inode = bprm->file->f_dentry->d_inode;
+        struct inode * inode = bprm->file->f_path.dentry->d_inode;
         int retval;
 
         mode = inode->i_mode;
@@ -922,7 +923,7 @@ int prepare_binprm(struct linux_binprm *bprm)
         bprm->e_uid = current->euid;
         bprm->e_gid = current->egid;
 
-        if(!(bprm->file->f_vfsmnt->mnt_flags & MNT_NOSUID)) {
+        if(!(bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)) {
                 /* Set-uid? */
                 if (mode & S_ISUID) {
                         current->personality &= ~PER_CLEAR_ON_SETID;
@@ -1519,10 +1520,10 @@ int do_coredump(long signr, int exit_code, struct pt_regs * regs)
                                  0600);
         if (IS_ERR(file))
                 goto fail_unlock;
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
         if (inode->i_nlink > 1)
                 goto close_fail;        /* multiple links - don't dump */
-        if (!ispipe && d_unhashed(file->f_dentry))
+        if (!ispipe && d_unhashed(file->f_path.dentry))
                 goto close_fail;
 
         /* AK: actually i see no reason to not allow this for named pipes etc.,
@@ -1533,7 +1534,7 @@ int do_coredump(long signr, int exit_code, struct pt_regs * regs)
                 goto close_fail;
         if (!file->f_op->write)
                 goto close_fail;
-        if (!ispipe && do_truncate(file->f_dentry, 0, 0, file) != 0)
+        if (!ispipe && do_truncate(file->f_path.dentry, 0, 0, file) != 0)
                 goto close_fail;
 
         retval = binfmt->core_dump(signr, regs, file);
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 3e7a84a1e509..0b02ba9642d2 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -248,7 +248,7 @@ static int
 ext2_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 = filp->f_path.dentry->d_inode;
         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 e3cf8c81507f..4b099d310712 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -90,7 +90,7 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
 #ifdef CONFIG_COMPAT
 long ext2_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int ret;
 
         /* These are just misnamed, they actually get/put from/to user an int */
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 255cef5f7420..6347c2dbdd81 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -597,8 +597,6 @@ static int ext2_check_descriptors (struct super_block * sb)
         return 1;
 }
 
-#define log2(n) ffz(~(n))
- 
 /*
  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
@@ -834,9 +832,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
         sbi->s_sbh = bh;
         sbi->s_mount_state = le16_to_cpu(es->s_state);
         sbi->s_addr_per_block_bits =
-                log2 (EXT2_ADDR_PER_BLOCK(sb));
+                ilog2 (EXT2_ADDR_PER_BLOCK(sb));
         sbi->s_desc_per_block_bits =
-                log2 (EXT2_DESC_PER_BLOCK(sb));
+                ilog2 (EXT2_DESC_PER_BLOCK(sb));
 
         if (sb->s_magic != EXT2_SUPER_MAGIC)
                 goto cantfind_ext2;
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 5a9313ecd4ef..665adee99b31 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -103,7 +103,7 @@ static int ext3_readdir(struct file * filp,
         struct ext3_dir_entry_2 *de;
         struct super_block *sb;
         int err;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int ret = 0;
 
         sb = inode->i_sb;
@@ -122,7 +122,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_dentry->d_inode)->i_flags &= ~EXT3_INDEX_FL;
+                EXT3_I(filp->f_path.dentry->d_inode)->i_flags &= ~EXT3_INDEX_FL;
         }
 #endif
         stored = 0;
@@ -402,7 +402,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block * sb;
         int error;
 
@@ -432,7 +432,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct fname *fname;
         int     ret;
 
diff --git a/fs/ext3/file.c b/fs/ext3/file.c
index e96c388047e0..881f6365c41a 100644
--- a/fs/ext3/file.c
+++ b/fs/ext3/file.c
@@ -52,7 +52,7 @@ ext3_file_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t ret;
         int err;
 
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 12daa6869572..9b8090d94e6c 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -257,7 +257,7 @@ flags_err:
 #ifdef CONFIG_COMPAT
 long ext3_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int ret;
 
         /* These are just misnamed, they actually get/put from/to user an int */
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 60d2f9dbdb00..4df39c4315e1 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -602,7 +602,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_dentry->d_inode;
+        dir = dir_file->f_path.dentry->d_inode;
         if (!(EXT3_I(dir)->i_flags & EXT3_INDEX_FL)) {
                 hinfo.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version;
                 hinfo.seed = EXT3_SB(dir->i_sb)->s_hash_seed;
@@ -613,7 +613,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_dentry->d_inode, &hinfo, frames, &err);
+        frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo, frames, &err);
         if (!frame)
                 return err;
 
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 580b8a6ca979..b34886734a44 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1347,8 +1347,6 @@ static void ext3_orphan_cleanup (struct super_block * sb,
         sb->s_flags = s_flags; /* Restore MS_RDONLY status */
 }
 
-#define log2(n) ffz(~(n))
-
 /*
  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
@@ -1597,8 +1595,8 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
         sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
         sbi->s_sbh = bh;
         sbi->s_mount_state = le16_to_cpu(es->s_state);
-        sbi->s_addr_per_block_bits = log2(EXT3_ADDR_PER_BLOCK(sb));
-        sbi->s_desc_per_block_bits = log2(EXT3_DESC_PER_BLOCK(sb));
+        sbi->s_addr_per_block_bits = ilog2(EXT3_ADDR_PER_BLOCK(sb));
+        sbi->s_desc_per_block_bits = ilog2(EXT3_DESC_PER_BLOCK(sb));
         for (i=0; i < 4; i++)
                 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
         sbi->s_def_hash_version = es->s_def_hash_version;
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index f2ed3e7fb9f5..da80368b66f0 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -103,7 +103,7 @@ static int ext4_readdir(struct file * filp,
         struct ext4_dir_entry_2 *de;
         struct super_block *sb;
         int err;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int ret = 0;
 
         sb = inode->i_sb;
@@ -122,7 +122,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_I(filp->f_dentry->d_inode)->i_flags &= ~EXT4_INDEX_FL;
+                EXT4_I(filp->f_path.dentry->d_inode)->i_flags &= ~EXT4_INDEX_FL;
         }
 #endif
         stored = 0;
@@ -402,7 +402,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block * sb;
         int error;
 
@@ -432,7 +432,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct fname *fname;
         int     ret;
 
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 0b622c0624b7..3bbc24b58785 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -52,7 +52,7 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t ret;
         int err;
 
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 1d85d4ec9598..a127cc03c9fa 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1232,7 +1232,7 @@ retry:
                                 from, to, NULL, do_journal_get_write_access);
                 if (ret)
                         /* fatal error, just put the handle and return */
-                        journal_stop(handle);
+                        ext4_journal_stop(handle);
         }
         return ret;
 
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 22a737c306c7..500567dd53b6 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -256,7 +256,7 @@ flags_err:
 #ifdef CONFIG_COMPAT
 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int ret;
 
         /* These are just misnamed, they actually get/put from/to user an int */
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 859990eac504..e5a74a5ac261 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -602,7 +602,7 @@ int ext4_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_dentry->d_inode;
+        dir = dir_file->f_path.dentry->d_inode;
         if (!(EXT4_I(dir)->i_flags & EXT4_INDEX_FL)) {
                 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
                 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
@@ -613,7 +613,7 @@ int ext4_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_dentry->d_inode, &hinfo, frames, &err);
+        frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo, frames, &err);
         if (!frame)
                 return err;
 
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 69c439f44387..c16af246d245 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -579,7 +579,7 @@ parse_record:
         if (!memcmp(de->name, MSDOS_DOT, MSDOS_NAME))
                 inum = inode->i_ino;
         else if (!memcmp(de->name, MSDOS_DOTDOT, MSDOS_NAME)) {
-                inum = parent_ino(filp->f_dentry);
+                inum = parent_ino(filp->f_path.dentry);
         } else {
                 loff_t i_pos = fat_make_i_pos(sb, bh, de);
                 struct inode *tmp = fat_iget(sb, i_pos);
@@ -643,7 +643,7 @@ out:
 
 static int fat_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         return __fat_readdir(inode, filp, dirent, filldir, 0, 0);
 }
 
@@ -782,7 +782,7 @@ static long fat_compat_dir_ioctl(struct file *file, unsigned cmd,
 
         set_fs(KERNEL_DS);
         lock_kernel();
-        ret = fat_dir_ioctl(file->f_dentry->d_inode, file,
+        ret = fat_dir_ioctl(file->f_path.dentry->d_inode, file,
                             cmd, (unsigned long) &d);
         unlock_kernel();
         set_fs(oldfs);
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 0aa813d944a6..c1237b70c1fe 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -92,7 +92,7 @@ int fat_generic_ioctl(struct inode *inode, struct file *filp,
                 }
 
                 /* This MUST be done before doing anything irreversible... */
-                err = notify_change(filp->f_dentry, &ia);
+                err = notify_change(filp->f_path.dentry, &ia);
                 if (err)
                         goto up;
 
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 4740d35e52cd..2bdaef35da54 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -204,7 +204,7 @@ asmlinkage long sys_dup(unsigned int fildes)
 
 static int setfl(int fd, struct file * filp, unsigned long arg)
 {
-        struct inode * inode = filp->f_dentry->d_inode;
+        struct inode * inode = filp->f_path.dentry->d_inode;
         int error = 0;
 
         /*
diff --git a/fs/file_table.c b/fs/file_table.c
index 24f25a057d9c..4c17a18d8c10 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -152,8 +152,8 @@ EXPORT_SYMBOL(fput);
  */
 void fastcall __fput(struct file *file)
 {
-        struct dentry *dentry = file->f_dentry;
-        struct vfsmount *mnt = file->f_vfsmnt;
+        struct dentry *dentry = file->f_path.dentry;
+        struct vfsmount *mnt = file->f_path.mnt;
         struct inode *inode = dentry->d_inode;
 
         might_sleep();
@@ -176,8 +176,8 @@ void fastcall __fput(struct file *file)
                 put_write_access(inode);
         put_pid(file->f_owner.pid);
         file_kill(file);
-        file->f_dentry = NULL;
-        file->f_vfsmnt = NULL;
+        file->f_path.dentry = NULL;
+        file->f_path.mnt = NULL;
         file_free(file);
         dput(dentry);
         mntput(mnt);
@@ -271,7 +271,7 @@ int fs_may_remount_ro(struct super_block *sb)
         file_list_lock();
         list_for_each(p, &sb->s_files) {
                 struct file *file = list_entry(p, struct file, f_u.fu_list);
-                struct inode *inode = file->f_dentry->d_inode;
+                struct inode *inode = file->f_path.dentry->d_inode;
 
                 /* File with pending delete? */
                 if (inode->i_nlink == 0)
diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c
index 43886fa00a2a..3995d7fbedab 100644
--- a/fs/freevxfs/vxfs_lookup.c
+++ b/fs/freevxfs/vxfs_lookup.c
@@ -240,7 +240,7 @@ vxfs_lookup(struct inode *dip, struct dentry *dp, struct nameidata *nd)
 static int
 vxfs_readdir(struct file *fp, void *retp, filldir_t filler)
 {
-        struct inode            *ip = fp->f_dentry->d_inode;
+        struct inode            *ip = fp->f_path.dentry->d_inode;
         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 16b39c053d47..8c58bd453993 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_dentry->d_inode->i_private;
+        fc = file->f_path.dentry->d_inode->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 1cabdb229adb..40080477ceb4 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -856,7 +856,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_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
 
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 128f79c40803..1387749201b3 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -141,8 +141,8 @@ int fuse_release_common(struct inode *inode, struct file *file, int isdir)
                                         isdir ? FUSE_RELEASEDIR : FUSE_RELEASE);
 
                 /* Hold vfsmount and dentry until release is finished */
-                req->vfsmount = mntget(file->f_vfsmnt);
-                req->dentry = dget(file->f_dentry);
+                req->vfsmount = mntget(file->f_path.mnt);
+                req->dentry = dget(file->f_path.dentry);
                 request_send_background(fc, req);
         }
 
@@ -184,7 +184,7 @@ static u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
 
 static int fuse_flush(struct file *file, fl_owner_t id)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_file *ff = file->private_data;
         struct fuse_req *req;
@@ -533,7 +533,7 @@ static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
 static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
                               size_t count, loff_t *ppos, int write)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         size_t nmax = write ? fc->max_write : fc->max_read;
         loff_t pos = *ppos;
@@ -607,7 +607,7 @@ static ssize_t fuse_direct_read(struct file *file, char __user *buf,
 static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
                                  size_t count, loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t res;
         /* Don't allow parallel writes to the same file */
         mutex_lock(&inode->i_mutex);
@@ -662,7 +662,7 @@ static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
 static void fuse_lk_fill(struct fuse_req *req, struct file *file,
                          const struct file_lock *fl, int opcode, pid_t pid)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_file *ff = file->private_data;
         struct fuse_lk_in *arg = &req->misc.lk_in;
@@ -682,7 +682,7 @@ static void fuse_lk_fill(struct fuse_req *req, struct file *file,
 
 static int fuse_getlk(struct file *file, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
         struct fuse_lk_out outarg;
@@ -707,7 +707,7 @@ static int fuse_getlk(struct file *file, struct file_lock *fl)
 
 static int fuse_setlk(struct file *file, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_req *req;
         int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
@@ -734,7 +734,7 @@ static int fuse_setlk(struct file *file, struct file_lock *fl)
 
 static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
         int err;
 
diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
index b3f1e0349ae0..faa07e4b97d0 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -247,7 +247,7 @@ static const u32 gfs2_to_fsflags[32] = {
 
 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int error;
@@ -305,7 +305,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct buffer_head *bh;
@@ -588,7 +588,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_dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
         struct gfs2_glock *gl;
         unsigned int state;
         int flags;
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 37d681b4f216..e2e0358da335 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -53,7 +53,7 @@ done:
  */
 static int hfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         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 02f5573e0349..5cb7f8fee8d6 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -102,7 +102,7 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
                 const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
+        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
 
         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
                                   offset, nr_segs, hfs_get_block, NULL);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 7e309751645f..e886ac8460d3 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -111,7 +111,7 @@ fail:
 
 static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         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 9e3675249633..75e8c4d8aac3 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -97,7 +97,7 @@ static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
                 const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
+        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
 
         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
                                   offset, nr_segs, hfsplus_get_block, NULL);
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index b6bd33ca3731..1e6fc3799876 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -35,7 +35,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_dentry->d_inode)
+#define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode)
 
 int hostfs_d_delete(struct dentry *dentry)
 {
@@ -325,7 +325,7 @@ int hostfs_readdir(struct file *file, void *ent, filldir_t filldir)
         unsigned long long next, ino;
         int error, len;
 
-        name = dentry_name(file->f_dentry, 0);
+        name = dentry_name(file->f_path.dentry, 0);
         if(name == NULL) return(-ENOMEM);
         dir = open_dir(name, &error);
         kfree(name);
@@ -366,7 +366,7 @@ int hostfs_file_open(struct inode *ino, struct file *file)
         if(w)
                 r = 1;
 
-        name = dentry_name(file->f_dentry, 0);
+        name = dentry_name(file->f_path.dentry, 0);
         if(name == NULL)
                 return(-ENOMEM);
 
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index 594f9c428fc2..6916c41d7017 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -24,7 +24,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_dentry->d_inode;
+        struct inode *i = filp->f_path.dentry->d_inode;
         struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
         struct super_block *s = i->i_sb;
 
@@ -52,7 +52,7 @@ fail:
 
 static int hpfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         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 8b94d24855f0..fb4c8915010a 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -115,7 +115,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_i(file->f_dentry->d_inode)->i_dirty = 1;
+                hpfs_i(file->f_path.dentry->d_inode)->i_dirty = 1;
         return retval;
 }
 
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs_kern.c
index 642675fc394a..afd340a45da4 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs_kern.c
@@ -221,7 +221,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_dentry->d_inode->i_fop->read;
+        read = file->f_path.dentry->d_inode->i_fop->read;
 
         if(!is_user)
                 set_fs(KERNEL_DS);
@@ -320,7 +320,7 @@ static ssize_t hppfs_write(struct file *file, const char __user *buf, size_t len
         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
         int err;
 
-        write = proc_file->f_dentry->d_inode->i_fop->write;
+        write = proc_file->f_path.dentry->d_inode->i_fop->write;
 
         proc_file->f_pos = file->f_pos;
         err = (*write)(proc_file, buf, len, &proc_file->f_pos);
@@ -464,7 +464,7 @@ static int hppfs_open(struct inode *inode, struct file *file)
         if(data == NULL)
                 goto out;
 
-        host_file = dentry_name(file->f_dentry, strlen("/rw"));
+        host_file = dentry_name(file->f_path.dentry, strlen("/rw"));
         if(host_file == NULL)
                 goto out_free2;
 
@@ -547,7 +547,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_dentry->d_inode->i_fop->llseek;
+        llseek = proc_file->f_path.dentry->d_inode->i_fop->llseek;
         if(llseek != NULL){
                 ret = (*llseek)(proc_file, off, where);
                 if(ret < 0)
@@ -591,10 +591,10 @@ static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
         struct hppfs_dirent dirent = ((struct hppfs_dirent)
                                       { .vfs_dirent     = ent,
                                         .filldir        = filldir,
-                                        .dentry         = file->f_dentry } );
+                                        .dentry         = file->f_path.dentry } );
         int err;
 
-        readdir = proc_file->f_dentry->d_inode->i_fop->readdir;
+        readdir = proc_file->f_path.dentry->d_inode->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 0706f5aac6a2..ed2c22340ad7 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -58,7 +58,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_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         loff_t len, vma_len;
         int ret;
 
@@ -774,8 +774,8 @@ struct file *hugetlb_zero_setup(size_t size)
         d_instantiate(dentry, inode);
         inode->i_size = size;
         inode->i_nlink = 0;
-        file->f_vfsmnt = mntget(hugetlbfs_vfsmount);
-        file->f_dentry = dentry;
+        file->f_path.mnt = mntget(hugetlbfs_vfsmount);
+        file->f_path.dentry = dentry;
         file->f_mapping = inode->i_mapping;
         file->f_op = &hugetlbfs_file_operations;
         file->f_mode = FMODE_WRITE | FMODE_READ;
diff --git a/fs/inode.c b/fs/inode.c
index 9ecccab7326d..d00de182ecb9 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1200,7 +1200,7 @@ EXPORT_SYMBOL(touch_atime);
 
 void file_update_time(struct file *file)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct timespec now;
         int sync_it = 0;
 
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index e1956e6f116c..55f6da55b7c0 100644
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -570,9 +570,9 @@ asmlinkage long sys_inotify_init(void)
         dev->ih = ih;
 
         filp->f_op = &inotify_fops;
-        filp->f_vfsmnt = mntget(inotify_mnt);
-        filp->f_dentry = dget(inotify_mnt->mnt_root);
-        filp->f_mapping = filp->f_dentry->d_inode->i_mapping;
+        filp->f_path.mnt = mntget(inotify_mnt);
+        filp->f_path.dentry = dget(inotify_mnt->mnt_root);
+        filp->f_mapping = filp->f_path.dentry->d_inode->i_mapping;
         filp->f_mode = FMODE_READ;
         filp->f_flags = O_RDONLY;
         filp->private_data = dev;
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 4b7660b09ac0..ff61772ceedd 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -31,7 +31,7 @@ static long do_ioctl(struct file *filp, unsigned int cmd,
                 goto out;
         } else if (filp->f_op->ioctl) {
                 lock_kernel();
-                error = filp->f_op->ioctl(filp->f_dentry->d_inode,
+                error = filp->f_op->ioctl(filp->f_path.dentry->d_inode,
                                           filp, cmd, arg);
                 unlock_kernel();
         }
@@ -45,7 +45,7 @@ static int file_ioctl(struct file *filp, unsigned int cmd,
 {
         int error;
         int block;
-        struct inode * inode = filp->f_dentry->d_inode;
+        struct inode * inode = filp->f_path.dentry->d_inode;
         int __user *p = (int __user *)arg;
 
         switch (cmd) {
@@ -137,17 +137,17 @@ int vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, unsigned lon
                         break;
 
                 case FIOQSIZE:
-                        if (S_ISDIR(filp->f_dentry->d_inode->i_mode) ||
-                            S_ISREG(filp->f_dentry->d_inode->i_mode) ||
-                            S_ISLNK(filp->f_dentry->d_inode->i_mode)) {
-                                loff_t res = inode_get_bytes(filp->f_dentry->d_inode);
+                        if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) ||
+                            S_ISREG(filp->f_path.dentry->d_inode->i_mode) ||
+                            S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) {
+                                loff_t res = inode_get_bytes(filp->f_path.dentry->d_inode);
                                 error = copy_to_user((loff_t __user *)arg, &res, sizeof(res)) ? -EFAULT : 0;
                         }
                         else
                                 error = -ENOTTY;
                         break;
                 default:
-                        if (S_ISREG(filp->f_dentry->d_inode->i_mode))
+                        if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
                                 error = file_ioctl(filp, cmd, arg);
                         else
                                 error = do_ioctl(filp, cmd, arg);
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index 731816332b12..6bbbdb53581d 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -42,7 +42,7 @@ static struct semaphore zisofs_zlib_semaphore;
  */
 static int zisofs_readpage(struct file *file, struct page *page)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct address_space *mapping = inode->i_mapping;
         unsigned int maxpage, xpage, fpage, blockindex;
         unsigned long offset;
diff --git a/fs/isofs/dir.c b/fs/isofs/dir.c
index 27e276987fd2..4af2548f97a9 100644
--- a/fs/isofs/dir.c
+++ b/fs/isofs/dir.c
@@ -183,7 +183,7 @@ static int do_isofs_readdir(struct inode *inode, struct file *filp,
 
                 /* Handle the case of the '..' directory */
                 if (de->name_len[0] == 1 && de->name[0] == 1) {
-                        inode_number = parent_ino(filp->f_dentry);
+                        inode_number = parent_ino(filp->f_path.dentry);
                         if (filldir(dirent, "..", 2, filp->f_pos, inode_number, DT_DIR) < 0)
                                 break;
                         filp->f_pos += de_len;
@@ -255,8 +255,7 @@ static int isofs_readdir(struct file *filp,
         int result;
         char * tmpname;
         struct iso_directory_record * tmpde;
-        struct inode *inode = filp->f_dentry->d_inode;
-
+        struct inode *inode = filp->f_path.dentry->d_inode;
 
         tmpname = (char *)__get_free_page(GFP_KERNEL);
         if (tmpname == NULL)
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 9f15bce92022..7b40c69f44eb 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -566,7 +566,7 @@ static int
 jffs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         struct jffs_file *f;
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct jffs_control *c = (struct jffs_control *)inode->i_sb->s_fs_info;
         int j;
@@ -1372,7 +1372,7 @@ jffs_file_write(struct file *filp, const char *buf, size_t count,
         struct jffs_control *c;
         struct jffs_file *f;
         struct jffs_node *node;
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int recoverable = 0;
         size_t written = 0;
@@ -1380,7 +1380,7 @@ jffs_file_write(struct file *filp, const char *buf, size_t count,
         loff_t pos = *ppos;
         int err;
 
-        inode = filp->f_dentry->d_inode;
+        inode = filp->f_path.dentry->d_inode;
 
         D2(printk("***jffs_file_write(): inode: 0x%p (ino: %lu), "
                   "filp: 0x%p, buf: 0x%p, count: %d\n",
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 9def6adf4a5d..da6034d50718 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -123,11 +123,11 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
         struct jffs2_inode_info *f;
         struct jffs2_sb_info *c;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct jffs2_full_dirent *fd;
         unsigned long offset, curofs;
 
-        D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_dentry->d_inode->i_ino));
+        D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_path.dentry->d_inode->i_ino));
 
         f = JFFS2_INODE_INFO(inode);
         c = JFFS2_SB_INFO(inode->i_sb);
@@ -141,7 +141,7 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 offset++;
         }
         if (offset == 1) {
-                unsigned long pino = parent_ino(filp->f_dentry);
+                unsigned long pino = parent_ino(filp->f_path.dentry);
                 D1(printk(KERN_DEBUG "Dirent 1: \"..\", ino #%lu\n", pino));
                 if (filldir(dirent, "..", 2, 1, pino, DT_DIR) < 0)
                         goto out;
diff --git a/fs/jfs/jfs_dtree.c b/fs/jfs/jfs_dtree.c
index ecb2216d881c..47bc0b5d1324 100644
--- a/fs/jfs/jfs_dtree.c
+++ b/fs/jfs/jfs_dtree.c
@@ -3009,7 +3009,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_dentry->d_inode;
+        struct inode *ip = filp->f_path.dentry->d_inode;
         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/libfs.c b/fs/libfs.c
index bd08e0e64a8c..503898d5c4a7 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -63,7 +63,7 @@ int dcache_dir_open(struct inode *inode, struct file *file)
 {
         static struct qstr cursor_name = {.len = 1, .name = "."};
 
-        file->private_data = d_alloc(file->f_dentry, &cursor_name);
+        file->private_data = d_alloc(file->f_path.dentry, &cursor_name);
 
         return file->private_data ? 0 : -ENOMEM;
 }
@@ -76,7 +76,7 @@ int dcache_dir_close(struct inode *inode, struct file *file)
 
 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 {
-        mutex_lock(&file->f_dentry->d_inode->i_mutex);
+        mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
         switch (origin) {
                 case 1:
                         offset += file->f_pos;
@@ -84,7 +84,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -96,8 +96,8 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 
                         spin_lock(&dcache_lock);
                         list_del(&cursor->d_u.d_child);
-                        p = file->f_dentry->d_subdirs.next;
-                        while (n && p != &file->f_dentry->d_subdirs) {
+                        p = file->f_path.dentry->d_subdirs.next;
+                        while (n && p != &file->f_path.dentry->d_subdirs) {
                                 struct dentry *next;
                                 next = list_entry(p, struct dentry, d_u.d_child);
                                 if (!d_unhashed(next) && next->d_inode)
@@ -108,7 +108,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
                         spin_unlock(&dcache_lock);
                 }
         }
-        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
         return offset;
 }
 
@@ -126,7 +126,7 @@ static inline unsigned char dt_type(struct inode *inode)
 
 int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct dentry *cursor = filp->private_data;
         struct list_head *p, *q = &cursor->d_u.d_child;
         ino_t ino;
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index b85a0ad2cfb6..92681c9e9b20 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -126,7 +126,7 @@ __be32 nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *lock
                         continue;
                 if (!nlm_cmp_addr(&block->b_host->h_addr, addr))
                         continue;
-                if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_dentry->d_inode) ,fh) != 0)
+                if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_path.dentry->d_inode) ,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 497c3cd59d52..80a1a6dccc8f 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -129,7 +129,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl)
 
         nlmclnt_next_cookie(&argp->cookie);
         argp->state   = nsm_local_state;
-        memcpy(&lock->fh, NFS_FH(fl->fl_file->f_dentry->d_inode), sizeof(struct nfs_fh));
+        memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), 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 7e219b938552..5c054b20fd5e 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -343,8 +343,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_dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_dentry->d_inode->i_ino,
+                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
+                                file->f_file->f_path.dentry->d_inode->i_ino,
                                 lock->fl.fl_type, lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end,
@@ -420,8 +420,8 @@ nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
                                        struct nlm_lock *conflock)
 {
         dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
-                                file->f_file->f_dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_dentry->d_inode->i_ino,
+                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
+                                file->f_file->f_path.dentry->d_inode->i_ino,
                                 lock->fl.fl_type,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
@@ -454,8 +454,8 @@ nlmsvc_unlock(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_dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_dentry->d_inode->i_ino,
+                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
+                                file->f_file->f_path.dentry->d_inode->i_ino,
                                 lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
@@ -483,8 +483,8 @@ nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
         int status = 0;
 
         dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
-                                file->f_file->f_dentry->d_inode->i_sb->s_id,
-                                file->f_file->f_dentry->d_inode->i_ino,
+                                file->f_file->f_path.dentry->d_inode->i_sb->s_id,
+                                file->f_file->f_path.dentry->d_inode->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 e83024e16042..c0df00c74ce3 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -43,7 +43,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_dentry->d_inode;
+        struct inode *inode = file->f_file->f_path.dentry->d_inode;
 
         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 1cb0c57fedbd..52a81005dab4 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -321,7 +321,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_dentry->d_inode);
+                start = i_size_read(filp->f_path.dentry->d_inode);
                 break;
         default:
                 return -EINVAL;
@@ -371,7 +371,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_dentry->d_inode);
+                start = i_size_read(filp->f_path.dentry->d_inode);
                 break;
         default:
                 return -EINVAL;
@@ -672,7 +672,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl,
         struct file_lock *cfl;
 
         lock_kernel();
-        for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
+        for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
                 if (!IS_POSIX(cfl))
                         continue;
                 if (posix_locks_conflict(cfl, fl))
@@ -734,7 +734,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_dentry->d_inode;
+        struct inode * inode = filp->f_path.dentry->d_inode;
         int error = 0;
         int found = 0;
 
@@ -1018,7 +1018,7 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
  */
 int posix_lock_file(struct file *filp, struct file_lock *fl)
 {
-        return __posix_lock_file_conf(filp->f_dentry->d_inode, fl, NULL);
+        return __posix_lock_file_conf(filp->f_path.dentry->d_inode, fl, NULL);
 }
 EXPORT_SYMBOL(posix_lock_file);
 
@@ -1033,7 +1033,7 @@ EXPORT_SYMBOL(posix_lock_file);
 int posix_lock_file_conf(struct file *filp, struct file_lock *fl,
                         struct file_lock *conflock)
 {
-        return __posix_lock_file_conf(filp->f_dentry->d_inode, fl, conflock);
+        return __posix_lock_file_conf(filp->f_path.dentry->d_inode, fl, conflock);
 }
 EXPORT_SYMBOL(posix_lock_file_conf);
 
@@ -1333,8 +1333,8 @@ int fcntl_getlease(struct file *filp)
         int type = F_UNLCK;
 
         lock_kernel();
-        time_out_leases(filp->f_dentry->d_inode);
-        for (fl = filp->f_dentry->d_inode->i_flock; fl && IS_LEASE(fl);
+        time_out_leases(filp->f_path.dentry->d_inode);
+        for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl);
                         fl = fl->fl_next) {
                 if (fl->fl_file == filp) {
                         type = fl->fl_type & ~F_INPROGRESS;
@@ -1359,7 +1359,7 @@ int fcntl_getlease(struct file *filp)
 static int __setlease(struct file *filp, long arg, struct file_lock **flp)
 {
         struct file_lock *fl, **before, **my_before = NULL, *lease;
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int error, rdlease_count = 0, wrlease_count = 0;
 
@@ -1448,7 +1448,7 @@ out:
 
 int setlease(struct file *filp, long arg, struct file_lock **lease)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int error;
 
@@ -1482,7 +1482,7 @@ EXPORT_SYMBOL(setlease);
 int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 {
         struct file_lock fl, *flp = &fl;
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int error;
 
@@ -1692,7 +1692,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_dentry->d_inode;
+        inode = filp->f_path.dentry->d_inode;
 
         /* Don't allow mandatory locks on files that may be memory mapped
          * and shared.
@@ -1835,7 +1835,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_dentry->d_inode;
+        inode = filp->f_path.dentry->d_inode;
 
         /* Don't allow mandatory locks on files that may be memory mapped
          * and shared.
@@ -1922,7 +1922,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_dentry->d_inode->i_flock)
+        if (!filp->f_path.dentry->d_inode->i_flock)
                 return;
 
         lock.fl_type = F_UNLCK;
@@ -1951,7 +1951,7 @@ EXPORT_SYMBOL(locks_remove_posix);
  */
 void locks_remove_flock(struct file *filp)
 {
-        struct inode * inode = filp->f_dentry->d_inode; 
+        struct inode * inode = filp->f_path.dentry->d_inode;
         struct file_lock *fl;
         struct file_lock **before;
 
@@ -2020,7 +2020,7 @@ static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
         struct inode *inode = NULL;
 
         if (fl->fl_file != NULL)
-                inode = fl->fl_file->f_dentry->d_inode;
+                inode = fl->fl_file->f_path.dentry->d_inode;
 
         out += sprintf(out, "%d:%s ", id, pfx);
         if (IS_POSIX(fl)) {
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index 2b0a389d1987..ab782c4086f5 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -82,7 +82,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         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 db1bca26d88c..e4f108f08230 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -297,7 +297,7 @@ int vfs_permission(struct nameidata *nd, int mask)
  */
 int file_permission(struct file *file, int mask)
 {
-        return permission(file->f_dentry->d_inode, mask, NULL);
+        return permission(file->f_path.dentry->d_inode, mask, NULL);
 }
 
 /*
@@ -333,7 +333,7 @@ int get_write_access(struct inode * inode)
 
 int deny_write_access(struct file * file)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
 
         spin_lock(&inode->i_lock);
         if (atomic_read(&inode->i_writecount) > 0) {
@@ -368,7 +368,7 @@ void path_release_on_umount(struct nameidata *nd)
  */
 void release_open_intent(struct nameidata *nd)
 {
-        if (nd->intent.open.file->f_dentry == NULL)
+        if (nd->intent.open.file->f_path.dentry == NULL)
                 put_filp(nd->intent.open.file);
         else
                 fput(nd->intent.open.file);
@@ -572,11 +572,6 @@ fail:
         return PTR_ERR(link);
 }
 
-struct path {
-        struct vfsmount *mnt;
-        struct dentry *dentry;
-};
-
 static inline void dput_path(struct path *path, struct nameidata *nd)
 {
         dput(path->dentry);
@@ -1143,7 +1138,7 @@ static int fastcall do_path_lookup(int dfd, const char *name,
                 if (!file)
                         goto out_fail;
 
-                dentry = file->f_dentry;
+                dentry = file->f_path.dentry;
 
                 retval = -ENOTDIR;
                 if (!S_ISDIR(dentry->d_inode->i_mode))
@@ -1153,7 +1148,7 @@ static int fastcall do_path_lookup(int dfd, const char *name,
                 if (retval)
                         goto fput_fail;
 
-                nd->mnt = mntget(file->f_vfsmnt);
+                nd->mnt = mntget(file->f_path.mnt);
                 nd->dentry = dget(dentry);
 
                 fput_light(file, fput_needed);
diff --git a/fs/namespace.c b/fs/namespace.c
index b00ac84ebbdd..fde8553faa76 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -20,7 +20,7 @@
 #include <linux/module.h>
 #include <linux/sysfs.h>
 #include <linux/seq_file.h>
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/namei.h>
 #include <linux/security.h>
 #include <linux/mount.h>
@@ -133,10 +133,10 @@ struct vfsmount *lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
 
 static inline int check_mnt(struct vfsmount *mnt)
 {
-        return mnt->mnt_namespace == current->nsproxy->namespace;
+        return mnt->mnt_ns == current->nsproxy->mnt_ns;
 }
 
-static void touch_namespace(struct namespace *ns)
+static void touch_mnt_namespace(struct mnt_namespace *ns)
 {
         if (ns) {
                 ns->event = ++event;
@@ -144,7 +144,7 @@ static void touch_namespace(struct namespace *ns)
         }
 }
 
-static void __touch_namespace(struct namespace *ns)
+static void __touch_mnt_namespace(struct mnt_namespace *ns)
 {
         if (ns && ns->event != event) {
                 ns->event = event;
@@ -187,19 +187,19 @@ static void commit_tree(struct vfsmount *mnt)
         struct vfsmount *parent = mnt->mnt_parent;
         struct vfsmount *m;
         LIST_HEAD(head);
-        struct namespace *n = parent->mnt_namespace;
+        struct mnt_namespace *n = parent->mnt_ns;
 
         BUG_ON(parent == mnt);
 
         list_add_tail(&head, &mnt->mnt_list);
         list_for_each_entry(m, &head, mnt_list)
-                m->mnt_namespace = n;
+                m->mnt_ns = n;
         list_splice(&head, n->list.prev);
 
         list_add_tail(&mnt->mnt_hash, mount_hashtable +
                                 hash(parent, mnt->mnt_mountpoint));
         list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
-        touch_namespace(n);
+        touch_mnt_namespace(n);
 }
 
 static struct vfsmount *next_mnt(struct vfsmount *p, struct vfsmount *root)
@@ -320,7 +320,7 @@ EXPORT_SYMBOL(mnt_unpin);
 /* iterator */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
-        struct namespace *n = m->private;
+        struct mnt_namespace *n = m->private;
         struct list_head *p;
         loff_t l = *pos;
 
@@ -333,7 +333,7 @@ static void *m_start(struct seq_file *m, loff_t *pos)
 
 static void *m_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct namespace *n = m->private;
+        struct mnt_namespace *n = m->private;
         struct list_head *p = ((struct vfsmount *)v)->mnt_list.next;
         (*pos)++;
         return p == &n->list ? NULL : list_entry(p, struct vfsmount, mnt_list);
@@ -526,8 +526,8 @@ void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
         list_for_each_entry(p, kill, mnt_hash) {
                 list_del_init(&p->mnt_expire);
                 list_del_init(&p->mnt_list);
-                __touch_namespace(p->mnt_namespace);
-                p->mnt_namespace = NULL;
+                __touch_mnt_namespace(p->mnt_ns);
+                p->mnt_ns = NULL;
                 list_del_init(&p->mnt_child);
                 if (p->mnt_parent != p)
                         p->mnt_mountpoint->d_mounted--;
@@ -830,7 +830,7 @@ static int attach_recursive_mnt(struct vfsmount *source_mnt,
         if (parent_nd) {
                 detach_mnt(source_mnt, parent_nd);
                 attach_mnt(source_mnt, nd);
-                touch_namespace(current->nsproxy->namespace);
+                touch_mnt_namespace(current->nsproxy->mnt_ns);
         } else {
                 mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
                 commit_tree(source_mnt);
@@ -1145,9 +1145,9 @@ static void expire_mount(struct vfsmount *mnt, struct list_head *mounts,
          */
         if (!propagate_mount_busy(mnt, 2)) {
                 /* delete from the namespace */
-                touch_namespace(mnt->mnt_namespace);
+                touch_mnt_namespace(mnt->mnt_ns);
                 list_del_init(&mnt->mnt_list);
-                mnt->mnt_namespace = NULL;
+                mnt->mnt_ns = NULL;
                 umount_tree(mnt, 1, umounts);
                 spin_unlock(&vfsmount_lock);
         } else {
@@ -1168,7 +1168,7 @@ static void expire_mount(struct vfsmount *mnt, struct list_head *mounts,
  */
 static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts)
 {
-        struct namespace *namespace;
+        struct mnt_namespace *ns;
         struct vfsmount *mnt;
 
         while (!list_empty(graveyard)) {
@@ -1178,10 +1178,10 @@ static void expire_mount_list(struct list_head *graveyard, struct list_head *mou
 
                 /* don't do anything if the namespace is dead - all the
                  * vfsmounts from it are going away anyway */
-                namespace = mnt->mnt_namespace;
-                if (!namespace || !namespace->root)
+                ns = mnt->mnt_ns;
+                if (!ns || !ns->root)
                         continue;
-                get_namespace(namespace);
+                get_mnt_ns(ns);
 
                 spin_unlock(&vfsmount_lock);
                 down_write(&namespace_sem);
@@ -1189,7 +1189,7 @@ static void expire_mount_list(struct list_head *graveyard, struct list_head *mou
                 up_write(&namespace_sem);
                 release_mounts(&umounts);
                 mntput(mnt);
-                put_namespace(namespace);
+                put_mnt_ns(ns);
                 spin_lock(&vfsmount_lock);
         }
 }
@@ -1439,14 +1439,15 @@ dput_out:
  * Allocate a new namespace structure and populate it with contents
  * copied from the namespace of the passed in task structure.
  */
-struct namespace *dup_namespace(struct task_struct *tsk, struct fs_struct *fs)
+struct mnt_namespace *dup_mnt_ns(struct task_struct *tsk,
+                struct fs_struct *fs)
 {
-        struct namespace *namespace = tsk->nsproxy->namespace;
-        struct namespace *new_ns;
+        struct mnt_namespace *mnt_ns = tsk->nsproxy->mnt_ns;
+        struct mnt_namespace *new_ns;
         struct vfsmount *rootmnt = NULL, *pwdmnt = NULL, *altrootmnt = NULL;
         struct vfsmount *p, *q;
 
-        new_ns = kmalloc(sizeof(struct namespace), GFP_KERNEL);
+        new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
         if (!new_ns)
                 return NULL;
 
@@ -1457,7 +1458,7 @@ struct namespace *dup_namespace(struct task_struct *tsk, struct fs_struct *fs)
 
         down_write(&namespace_sem);
         /* First pass: copy the tree topology */
-        new_ns->root = copy_tree(namespace->root, namespace->root->mnt_root,
+        new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root,
                                         CL_COPY_ALL | CL_EXPIRE);
         if (!new_ns->root) {
                 up_write(&namespace_sem);
@@ -1473,10 +1474,10 @@ struct namespace *dup_namespace(struct task_struct *tsk, struct fs_struct *fs)
          * as belonging to new namespace.  We have already acquired a private
          * fs_struct, so tsk->fs->lock is not needed.
          */
-        p = namespace->root;
+        p = mnt_ns->root;
         q = new_ns->root;
         while (p) {
-                q->mnt_namespace = new_ns;
+                q->mnt_ns = new_ns;
                 if (fs) {
                         if (p == fs->rootmnt) {
                                 rootmnt = p;
@@ -1491,7 +1492,7 @@ struct namespace *dup_namespace(struct task_struct *tsk, struct fs_struct *fs)
                                 fs->altrootmnt = mntget(q);
                         }
                 }
-                p = next_mnt(p, namespace->root);
+                p = next_mnt(p, mnt_ns->root);
                 q = next_mnt(q, new_ns->root);
         }
         up_write(&namespace_sem);
@@ -1506,16 +1507,16 @@ struct namespace *dup_namespace(struct task_struct *tsk, struct fs_struct *fs)
         return new_ns;
 }
 
-int copy_namespace(int flags, struct task_struct *tsk)
+int copy_mnt_ns(int flags, struct task_struct *tsk)
 {
-        struct namespace *namespace = tsk->nsproxy->namespace;
-        struct namespace *new_ns;
+        struct mnt_namespace *ns = tsk->nsproxy->mnt_ns;
+        struct mnt_namespace *new_ns;
         int err = 0;
 
-        if (!namespace)
+        if (!ns)
                 return 0;
 
-        get_namespace(namespace);
+        get_mnt_ns(ns);
 
         if (!(flags & CLONE_NEWNS))
                 return 0;
@@ -1525,16 +1526,16 @@ int copy_namespace(int flags, struct task_struct *tsk)
                 goto out;
         }
 
-        new_ns = dup_namespace(tsk, tsk->fs);
+        new_ns = dup_mnt_ns(tsk, tsk->fs);
         if (!new_ns) {
                 err = -ENOMEM;
                 goto out;
         }
 
-        tsk->nsproxy->namespace = new_ns;
+        tsk->nsproxy->mnt_ns = new_ns;
 
 out:
-        put_namespace(namespace);
+        put_mnt_ns(ns);
         return err;
 }
 
@@ -1754,7 +1755,7 @@ asmlinkage long sys_pivot_root(const char __user * new_root,
         detach_mnt(user_nd.mnt, &root_parent);
         attach_mnt(user_nd.mnt, &old_nd);     /* mount old root on put_old */
         attach_mnt(new_nd.mnt, &root_parent); /* mount new_root on / */
-        touch_namespace(current->nsproxy->namespace);
+        touch_mnt_namespace(current->nsproxy->mnt_ns);
         spin_unlock(&vfsmount_lock);
         chroot_fs_refs(&user_nd, &new_nd);
         security_sb_post_pivotroot(&user_nd, &new_nd);
@@ -1779,27 +1780,27 @@ out3:
 static void __init init_mount_tree(void)
 {
         struct vfsmount *mnt;
-        struct namespace *namespace;
+        struct mnt_namespace *ns;
 
         mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
         if (IS_ERR(mnt))
                 panic("Can't create rootfs");
-        namespace = kmalloc(sizeof(*namespace), GFP_KERNEL);
-        if (!namespace)
+        ns = kmalloc(sizeof(*ns), GFP_KERNEL);
+        if (!ns)
                 panic("Can't allocate initial namespace");
-        atomic_set(&namespace->count, 1);
-        INIT_LIST_HEAD(&namespace->list);
-        init_waitqueue_head(&namespace->poll);
-        namespace->event = 0;
-        list_add(&mnt->mnt_list, &namespace->list);
-        namespace->root = mnt;
-        mnt->mnt_namespace = namespace;
-
-        init_task.nsproxy->namespace = namespace;
-        get_namespace(namespace);
-
-        set_fs_pwd(current->fs, namespace->root, namespace->root->mnt_root);
-        set_fs_root(current->fs, namespace->root, namespace->root->mnt_root);
+        atomic_set(&ns->count, 1);
+        INIT_LIST_HEAD(&ns->list);
+        init_waitqueue_head(&ns->poll);
+        ns->event = 0;
+        list_add(&mnt->mnt_list, &ns->list);
+        ns->root = mnt;
+        mnt->mnt_ns = ns;
+
+        init_task.nsproxy->mnt_ns = ns;
+        get_mnt_ns(ns);
+
+        set_fs_pwd(current->fs, ns->root, ns->root->mnt_root);
+        set_fs_root(current->fs, ns->root, ns->root->mnt_root);
 }
 
 void __init mnt_init(unsigned long mempages)
@@ -1860,11 +1861,11 @@ void __init mnt_init(unsigned long mempages)
         init_mount_tree();
 }
 
-void __put_namespace(struct namespace *namespace)
+void __put_mnt_ns(struct mnt_namespace *ns)
 {
-        struct vfsmount *root = namespace->root;
+        struct vfsmount *root = ns->root;
         LIST_HEAD(umount_list);
-        namespace->root = NULL;
+        ns->root = NULL;
         spin_unlock(&vfsmount_lock);
         down_write(&namespace_sem);
         spin_lock(&vfsmount_lock);
@@ -1872,5 +1873,5 @@ void __put_namespace(struct namespace *namespace)
         spin_unlock(&vfsmount_lock);
         up_write(&namespace_sem);
         release_mounts(&umount_list);
-        kfree(namespace);
+        kfree(ns);
 }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 458b3b785194..73747772c3bb 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -402,7 +402,7 @@ static time_t ncp_obtain_mtime(struct dentry *dentry)
 
 static int ncp_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct page *page = NULL;
         struct ncp_server *server = NCP_SERVER(inode);
@@ -554,7 +554,7 @@ static int
 ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                 struct ncp_cache_control *ctrl, struct ncp_entry_info *entry)
 {
-        struct dentry *newdent, *dentry = filp->f_dentry;
+        struct dentry *newdent, *dentry = filp->f_path.dentry;
         struct inode *newino, *inode = dentry->d_inode;
         struct ncp_cache_control ctl = *ctrl;
         struct qstr qname;
@@ -649,7 +649,7 @@ static void
 ncp_read_volume_list(struct file *filp, void *dirent, filldir_t filldir,
                         struct ncp_cache_control *ctl)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct ncp_server *server = NCP_SERVER(inode);
         struct ncp_volume_info info;
@@ -685,7 +685,7 @@ static void
 ncp_do_readdir(struct file *filp, void *dirent, filldir_t filldir,
                                                 struct ncp_cache_control *ctl)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *dir = dentry->d_inode;
         struct ncp_server *server = NCP_SERVER(dir);
         struct nw_search_sequence seq;
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index df37524b85db..b91fea03b1c3 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -101,7 +101,7 @@ out:
 static ssize_t
 ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         size_t already_read = 0;
         off_t pos;
@@ -182,7 +182,7 @@ outrel:
 static ssize_t
 ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         size_t already_written = 0;
         off_t pos;
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index fae53243bb92..47462ac94474 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -471,7 +471,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_dentry->d_inode;
+        sock_inode = ncp_filp->f_path.dentry->d_inode;
         if (!S_ISSOCK(sock_inode->i_mode))
                 goto out_fput;
         sock = SOCKET_I(sock_inode);
@@ -504,7 +504,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
                 if (!server->info_filp)
                         goto out_fput;
                 error = -ENOTSOCK;
-                sock_inode = server->info_filp->f_dentry->d_inode;
+                sock_inode = server->info_filp->f_path.dentry->d_inode;
                 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 589d1eac55c1..8843a83d4ef0 100644
--- a/fs/ncpfs/ioctl.c
+++ b/fs/ncpfs/ioctl.c
@@ -35,7 +35,7 @@ static int
 ncp_get_fs_info(struct ncp_server * server, struct file *file,
                 struct ncp_fs_info __user *arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct ncp_fs_info info;
 
         if ((file_permission(file, MAY_WRITE) != 0)
@@ -65,7 +65,7 @@ static int
 ncp_get_fs_info_v2(struct ncp_server * server, struct file *file,
                    struct ncp_fs_info_v2 __user * arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct ncp_fs_info_v2 info2;
 
         if ((file_permission(file, MAY_WRITE) != 0)
@@ -136,7 +136,7 @@ static int
 ncp_get_compat_fs_info_v2(struct ncp_server * server, struct file *file,
                    struct compat_ncp_fs_info_v2 __user * arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct compat_ncp_fs_info_v2 info2;
 
         if ((file_permission(file, MAY_WRITE) != 0)
@@ -824,7 +824,7 @@ outrel:
 #ifdef CONFIG_COMPAT
 long ncp_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int ret;
 
         lock_kernel();
diff --git a/fs/ncpfs/mmap.c b/fs/ncpfs/mmap.c
index e7d5a3097fe6..70a69115500f 100644
--- a/fs/ncpfs/mmap.c
+++ b/fs/ncpfs/mmap.c
@@ -29,7 +29,7 @@ static struct page* ncp_file_mmap_nopage(struct vm_area_struct *area,
                                      unsigned long address, int *type)
 {
         struct file *file = area->vm_file;
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct page* page;
         char *pg_addr;
@@ -106,7 +106,7 @@ static 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_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         
         DPRINTK("ncp_mmap: called\n");
 
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index b34cd16f472f..dee3d6c0f194 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -172,7 +172,7 @@ static
 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
 {
         struct file     *file = desc->file;
-        struct inode    *inode = file->f_dentry->d_inode;
+        struct inode    *inode = file->f_path.dentry->d_inode;
         struct rpc_cred *cred = nfs_file_cred(file);
         unsigned long   timestamp;
         int             error;
@@ -183,7 +183,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
 
  again:
         timestamp = jiffies;
-        error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->entry->cookie, page,
+        error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, desc->entry->cookie, page,
                                           NFS_SERVER(inode)->dtsize, desc->plus);
         if (error < 0) {
                 /* We requested READDIRPLUS, but the server doesn't grok it */
@@ -308,7 +308,7 @@ int find_dirent_index(nfs_readdir_descriptor_t *desc)
 static inline
 int find_dirent_page(nfs_readdir_descriptor_t *desc)
 {
-        struct inode    *inode = desc->file->f_dentry->d_inode;
+        struct inode    *inode = desc->file->f_path.dentry->d_inode;
         struct page     *page;
         int             status;
 
@@ -464,7 +464,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
                      filldir_t filldir)
 {
         struct file     *file = desc->file;
-        struct inode    *inode = file->f_dentry->d_inode;
+        struct inode    *inode = file->f_path.dentry->d_inode;
         struct rpc_cred *cred = nfs_file_cred(file);
         struct page     *page = NULL;
         int             status;
@@ -477,7 +477,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
                 status = -ENOMEM;
                 goto out;
         }
-        desc->error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, *desc->dir_cookie,
+        desc->error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, *desc->dir_cookie,
                                                 page,
                                                 NFS_SERVER(inode)->dtsize,
                                                 desc->plus);
@@ -516,7 +516,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
  */
 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct dentry   *dentry = filp->f_dentry;
+        struct dentry   *dentry = filp->f_path.dentry;
         struct inode    *inode = dentry->d_inode;
         nfs_readdir_descriptor_t my_desc,
                         *desc = &my_desc;
@@ -599,7 +599,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
 loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
 {
-        mutex_lock(&filp->f_dentry->d_inode->i_mutex);
+        mutex_lock(&filp->f_path.dentry->d_inode->i_mutex);
         switch (origin) {
                 case 1:
                         offset += filp->f_pos;
@@ -615,7 +615,7 @@ loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
                 ((struct nfs_open_context *)filp->private_data)->dir_cookie = 0;
         }
 out:
-        mutex_unlock(&filp->f_dentry->d_inode->i_mutex);
+        mutex_unlock(&filp->f_path.dentry->d_inode->i_mutex);
         return offset;
 }
 
@@ -1102,7 +1102,7 @@ no_open:
 
 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc)
 {
-        struct dentry *parent = desc->file->f_dentry;
+        struct dentry *parent = desc->file->f_path.dentry;
         struct inode *dir = parent->d_inode;
         struct nfs_entry *entry = desc->entry;
         struct dentry *dentry, *alias;
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index f9d678f4ae06..bd21d7fde650 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -116,7 +116,7 @@ static inline int put_dreq(struct nfs_direct_req *dreq)
 ssize_t nfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t pos, unsigned long nr_segs)
 {
         dprintk("NFS: nfs_direct_IO (%s) off/no(%Ld/%lu) EINVAL\n",
-                        iocb->ki_filp->f_dentry->d_name.name,
+                        iocb->ki_filp->f_path.dentry->d_name.name,
                         (long long) pos, nr_segs);
 
         return -EINVAL;
@@ -734,8 +734,8 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,
         size_t count = iov[0].iov_len;
 
         dprintk("nfs: direct read(%s/%s, %lu@%Ld)\n",
-                file->f_dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name,
+                file->f_path.dentry->d_parent->d_name.name,
+                file->f_path.dentry->d_name.name,
                 (unsigned long) count, (long long) pos);
 
         if (nr_segs != 1)
@@ -798,8 +798,8 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,
         size_t count = iov[0].iov_len;
 
         dfprintk(VFS, "nfs: direct write(%s/%s, %lu@%Ld)\n",
-                file->f_dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name,
+                file->f_path.dentry->d_parent->d_name.name,
+                file->f_path.dentry->d_name.name,
                 (unsigned long) count, (long long) pos);
 
         if (nr_segs != 1)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 8e28bffc35a0..0dd6be346aa7 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -176,7 +176,7 @@ static int
 nfs_file_flush(struct file *file, fl_owner_t id)
 {
         struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
-        struct inode    *inode = file->f_dentry->d_inode;
+        struct inode    *inode = file->f_path.dentry->d_inode;
         int             status;
 
         dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
@@ -201,7 +201,7 @@ static ssize_t
 nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
-        struct dentry * dentry = iocb->ki_filp->f_dentry;
+        struct dentry * dentry = iocb->ki_filp->f_path.dentry;
         struct inode * inode = dentry->d_inode;
         ssize_t result;
         size_t count = iov_length(iov, nr_segs);
@@ -226,7 +226,7 @@ static ssize_t
 nfs_file_sendfile(struct file *filp, loff_t *ppos, size_t count,
                 read_actor_t actor, void *target)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         ssize_t res;
 
@@ -243,7 +243,7 @@ nfs_file_sendfile(struct file *filp, loff_t *ppos, size_t count,
 static int
 nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int     status;
 
@@ -343,7 +343,7 @@ const struct address_space_operations nfs_file_aops = {
 static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos)
 {
-        struct dentry * dentry = iocb->ki_filp->f_dentry;
+        struct dentry * dentry = iocb->ki_filp->f_path.dentry;
         struct inode * inode = dentry->d_inode;
         ssize_t result;
         size_t count = iov_length(iov, nr_segs);
@@ -535,8 +535,8 @@ static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
 {
         dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n",
-                        filp->f_dentry->d_inode->i_sb->s_id,
-                        filp->f_dentry->d_inode->i_ino,
+                        filp->f_path.dentry->d_inode->i_sb->s_id,
+                        filp->f_path.dentry->d_inode->i_ino,
                         fl->fl_type, fl->fl_flags);
 
         /*
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 20c6f39ea38a..8391bd7a83ce 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -31,7 +31,7 @@
 #include <linux/nfs_idmap.h>
 #include <linux/vfs.h>
 #include <linux/namei.h>
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/security.h>
 
 #include <asm/system.h>
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index 82ad7110a1c0..9d4a6b2d1996 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -377,7 +377,7 @@ idmap_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
 static ssize_t
 idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 {
-        struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
+        struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
         struct idmap *idmap = (struct idmap *)rpci->private;
         struct idmap_msg im_in, *im = &idmap->idmap_im;
         struct idmap_hashtable *h;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 36680d1061b0..63e470279309 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -496,7 +496,7 @@ void put_nfs_open_context(struct nfs_open_context *ctx)
  */
 static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
         filp->private_data = get_nfs_open_context(ctx);
@@ -528,7 +528,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct nfs_open_context *ctx = (struct nfs_open_context *)filp->private_data;
 
         if (ctx) {
@@ -551,7 +551,7 @@ int nfs_open(struct inode *inode, struct file *filp)
         cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
         if (IS_ERR(cred))
                 return PTR_ERR(cred);
-        ctx = alloc_nfs_open_context(filp->f_vfsmnt, filp->f_dentry, cred);
+        ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
         put_rpccred(cred);
         if (ctx == NULL)
                 return -ENOMEM;
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 510ae524f3fd..acd8fe9762d3 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -841,7 +841,7 @@ static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
 static int
 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
-        return nlmclnt_proc(filp->f_dentry->d_inode, cmd, fl);
+        return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
 }
 
 const struct nfs_rpc_ops nfs_v3_clientops = {
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 10f5e80ca157..560536ad74a4 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -651,7 +651,7 @@ nfs_proc_commit_setup(struct nfs_write_data *data, int how)
 static int
 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
-        return nlmclnt_proc(filp->f_dentry->d_inode, cmd, fl);
+        return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
 }
 
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 594eb16879ef..345492e78643 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -754,8 +754,8 @@ int nfs_updatepage(struct file *file, struct page *page,
         nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
 
         dprintk("NFS:      nfs_updatepage(%s/%s %d@%Ld)\n",
-                file->f_dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name, count,
+                file->f_path.dentry->d_parent->d_name.name,
+                file->f_path.dentry->d_name.name, count,
                 (long long)(page_offset(page) +offset));
 
         /* If we're not using byte range locks, and we know the page
diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c
index e3eca0816986..edde5dc5f796 100644
--- a/fs/nfsd/nfs2acl.c
+++ b/fs/nfsd/nfs2acl.c
@@ -222,12 +222,10 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
 {
         struct dentry *dentry = resp->fh.fh_dentry;
         struct inode *inode = dentry->d_inode;
-        int w = nfsacl_size(
-                (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
-                (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
         struct kvec *head = rqstp->rq_res.head;
         unsigned int base;
         int n;
+        int w;
 
         if (dentry == NULL || dentry->d_inode == NULL)
                 return 0;
@@ -239,7 +237,9 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
                 return 0;
         base = (char *)p - (char *)head->iov_base;
 
-        rqstp->rq_res.page_len = w;
+        rqstp->rq_res.page_len = w = nfsacl_size(
+                (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
+                (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
         while (w > 0) {
                 if (!rqstp->rq_respages[rqstp->rq_resused++])
                         return 0;
diff --git a/fs/nfsd/nfs3acl.c b/fs/nfsd/nfs3acl.c
index fcad2895ddb0..3e3f2de82c36 100644
--- a/fs/nfsd/nfs3acl.c
+++ b/fs/nfsd/nfs3acl.c
@@ -171,19 +171,19 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
         p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh);
         if (resp->status == 0 && dentry && dentry->d_inode) {
                 struct inode *inode = dentry->d_inode;
-                int w = nfsacl_size(
-                        (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
-                        (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
                 struct kvec *head = rqstp->rq_res.head;
                 unsigned int base;
                 int n;
+                int w;
 
                 *p++ = htonl(resp->mask);
                 if (!xdr_ressize_check(rqstp, p))
                         return 0;
                 base = (char *)p - (char *)head->iov_base;
 
-                rqstp->rq_res.page_len = w;
+                rqstp->rq_res.page_len = w = nfsacl_size(
+                        (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
+                        (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
                 while (w > 0) {
                         if (!rqstp->rq_respages[rqstp->rq_resused++])
                                 return 0;
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 81b8565d3837..c7774e3a9469 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -259,7 +259,7 @@ nfsd4_remove_clid_file(struct dentry *dir, struct dentry *dentry)
                 printk("nfsd4: non-file found in client recovery directory\n");
                 return -EINVAL;
         }
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
         status = vfs_unlink(dir->d_inode, dentry);
         mutex_unlock(&dir->d_inode->i_mutex);
         return status;
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 640c92b2a9f7..b7179bd45a1e 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1310,7 +1310,7 @@ static inline void
 nfs4_file_downgrade(struct file *filp, unsigned int share_access)
 {
         if (share_access & NFS4_SHARE_ACCESS_WRITE) {
-                put_write_access(filp->f_dentry->d_inode);
+                put_write_access(filp->f_path.dentry->d_inode);
                 filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
         }
 }
@@ -1623,7 +1623,7 @@ static __be32
 nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
 {
         struct file *filp = stp->st_vfs_file;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         unsigned int share_access, new_writer;
         __be32 status;
 
@@ -1965,7 +1965,7 @@ search_close_lru(u32 st_id, int flags)
 static inline int
 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
 {
-        return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_dentry->d_inode;
+        return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode;
 }
 
 static int
@@ -2862,7 +2862,7 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
          * only the dentry:inode set.
          */
         memset(&file, 0, sizeof (struct file));
-        file.f_dentry = current_fh->fh_dentry;
+        file.f_path.dentry = current_fh->fh_dentry;
 
         status = nfs_ok;
         if (posix_test_lock(&file, &file_lock, &conflock)) {
@@ -2952,7 +2952,7 @@ static int
 check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
 {
         struct file_lock **flpp;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int status = 0;
 
         lock_kernel();
diff --git a/fs/nfsd/nfscache.c b/fs/nfsd/nfscache.c
index 6100bbe27432..f90d70475854 100644
--- a/fs/nfsd/nfscache.c
+++ b/fs/nfsd/nfscache.c
@@ -66,14 +66,13 @@ nfsd_cache_init(void)
                 printk (KERN_ERR "nfsd: cannot allocate all %d cache entries, only got %d\n",
                         CACHESIZE, CACHESIZE-i);
 
-        hash_list = kmalloc (HASHSIZE * sizeof(struct hlist_head), GFP_KERNEL);
+        hash_list = kcalloc (HASHSIZE, sizeof(struct hlist_head), GFP_KERNEL);
         if (!hash_list) {
                 nfsd_cache_shutdown();
                 printk (KERN_ERR "nfsd: cannot allocate %Zd bytes for hash list\n",
                         HASHSIZE * sizeof(struct hlist_head));
                 return;
         }
-        memset(hash_list, 0, HASHSIZE * sizeof(struct hlist_head));
 
         cache_disabled = 0;
 }
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 39aed901514b..eedf2e3990a9 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -111,7 +111,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_dentry->d_inode->i_ino;
+        ino_t ino =  file->f_path.dentry->d_inode->i_ino;
         char *data;
         ssize_t rv;
 
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index bb4d926e4487..4883d7586229 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -736,10 +736,10 @@ static int
 nfsd_sync(struct file *filp)
 {
         int err;
-        struct inode *inode = filp->f_dentry->d_inode;
-        dprintk("nfsd: sync file %s\n", filp->f_dentry->d_name.name);
+        struct inode *inode = filp->f_path.dentry->d_inode;
+        dprintk("nfsd: sync file %s\n", filp->f_path.dentry->d_name.name);
         mutex_lock(&inode->i_mutex);
-        err=nfsd_dosync(filp, filp->f_dentry, filp->f_op);
+        err=nfsd_dosync(filp, filp->f_path.dentry, filp->f_op);
         mutex_unlock(&inode->i_mutex);
 
         return err;
@@ -845,7 +845,7 @@ nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         int             host_err;
 
         err = nfserr_perm;
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
 #ifdef MSNFS
         if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
                 (!lock_may_read(inode, offset, *count)))
@@ -883,7 +883,7 @@ nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                 nfsdstats.io_read += host_err;
                 *count = host_err;
                 err = 0;
-                fsnotify_access(file->f_dentry);
+                fsnotify_access(file->f_path.dentry);
         } else 
                 err = nfserrno(host_err);
 out:
@@ -917,11 +917,11 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         err = nfserr_perm;
 
         if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
-                (!lock_may_write(file->f_dentry->d_inode, offset, cnt)))
+                (!lock_may_write(file->f_path.dentry->d_inode, offset, cnt)))
                 goto out;
 #endif
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         inode = dentry->d_inode;
         exp   = fhp->fh_export;
 
@@ -950,7 +950,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         set_fs(oldfs);
         if (host_err >= 0) {
                 nfsdstats.io_write += cnt;
-                fsnotify_modify(file->f_dentry);
+                fsnotify_modify(file->f_path.dentry);
         }
 
         /* clear setuid/setgid flag after write */
@@ -1885,28 +1885,27 @@ nfsd_racache_init(int cache_size)
                 return 0;
         if (cache_size < 2*RAPARM_HASH_SIZE)
                 cache_size = 2*RAPARM_HASH_SIZE;
-        raparml = kmalloc(sizeof(struct raparms) * cache_size, GFP_KERNEL);
-
-        if (raparml != NULL) {
-                dprintk("nfsd: allocating %d readahead buffers.\n",
-                        cache_size);
-                for (i = 0 ; i < RAPARM_HASH_SIZE ; i++) {
-                        raparm_hash[i].pb_head = NULL;
-                        spin_lock_init(&raparm_hash[i].pb_lock);
-                }
-                nperbucket = cache_size >> RAPARM_HASH_BITS;
-                memset(raparml, 0, sizeof(struct raparms) * cache_size);
-                for (i = 0; i < cache_size - 1; i++) {
-                        if (i % nperbucket == 0)
-                                raparm_hash[j++].pb_head = raparml + i;
-                        if (i % nperbucket < nperbucket-1)
-                                raparml[i].p_next = raparml + i + 1;
-                }
-        } else {
+        raparml = kcalloc(cache_size, sizeof(struct raparms), GFP_KERNEL);
+
+        if (!raparml) {
                 printk(KERN_WARNING
-                       "nfsd: Could not allocate memory read-ahead cache.\n");
+                        "nfsd: Could not allocate memory read-ahead cache.\n");
                 return -ENOMEM;
         }
+
+        dprintk("nfsd: allocating %d readahead buffers.\n", cache_size);
+        for (i = 0 ; i < RAPARM_HASH_SIZE ; i++) {
+                raparm_hash[i].pb_head = NULL;
+                spin_lock_init(&raparm_hash[i].pb_lock);
+        }
+        nperbucket = cache_size >> RAPARM_HASH_BITS;
+        for (i = 0; i < cache_size - 1; i++) {
+                if (i % nperbucket == 0)
+                        raparm_hash[j++].pb_head = raparml + i;
+                if (i % nperbucket < nperbucket-1)
+                        raparml[i].p_next = raparml + i + 1;
+        }
+
         nfsdstats.ra_size = cache_size;
         return 0;
 }
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 85c36b8ca452..8296c29ae3b8 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_dentry->d_inode;
+        struct inode *bmp_vi, *vdir = filp->f_path.dentry->d_inode;
         struct super_block *sb = vdir->i_sb;
         ntfs_inode *ndir = NTFS_I(vdir);
         ntfs_volume *vol = NTFS_SB(sb);
@@ -1136,9 +1136,9 @@ static int ntfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
         if (fpos == 1) {
                 ntfs_debug("Calling filldir for .. with len 2, fpos 0x1, "
                                 "inode 0x%lx, DT_DIR.",
-                                (unsigned long)parent_ino(filp->f_dentry));
+                                (unsigned long)parent_ino(filp->f_path.dentry));
                 rc = filldir(dirent, "..", 2, fpos,
-                                parent_ino(filp->f_dentry), DT_DIR);
+                                parent_ino(filp->f_path.dentry), DT_DIR);
                 if (rc)
                         goto done;
                 fpos++;
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index ae2fe0016d2c..076c9420c257 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -2162,7 +2162,7 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
                 goto out;
         if (!count)
                 goto out;
-        err = remove_suid(file->f_dentry);
+        err = remove_suid(file->f_path.dentry);
         if (err)
                 goto out;
         file_update_time(file);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 2f7268e81520..ef6cd30108a9 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -595,7 +595,7 @@ static void ocfs2_dio_end_io(struct kiocb *iocb,
                              ssize_t bytes,
                              void *private)
 {
-        struct inode *inode = iocb->ki_filp->f_dentry->d_inode;
+        struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 
         /* this io's submitter should not have unlocked this before we could */
         BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
@@ -611,7 +611,7 @@ static ssize_t ocfs2_direct_IO(int rw,
                                unsigned long nr_segs)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
+        struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
         int ret;
 
         mlog_entry_void();
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index baad2aa27c14..66821e178167 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -79,7 +79,7 @@ int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
         struct buffer_head * bh, * tmp;
         struct ocfs2_dir_entry * de;
         int err;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block * sb = inode->i_sb;
         unsigned int ra_sectors = 16;
         int lock_level = 0;
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 941acf14e61f..b7f0ba97a1a2 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -176,7 +176,7 @@ static ssize_t dlmfs_file_read(struct file *filp,
         int bytes_left;
         ssize_t readlen;
         char *lvb_buf;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
 
         mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
                 inode->i_ino, count, *ppos);
@@ -220,7 +220,7 @@ static ssize_t dlmfs_file_write(struct file *filp,
         int bytes_left;
         ssize_t writelen;
         char *lvb_buf;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
 
         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 8786b3c490aa..e9a82ad95c1e 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -68,7 +68,7 @@ static int ocfs2_file_open(struct inode *inode, struct file *file)
         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 
         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
-                   file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+                   file->f_path.dentry->d_name.len, file->f_path.dentry->d_name.name);
 
         spin_lock(&oi->ip_lock);
 
@@ -98,8 +98,8 @@ static int ocfs2_file_release(struct inode *inode, struct file *file)
         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 
         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
-                       file->f_dentry->d_name.len,
-                       file->f_dentry->d_name.name);
+                       file->f_path.dentry->d_name.len,
+                       file->f_path.dentry->d_name.name);
 
         spin_lock(&oi->ip_lock);
         if (!--oi->ip_open_count)
@@ -1131,13 +1131,13 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
 {
         int ret, rw_level, have_alloc_sem = 0;
         struct file *filp = iocb->ki_filp;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int appending = filp->f_flags & O_APPEND ? 1 : 0;
 
         mlog_entry("(0x%p, %u, '%.*s')\n", filp,
                    (unsigned int)nr_segs,
-                   filp->f_dentry->d_name.len,
-                   filp->f_dentry->d_name.name);
+                   filp->f_path.dentry->d_name.len,
+                   filp->f_path.dentry->d_name.name);
 
         /* happy write of zero bytes */
         if (iocb->ki_left == 0)
@@ -1159,7 +1159,7 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
                 goto out;
         }
 
-        ret = ocfs2_prepare_inode_for_write(filp->f_dentry, &iocb->ki_pos,
+        ret = ocfs2_prepare_inode_for_write(filp->f_path.dentry, &iocb->ki_pos,
                                             iocb->ki_left, appending);
         if (ret < 0) {
                 mlog_errno(ret);
@@ -1207,12 +1207,12 @@ static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
                                        unsigned int flags)
 {
         int ret;
-        struct inode *inode = out->f_dentry->d_inode;
+        struct inode *inode = out->f_path.dentry->d_inode;
 
         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
                    (unsigned int)len,
-                   out->f_dentry->d_name.len,
-                   out->f_dentry->d_name.name);
+                   out->f_path.dentry->d_name.len,
+                   out->f_path.dentry->d_name.name);
 
         inode_double_lock(inode, pipe->inode);
 
@@ -1222,7 +1222,7 @@ static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
                 goto out;
         }
 
-        ret = ocfs2_prepare_inode_for_write(out->f_dentry, ppos, len, 0);
+        ret = ocfs2_prepare_inode_for_write(out->f_path.dentry, ppos, len, 0);
         if (ret < 0) {
                 mlog_errno(ret);
                 goto out_unlock;
@@ -1247,12 +1247,12 @@ static ssize_t ocfs2_file_splice_read(struct file *in,
                                       unsigned int flags)
 {
         int ret = 0;
-        struct inode *inode = in->f_dentry->d_inode;
+        struct inode *inode = in->f_path.dentry->d_inode;
 
         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
                    (unsigned int)len,
-                   in->f_dentry->d_name.len,
-                   in->f_dentry->d_name.name);
+                   in->f_path.dentry->d_name.len,
+                   in->f_path.dentry->d_name.name);
 
         /*
          * See the comment in ocfs2_file_aio_read()
@@ -1278,12 +1278,12 @@ 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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
 
         mlog_entry("(0x%p, %u, '%.*s')\n", filp,
                    (unsigned int)nr_segs,
-                   filp->f_dentry->d_name.len,
-                   filp->f_dentry->d_name.name);
+                   filp->f_path.dentry->d_name.len,
+                   filp->f_path.dentry->d_name.name);
 
         if (!inode) {
                 ret = -EINVAL;
diff --git a/fs/open.c b/fs/open.c
index 89e0c237a636..0d94319e8681 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -165,7 +165,7 @@ asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user * buf)
         file = fget(fd);
         if (!file)
                 goto out;
-        error = vfs_statfs_native(file->f_dentry, &tmp);
+        error = vfs_statfs_native(file->f_path.dentry, &tmp);
         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                 error = -EFAULT;
         fput(file);
@@ -186,7 +186,7 @@ asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user
         file = fget(fd);
         if (!file)
                 goto out;
-        error = vfs_statfs64(file->f_dentry, &tmp);
+        error = vfs_statfs64(file->f_path.dentry, &tmp);
         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                 error = -EFAULT;
         fput(file);
@@ -302,7 +302,7 @@ static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
         if (file->f_flags & O_LARGEFILE)
                 small = 0;
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         inode = dentry->d_inode;
         error = -EINVAL;
         if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
@@ -448,8 +448,8 @@ asmlinkage long sys_fchdir(unsigned int fd)
         if (!file)
                 goto out;
 
-        dentry = file->f_dentry;
-        mnt = file->f_vfsmnt;
+        dentry = file->f_path.dentry;
+        mnt = file->f_path.mnt;
         inode = dentry->d_inode;
 
         error = -ENOTDIR;
@@ -503,7 +503,7 @@ asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
         if (!file)
                 goto out;
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         inode = dentry->d_inode;
 
         audit_inode(NULL, inode);
@@ -662,7 +662,7 @@ asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
         if (!file)
                 goto out;
 
-        dentry = file->f_dentry;
+        dentry = file->f_path.dentry;
         audit_inode(NULL, dentry->d_inode);
         error = chown_common(dentry, user, group);
         fput(file);
@@ -688,8 +688,8 @@ static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
         }
 
         f->f_mapping = inode->i_mapping;
-        f->f_dentry = dentry;
-        f->f_vfsmnt = mnt;
+        f->f_path.dentry = dentry;
+        f->f_path.mnt = mnt;
         f->f_pos = 0;
         f->f_op = fops_get(inode->i_fop);
         file_move(f, &inode->i_sb->s_files);
@@ -723,8 +723,8 @@ cleanup_all:
         if (f->f_mode & FMODE_WRITE)
                 put_write_access(inode);
         file_kill(f);
-        f->f_dentry = NULL;
-        f->f_vfsmnt = NULL;
+        f->f_path.dentry = NULL;
+        f->f_path.mnt = NULL;
 cleanup_file:
         put_filp(f);
         dput(dentry);
@@ -822,7 +822,7 @@ struct file *nameidata_to_filp(struct nameidata *nd, int flags)
         /* Pick up the filp from the open intent */
         filp = nd->intent.open.file;
         /* Has the filesystem initialised the file for us? */
-        if (filp->f_dentry == NULL)
+        if (filp->f_path.dentry == NULL)
                 filp = __dentry_open(nd->dentry, nd->mnt, flags, filp, NULL);
         else
                 path_release(nd);
@@ -965,7 +965,7 @@ long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
                                 put_unused_fd(fd);
                                 fd = PTR_ERR(f);
                         } else {
-                                fsnotify_open(f->f_dentry);
+                                fsnotify_open(f->f_path.dentry);
                                 fd_install(fd, f);
                         }
                 }
@@ -1087,6 +1087,7 @@ EXPORT_SYMBOL(sys_close);
 asmlinkage long sys_vhangup(void)
 {
         if (capable(CAP_SYS_TTY_CONFIG)) {
+                /* XXX: this needs locking */
                 tty_vhangup(current->signal->tty);
                 return 0;
         }
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 26f44e0074ec..99c0bc37ba09 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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct op_inode_info *oi = OP_I(inode);
         struct device_node *dp = oi->u.node;
         struct device_node *child;
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 1901137f4eca..3d73d94d93a7 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -276,12 +276,39 @@ static struct part_attribute part_attr_stat = {
         .show   = part_stat_read
 };
 
+#ifdef CONFIG_FAIL_MAKE_REQUEST
+
+static ssize_t part_fail_store(struct hd_struct * p,
+                               const char *buf, size_t count)
+{
+        int i;
+
+        if (count > 0 && sscanf(buf, "%d", &i) > 0)
+                p->make_it_fail = (i == 0) ? 0 : 1;
+
+        return count;
+}
+static ssize_t part_fail_read(struct hd_struct * p, char *page)
+{
+        return sprintf(page, "%d\n", p->make_it_fail);
+}
+static struct part_attribute part_attr_fail = {
+        .attr = {.name = "make-it-fail", .mode = S_IRUGO | S_IWUSR },
+        .store  = part_fail_store,
+        .show   = part_fail_read
+};
+
+#endif
+
 static struct attribute * default_attrs[] = {
         &part_attr_uevent.attr,
         &part_attr_dev.attr,
         &part_attr_start.attr,
         &part_attr_size.attr,
         &part_attr_stat.attr,
+#ifdef CONFIG_FAIL_MAKE_REQUEST
+        &part_attr_fail.attr,
+#endif
         NULL,
 };
 
diff --git a/fs/pipe.c b/fs/pipe.c
index ae36b89b1a37..f8b6bdcb879a 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -222,7 +222,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe;
         int do_wakeup;
         ssize_t ret;
@@ -335,7 +335,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe;
         ssize_t ret;
         int do_wakeup;
@@ -520,7 +520,7 @@ static int
 pipe_ioctl(struct inode *pino, struct file *filp,
            unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe;
         int count, buf, nrbufs;
 
@@ -548,7 +548,7 @@ static unsigned int
 pipe_poll(struct file *filp, poll_table *wait)
 {
         unsigned int mask;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe = inode->i_pipe;
         int nrbufs;
 
@@ -601,7 +601,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int retval;
 
         mutex_lock(&inode->i_mutex);
@@ -618,7 +618,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int retval;
 
         mutex_lock(&inode->i_mutex);
@@ -635,7 +635,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_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe = inode->i_pipe;
         int retval;
 
@@ -914,8 +914,8 @@ struct file *create_write_pipe(void)
          */
         dentry->d_flags &= ~DCACHE_UNHASHED;
         d_instantiate(dentry, inode);
-        f->f_vfsmnt = mntget(pipe_mnt);
-        f->f_dentry = dentry;
+        f->f_path.mnt = mntget(pipe_mnt);
+        f->f_path.dentry = dentry;
         f->f_mapping = inode->i_mapping;
 
         f->f_flags = O_WRONLY;
@@ -935,8 +935,8 @@ struct file *create_write_pipe(void)
 
 void free_write_pipe(struct file *f)
 {
-        mntput(f->f_vfsmnt);
-        dput(f->f_dentry);
+        mntput(f->f_path.mnt);
+        dput(f->f_path.dentry);
         put_filp(f);
 }
 
@@ -947,9 +947,9 @@ struct file *create_read_pipe(struct file *wrf)
                 return ERR_PTR(-ENFILE);
 
         /* Grab pipe from the writer */
-        f->f_vfsmnt = mntget(wrf->f_vfsmnt);
-        f->f_dentry = dget(wrf->f_dentry);
-        f->f_mapping = wrf->f_dentry->d_inode->i_mapping;
+        f->f_path.mnt = mntget(wrf->f_path.mnt);
+        f->f_path.dentry = dget(wrf->f_path.dentry);
+        f->f_mapping = wrf->f_path.dentry->d_inode->i_mapping;
 
         f->f_pos = 0;
         f->f_flags = O_RDONLY;
diff --git a/fs/pnode.c b/fs/pnode.c
index da42ee61c1df..56aacead8362 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -6,7 +6,7 @@
  *      Author : Ram Pai (linuxram@us.ibm.com)
  *
  */
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/mount.h>
 #include <linux/fs.h>
 #include "pnode.h"
diff --git a/fs/pnode.h b/fs/pnode.h
index 020e1bb60fdb..d45bd8ec36bf 100644
--- a/fs/pnode.h
+++ b/fs/pnode.h
@@ -13,7 +13,7 @@
 
 #define IS_MNT_SHARED(mnt) (mnt->mnt_flags & MNT_SHARED)
 #define IS_MNT_SLAVE(mnt) (mnt->mnt_master)
-#define IS_MNT_NEW(mnt)  (!mnt->mnt_namespace)
+#define IS_MNT_NEW(mnt)  (!mnt->mnt_ns)
 #define CLEAR_MNT_SHARED(mnt) (mnt->mnt_flags &= ~MNT_SHARED)
 #define IS_MNT_UNBINDABLE(mnt) (mnt->mnt_flags & MNT_UNBINDABLE)
 
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 25e917fb4739..70e4fab117b1 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -346,20 +346,13 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
         sigemptyset(&sigcatch);
         cutime = cstime = utime = stime = cputime_zero;
 
-        mutex_lock(&tty_mutex);
         rcu_read_lock();
         if (lock_task_sighand(task, &flags)) {
                 struct signal_struct *sig = task->signal;
-                struct tty_struct *tty = sig->tty;
-
-                if (tty) {
-                        /*
-                         * sig->tty is not stable, but tty_mutex
-                         * protects us from release_dev(tty)
-                         */
-                        barrier();
-                        tty_pgrp = tty->pgrp;
-                        tty_nr = new_encode_dev(tty_devnum(tty));
+
+                if (sig->tty) {
+                        tty_pgrp = sig->tty->pgrp;
+                        tty_nr = new_encode_dev(tty_devnum(sig->tty));
                 }
 
                 num_threads = atomic_read(&sig->count);
@@ -388,14 +381,13 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                         stime = cputime_add(stime, sig->stime);
                 }
 
-                sid = sig->session;
+                sid = signal_session(sig);
                 pgid = process_group(task);
                 ppid = rcu_dereference(task->real_parent)->tgid;
 
                 unlock_task_sighand(task, &flags);
         }
         rcu_read_unlock();
-        mutex_unlock(&tty_mutex);
 
         if (!whole || num_threads<2)
                 wchan = get_wchan(task);
diff --git a/fs/proc/base.c b/fs/proc/base.c
index b859fc749c07..fd959d5b5a80 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -59,7 +59,7 @@
 #include <linux/string.h>
 #include <linux/seq_file.h>
 #include <linux/namei.h>
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/mm.h>
 #include <linux/smp_lock.h>
 #include <linux/rcupdate.h>
@@ -365,33 +365,33 @@ struct proc_mounts {
 static int mounts_open(struct inode *inode, struct file *file)
 {
         struct task_struct *task = get_proc_task(inode);
-        struct namespace *namespace = NULL;
+        struct mnt_namespace *ns = NULL;
         struct proc_mounts *p;
         int ret = -EINVAL;
 
         if (task) {
                 task_lock(task);
-                namespace = task->nsproxy->namespace;
-                if (namespace)
-                        get_namespace(namespace);
+                ns = task->nsproxy->mnt_ns;
+                if (ns)
+                        get_mnt_ns(ns);
                 task_unlock(task);
                 put_task_struct(task);
         }
 
-        if (namespace) {
+        if (ns) {
                 ret = -ENOMEM;
                 p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
                 if (p) {
                         file->private_data = &p->m;
                         ret = seq_open(file, &mounts_op);
                         if (!ret) {
-                                p->m.private = namespace;
-                                p->event = namespace->event;
+                                p->m.private = ns;
+                                p->event = ns->event;
                                 return 0;
                         }
                         kfree(p);
                 }
-                put_namespace(namespace);
+                put_mnt_ns(ns);
         }
         return ret;
 }
@@ -399,15 +399,15 @@ static int mounts_open(struct inode *inode, struct file *file)
 static int mounts_release(struct inode *inode, struct file *file)
 {
         struct seq_file *m = file->private_data;
-        struct namespace *namespace = m->private;
-        put_namespace(namespace);
+        struct mnt_namespace *ns = m->private;
+        put_mnt_ns(ns);
         return seq_release(inode, file);
 }
 
 static unsigned mounts_poll(struct file *file, poll_table *wait)
 {
         struct proc_mounts *p = file->private_data;
-        struct namespace *ns = p->m.private;
+        struct mnt_namespace *ns = p->m.private;
         unsigned res = 0;
 
         poll_wait(file, &ns->poll, wait);
@@ -437,21 +437,21 @@ static int mountstats_open(struct inode *inode, struct file *file)
 
         if (!ret) {
                 struct seq_file *m = file->private_data;
-                struct namespace *namespace = NULL;
+                struct mnt_namespace *mnt_ns = NULL;
                 struct task_struct *task = get_proc_task(inode);
 
                 if (task) {
                         task_lock(task);
                         if (task->nsproxy)
-                                namespace = task->nsproxy->namespace;
-                        if (namespace)
-                                get_namespace(namespace);
+                                mnt_ns = task->nsproxy->mnt_ns;
+                        if (mnt_ns)
+                                get_mnt_ns(mnt_ns);
                         task_unlock(task);
                         put_task_struct(task);
                 }
 
-                if (namespace)
-                        m->private = namespace;
+                if (mnt_ns)
+                        m->private = mnt_ns;
                 else {
                         seq_release(inode, file);
                         ret = -EINVAL;
@@ -472,7 +472,7 @@ static struct file_operations proc_mountstats_operations = {
 static ssize_t proc_info_read(struct file * file, char __user * buf,
                           size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         unsigned long page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -512,7 +512,7 @@ static int mem_open(struct inode* inode, struct file* file)
 static ssize_t mem_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->f_path.dentry->d_inode);
         char *page;
         unsigned long src = *ppos;
         int ret = -ESRCH;
@@ -584,7 +584,7 @@ static ssize_t mem_write(struct file * file, const char * buf,
 {
         int copied;
         char *page;
-        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+        struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
         unsigned long dst = *ppos;
 
         copied = -ESRCH;
@@ -654,7 +654,7 @@ static struct file_operations proc_mem_operations = {
 static ssize_t oom_adjust_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->f_path.dentry->d_inode);
         char buffer[PROC_NUMBUF];
         size_t len;
         int oom_adjust;
@@ -694,7 +694,7 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
                 return -EINVAL;
         if (*end == '\n')
                 end++;
-        task = get_proc_task(file->f_dentry->d_inode);
+        task = get_proc_task(file->f_path.dentry->d_inode);
         if (!task)
                 return -ESRCH;
         if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) {
@@ -718,7 +718,7 @@ static struct file_operations proc_oom_adjust_operations = {
 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
                                   size_t count, loff_t *ppos)
 {
-        struct inode * inode = file->f_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         struct task_struct *task = get_proc_task(inode);
         ssize_t length;
         char tmpbuf[TMPBUFLEN];
@@ -734,7 +734,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_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         char *page, *tmp;
         ssize_t length;
         uid_t loginuid;
@@ -853,6 +853,65 @@ static struct file_operations proc_seccomp_operations = {
 };
 #endif /* CONFIG_SECCOMP */
 
+#ifdef CONFIG_FAULT_INJECTION
+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);
+        char buffer[PROC_NUMBUF];
+        size_t len;
+        int make_it_fail;
+        loff_t __ppos = *ppos;
+
+        if (!task)
+                return -ESRCH;
+        make_it_fail = task->make_it_fail;
+        put_task_struct(task);
+
+        len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
+        if (__ppos >= len)
+                return 0;
+        if (count > len-__ppos)
+                count = len-__ppos;
+        if (copy_to_user(buf, buffer + __ppos, count))
+                return -EFAULT;
+        *ppos = __ppos + count;
+        return count;
+}
+
+static ssize_t proc_fault_inject_write(struct file * file,
+                        const char __user * buf, size_t count, loff_t *ppos)
+{
+        struct task_struct *task;
+        char buffer[PROC_NUMBUF], *end;
+        int make_it_fail;
+
+        if (!capable(CAP_SYS_RESOURCE))
+                return -EPERM;
+        memset(buffer, 0, sizeof(buffer));
+        if (count > sizeof(buffer) - 1)
+                count = sizeof(buffer) - 1;
+        if (copy_from_user(buffer, buf, count))
+                return -EFAULT;
+        make_it_fail = simple_strtol(buffer, &end, 0);
+        if (*end == '\n')
+                end++;
+        task = get_proc_task(file->f_dentry->d_inode);
+        if (!task)
+                return -ESRCH;
+        task->make_it_fail = make_it_fail;
+        put_task_struct(task);
+        if (end - buffer == 0)
+                return -EIO;
+        return end - buffer;
+}
+
+static struct file_operations proc_fault_inject_operations = {
+        .read           = proc_fault_inject_read,
+        .write          = proc_fault_inject_write,
+};
+#endif
+
 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
         struct inode *inode = dentry->d_inode;
@@ -1078,7 +1137,7 @@ static int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
         char *name, int len,
         instantiate_t instantiate, struct task_struct *task, void *ptr)
 {
-        struct dentry *child, *dir = filp->f_dentry;
+        struct dentry *child, *dir = filp->f_path.dentry;
         struct inode *inode;
         struct qstr qname;
         ino_t ino = 0;
@@ -1157,8 +1216,8 @@ static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsm
                 spin_lock(&files->file_lock);
                 file = fcheck_files(files, fd);
                 if (file) {
-                        *mnt = mntget(file->f_vfsmnt);
-                        *dentry = dget(file->f_dentry);
+                        *mnt = mntget(file->f_path.mnt);
+                        *dentry = dget(file->f_path.dentry);
                         spin_unlock(&files->file_lock);
                         put_files_struct(files);
                         return 0;
@@ -1293,7 +1352,7 @@ static int proc_fd_fill_cache(struct file *filp, void *dirent, filldir_t filldir
 
 static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct task_struct *p = get_proc_task(inode);
         unsigned int fd, tid, ino;
@@ -1440,7 +1499,7 @@ static int proc_pident_readdir(struct file *filp,
 {
         int i;
         int pid;
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct task_struct *task = get_proc_task(inode);
         struct pid_entry *p, *last;
@@ -1496,7 +1555,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_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         unsigned long page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -1512,7 +1571,7 @@ static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
                 goto out;
 
         length = security_getprocattr(task,
-                                      (char*)file->f_dentry->d_name.name,
+                                      (char*)file->f_path.dentry->d_name.name,
                                       (void*)page, count);
         if (length >= 0)
                 length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
@@ -1526,7 +1585,7 @@ out_no_task:
 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_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         char *page;
         ssize_t length;
         struct task_struct *task = get_proc_task(inode);
@@ -1552,7 +1611,7 @@ static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
                 goto out_free;
 
         length = security_setprocattr(task,
-                                      (char*)file->f_dentry->d_name.name,
+                                      (char*)file->f_path.dentry->d_name.name,
                                       (void*)page, count);
 out_free:
         free_page((unsigned long) page);
@@ -1793,6 +1852,9 @@ static struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, loginuid),
 #endif
+#ifdef CONFIG_FAULT_INJECTION
+        REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
+#endif
 };
 
 static int proc_tgid_base_readdir(struct file * filp,
@@ -1994,7 +2056,7 @@ static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldi
 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
         unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
-        struct task_struct *reaper = get_proc_task(filp->f_dentry->d_inode);
+        struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
         struct task_struct *task;
         int tgid;
 
@@ -2068,6 +2130,9 @@ static struct pid_entry tid_base_stuff[] = {
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",  S_IWUSR|S_IRUGO, loginuid),
 #endif
+#ifdef CONFIG_FAULT_INJECTION
+        REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
+#endif
 };
 
 static int proc_tid_base_readdir(struct file * filp,
@@ -2235,7 +2300,7 @@ static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filld
 /* for the /proc/TGID/task/ directories */
 static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct task_struct *leader = get_proc_task(inode);
         struct task_struct *task;
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 4ba03009cf72..853cb877d5f3 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -52,7 +52,7 @@ static ssize_t
 proc_file_read(struct file *file, char __user *buf, size_t nbytes,
                loff_t *ppos)
 {
-        struct inode * inode = file->f_dentry->d_inode;
+        struct inode * inode = file->f_path.dentry->d_inode;
         char    *page;
         ssize_t retval=0;
         int     eof=0;
@@ -203,7 +203,7 @@ static ssize_t
 proc_file_write(struct file *file, const char __user *buffer,
                 size_t count, loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct proc_dir_entry * dp;
         
         dp = PDE(inode);
@@ -432,7 +432,7 @@ int proc_readdir(struct file * filp,
         struct proc_dir_entry * de;
         unsigned int ino;
         int i;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         int ret = 0;
 
         lock_kernel();
@@ -453,7 +453,7 @@ int proc_readdir(struct file * filp,
                         /* fall through */
                 case 1:
                         if (filldir(dirent, "..", 2, i,
-                                    parent_ino(filp->f_dentry),
+                                    parent_ino(filp->f_path.dentry),
                                     DT_DIR) < 0)
                                 goto out;
                         i++;
@@ -558,7 +558,7 @@ static void proc_kill_inodes(struct proc_dir_entry *de)
         file_list_lock();
         list_for_each(p, &sb->s_files) {
                 struct file * filp = list_entry(p, struct file, f_u.fu_list);
-                struct dentry * dentry = filp->f_dentry;
+                struct dentry * dentry = filp->f_path.dentry;
                 struct inode * inode;
                 const struct file_operations *fops;
 
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index d7dbdf9e0f49..5ec67257e5f9 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -46,7 +46,7 @@ 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_dentry->d_inode;
+                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
         }
@@ -67,7 +67,7 @@ int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma)
                 if (len < 1)
                         len = 1;
                 seq_printf(m, "%*c", len, ' ');
-                seq_path(m, file->f_vfsmnt, file->f_dentry, "");
+                seq_path(m, file->f_path.mnt, file->f_path.dentry, "");
         }
 
         seq_putc(m, '\n');
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 51815cece6f3..dc3e580d1dca 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -39,13 +39,14 @@
 #include <linux/seq_file.h>
 #include <linux/times.h>
 #include <linux/profile.h>
+#include <linux/utsname.h>
 #include <linux/blkdev.h>
 #include <linux/hugetlb.h>
 #include <linux/jiffies.h>
 #include <linux/sysrq.h>
 #include <linux/vmalloc.h>
 #include <linux/crash_dump.h>
-#include <linux/pspace.h>
+#include <linux/pid_namespace.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/io.h>
@@ -92,7 +93,7 @@ static int loadavg_read_proc(char *page, char **start, off_t off,
                 LOAD_INT(a), LOAD_FRAC(a),
                 LOAD_INT(b), LOAD_FRAC(b),
                 LOAD_INT(c), LOAD_FRAC(c),
-                nr_running(), nr_threads, init_pspace.last_pid);
+                nr_running(), nr_threads, current->nsproxy->pid_ns->last_pid);
         return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
@@ -252,8 +253,8 @@ static int version_read_proc(char *page, char **start, off_t off,
 {
         int len;
 
-        strcpy(page, linux_banner);
-        len = strlen(page);
+        len = sprintf(page, linux_banner,
+                utsname()->release, utsname()->version);
         return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 6b769afac55a..55ade0d15621 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -94,8 +94,8 @@ int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount *
         }
 
         if (vma) {
-                *mnt = mntget(vma->vm_file->f_vfsmnt);
-                *dentry = dget(vma->vm_file->f_dentry);
+                *mnt = mntget(vma->vm_file->f_path.mnt);
+                *dentry = dget(vma->vm_file->f_path.dentry);
                 result = 0;
         }
 
@@ -135,7 +135,7 @@ static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats
         int len;
 
         if (file) {
-                struct inode *inode = vma->vm_file->f_dentry->d_inode;
+                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
                 dev = inode->i_sb->s_dev;
                 ino = inode->i_ino;
         }
@@ -156,7 +156,7 @@ static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats
          */
         if (file) {
                 pad_len_spaces(m, len);
-                seq_path(m, file->f_vfsmnt, file->f_dentry, "\n");
+                seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n");
         } else {
                 const char *name = arch_vma_name(vma);
                 if (!name) {
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 091aa8e48e02..fcc5caf93f55 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -126,8 +126,8 @@ int proc_exe_link(struct inode *inode, struct dentry **dentry, struct vfsmount *
         }
 
         if (vma) {
-                *mnt = mntget(vma->vm_file->f_vfsmnt);
-                *dentry = dget(vma->vm_file->f_dentry);
+                *mnt = mntget(vma->vm_file->f_path.mnt);
+                *dentry = dget(vma->vm_file->f_path.dentry);
                 result = 0;
         }
 
diff --git a/fs/qnx4/dir.c b/fs/qnx4/dir.c
index 0d7103fa0df5..c94db1db7a71 100644
--- a/fs/qnx4/dir.c
+++ b/fs/qnx4/dir.c
@@ -22,7 +22,7 @@
 
 static int qnx4_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         unsigned int offset;
         struct buffer_head *bh;
         struct qnx4_inode_entry *de;
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index bfe5dbf1002e..61cbe1ef06b9 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -232,7 +232,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_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct page **pages = NULL, **ptr, *page;
         loff_t isize;
 
diff --git a/fs/read_write.c b/fs/read_write.c
index f792000a28e6..1d3dda4fa70c 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -64,13 +64,13 @@ loff_t remote_llseek(struct file *file, loff_t offset, int origin)
         lock_kernel();
         switch (origin) {
                 case 2:
-                        offset += i_size_read(file->f_dentry->d_inode);
+                        offset += i_size_read(file->f_path.dentry->d_inode);
                         break;
                 case 1:
                         offset += file->f_pos;
         }
         retval = -EINVAL;
-        if (offset>=0 && offset<=file->f_dentry->d_inode->i_sb->s_maxbytes) {
+        if (offset>=0 && offset<=file->f_path.dentry->d_inode->i_sb->s_maxbytes) {
                 if (offset != file->f_pos) {
                         file->f_pos = offset;
                         file->f_version = 0;
@@ -95,7 +95,7 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
         lock_kernel();
         switch (origin) {
                 case 2:
-                        offset += i_size_read(file->f_dentry->d_inode);
+                        offset += i_size_read(file->f_path.dentry->d_inode);
                         break;
                 case 1:
                         offset += file->f_pos;
@@ -203,7 +203,7 @@ int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count
         if (unlikely((pos < 0) || (loff_t) (pos + count) < 0))
                 goto Einval;
 
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
         if (unlikely(inode->i_flock && MANDATORY_LOCK(inode))) {
                 int retval = locks_mandatory_area(
                         read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
@@ -273,7 +273,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
                         else
                                 ret = do_sync_read(file, buf, count, pos);
                         if (ret > 0) {
-                                fsnotify_access(file->f_dentry);
+                                fsnotify_access(file->f_path.dentry);
                                 current->rchar += ret;
                         }
                         current->syscr++;
@@ -331,7 +331,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
                         else
                                 ret = do_sync_write(file, buf, count, pos);
                         if (ret > 0) {
-                                fsnotify_modify(file->f_dentry);
+                                fsnotify_modify(file->f_path.dentry);
                                 current->wchar += ret;
                         }
                         current->syscw++;
@@ -628,9 +628,9 @@ out:
                 kfree(iov);
         if ((ret + (type == READ)) > 0) {
                 if (type == READ)
-                        fsnotify_access(file->f_dentry);
+                        fsnotify_access(file->f_path.dentry);
                 else
-                        fsnotify_modify(file->f_dentry);
+                        fsnotify_modify(file->f_path.dentry);
         }
         return ret;
 }
@@ -722,7 +722,7 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
         if (!(in_file->f_mode & FMODE_READ))
                 goto fput_in;
         retval = -EINVAL;
-        in_inode = in_file->f_dentry->d_inode;
+        in_inode = in_file->f_path.dentry->d_inode;
         if (!in_inode)
                 goto fput_in;
         if (!in_file->f_op || !in_file->f_op->sendfile)
@@ -754,7 +754,7 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
         retval = -EINVAL;
         if (!out_file->f_op || !out_file->f_op->sendpage)
                 goto fput_out;
-        out_inode = out_file->f_dentry->d_inode;
+        out_inode = out_file->f_path.dentry->d_inode;
         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 bff3ee58e2f8..f39f5b313252 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -21,7 +21,7 @@
 
 int vfs_readdir(struct file *file, filldir_t filler, void *buf)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int res = -ENOTDIR;
         if (!file->f_op || !file->f_op->readdir)
                 goto out;
diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index e3d466a228d4..b286ccb08587 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -708,7 +708,7 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
  */
 static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
 {
-        struct path *path;
+        struct treepath *path;
         struct buffer_head *bh;
         struct item_head *ih;
         int pos_in_item;
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 657050ad7430..96a2f8889da3 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -45,7 +45,7 @@ static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
 //
 static int reiserfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
         INITIALIZE_PATH(path_to_entry);
         struct buffer_head *bh;
@@ -135,7 +135,7 @@ static int reiserfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                                 /* Ignore the .reiserfs_priv entry */
                                 if (reiserfs_xattrs(inode->i_sb) &&
                                     !old_format_only(inode->i_sb) &&
-                                    filp->f_dentry == inode->i_sb->s_root &&
+                                    filp->f_path.dentry == inode->i_sb->s_root &&
                                     REISERFS_SB(inode->i_sb)->priv_root &&
                                     REISERFS_SB(inode->i_sb)->priv_root->d_inode
                                     && deh_objectid(deh) ==
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 373d862c3f87..99b6f329ba23 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -1288,7 +1288,7 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
         loff_t pos;             // Current position in the file.
         ssize_t res;            // return value of various functions that we call.
         int err = 0;
-        struct inode *inode = file->f_dentry->d_inode;  // Inode of the file that we are writing to.
+        struct inode *inode = file->f_path.dentry->d_inode;     // Inode of the file that we are writing to.
         /* To simplify coding at this time, we store
            locked pages in array for now */
         struct page *prepared_pages[REISERFS_WRITE_PAGES_AT_A_TIME];
@@ -1335,7 +1335,7 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
         if (count == 0)
                 goto out;
 
-        res = remove_suid(file->f_dentry);
+        res = remove_suid(file->f_path.dentry);
         if (res)
                 goto out;
 
diff --git a/fs/reiserfs/fix_node.c b/fs/reiserfs/fix_node.c
index 6d0e554daa9d..0ee35c6c9b72 100644
--- a/fs/reiserfs/fix_node.c
+++ b/fs/reiserfs/fix_node.c
@@ -957,7 +957,7 @@ static int get_far_parent(struct tree_balance *p_s_tb,
 {
         struct buffer_head *p_s_parent;
         INITIALIZE_PATH(s_path_to_neighbor_father);
-        struct path *p_s_path = p_s_tb->tb_path;
+        struct treepath *p_s_path = p_s_tb->tb_path;
         struct cpu_key s_lr_father_key;
         int n_counter,
             n_position = INT_MAX,
@@ -1074,7 +1074,7 @@ static int get_far_parent(struct tree_balance *p_s_tb,
  */
 static int get_parents(struct tree_balance *p_s_tb, int n_h)
 {
-        struct path *p_s_path = p_s_tb->tb_path;
+        struct treepath *p_s_path = p_s_tb->tb_path;
         int n_position,
             n_ret_value,
             n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
@@ -1885,7 +1885,7 @@ static int check_balance(int mode,
 static int get_direct_parent(struct tree_balance *p_s_tb, int n_h)
 {
         struct buffer_head *p_s_bh;
-        struct path *p_s_path = p_s_tb->tb_path;
+        struct treepath *p_s_path = p_s_tb->tb_path;
         int n_position,
             n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
 
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 254239e6f9e3..f3d1c4a77979 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -207,7 +207,7 @@ static int file_capable(struct inode *inode, long block)
 }
 
 /*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
-                                   struct inode *inode, struct path *path)
+                                   struct inode *inode, struct treepath *path)
 {
         struct super_block *s = th->t_super;
         int len = th->t_blocks_allocated;
@@ -570,7 +570,7 @@ static inline int _allocate_block(struct reiserfs_transaction_handle *th,
                                   long block,
                                   struct inode *inode,
                                   b_blocknr_t * allocated_block_nr,
-                                  struct path *path, int flags)
+                                  struct treepath *path, int flags)
 {
         BUG_ON(!th->t_trans_id);
 
@@ -1107,7 +1107,7 @@ static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
 //
 
 // called by read_locked_inode
-static void init_inode(struct inode *inode, struct path *path)
+static void init_inode(struct inode *inode, struct treepath *path)
 {
         struct buffer_head *bh;
         struct item_head *ih;
@@ -1284,7 +1284,7 @@ static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
 /* NOTE, you must prepare the buffer head before sending it here,
 ** and then log it after the call
 */
-static void update_stat_data(struct path *path, struct inode *inode,
+static void update_stat_data(struct treepath *path, struct inode *inode,
                              loff_t size)
 {
         struct buffer_head *bh;
@@ -1653,7 +1653,7 @@ int reiserfs_write_inode(struct inode *inode, int do_sync)
    containing "." and ".." entries */
 static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
                                   struct inode *inode,
-                                  struct item_head *ih, struct path *path,
+                                  struct item_head *ih, struct treepath *path,
                                   struct inode *dir)
 {
         struct super_block *sb = th->t_super;
@@ -1712,7 +1712,7 @@ static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
    containing the body of symlink */
 static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode,    /* Inode of symlink */
                                 struct item_head *ih,
-                                struct path *path, const char *symname,
+                                struct treepath *path, const char *symname,
                                 int item_len)
 {
         struct super_block *sb = th->t_super;
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index 9c57578cb831..b484d2913c0d 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -99,7 +99,7 @@ int reiserfs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 long reiserfs_compat_ioctl(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int ret;
 
         /* These are just misnamed, they actually get/put from/to user an int */
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index abde1edc2235..23f5cd5bbf56 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -54,7 +54,7 @@ static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
 
 // comment?  maybe something like set de to point to what the path points to?
 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
-                                        struct path *path)
+                                        struct treepath *path)
 {
         de->de_bh = get_last_bh(path);
         de->de_ih = get_ih(path);
@@ -113,7 +113,7 @@ entry position in the item
 
 /* The function is NOT SCHEDULE-SAFE! */
 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
-                        struct path *path, struct reiserfs_dir_entry *de)
+                        struct treepath *path, struct reiserfs_dir_entry *de)
 {
         int retval;
 
@@ -282,7 +282,7 @@ static int linear_search_in_dir_item(struct cpu_key *key,
 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
 // FIXME: should add something like IOERROR
 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
-                               struct path *path_to_entry,
+                               struct treepath *path_to_entry,
                                struct reiserfs_dir_entry *de)
 {
         struct cpu_key key_to_search;
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index c533ec1bcaec..ecc9943202fc 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -295,7 +295,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_dentry->d_inode->i_size;
+                loff_t size = sb_info->oidmap.mapf->f_path.dentry->d_inode->i_size;
                 total_used += size / sizeof(reiserfs_oidinterval_d_t);
         }
 #endif
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index 5240abe1a709..47e7027ea39f 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -244,7 +244,7 @@ static const struct reiserfs_key MAX_KEY = {
    of the path, and going upwards.  We must check the path's validity at each step.  If the key is not in
    the path, there is no delimiting key in the tree (buffer is first or last buffer in tree), and in this
    case we return a special key, either MIN_KEY or MAX_KEY. */
-static inline const struct reiserfs_key *get_lkey(const struct path
+static inline const struct reiserfs_key *get_lkey(const struct treepath
                                                   *p_s_chk_path,
                                                   const struct super_block
                                                   *p_s_sb)
@@ -290,7 +290,7 @@ static inline const struct reiserfs_key *get_lkey(const struct path
 }
 
 /* Get delimiting key of the buffer at the path and its right neighbor. */
-inline const struct reiserfs_key *get_rkey(const struct path *p_s_chk_path,
+inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
                                            const struct super_block *p_s_sb)
 {
         int n_position, n_path_offset = p_s_chk_path->path_length;
@@ -337,7 +337,7 @@ inline const struct reiserfs_key *get_rkey(const struct path *p_s_chk_path,
    the path.  These delimiting keys are stored at least one level above that buffer in the tree. If the
    buffer is the first or last node in the tree order then one of the delimiting keys may be absent, and in
    this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */
-static inline int key_in_buffer(struct path *p_s_chk_path,      /* Path which should be checked.  */
+static inline int key_in_buffer(struct treepath *p_s_chk_path,  /* Path which should be checked.  */
                                 const struct cpu_key *p_s_key,  /* Key which should be checked.   */
                                 struct super_block *p_s_sb      /* Super block pointer.           */
     )
@@ -374,7 +374,7 @@ inline void decrement_bcount(struct buffer_head *p_s_bh)
 }
 
 /* Decrement b_count field of the all buffers in the path. */
-void decrement_counters_in_path(struct path *p_s_search_path)
+void decrement_counters_in_path(struct treepath *p_s_search_path)
 {
         int n_path_offset = p_s_search_path->path_length;
 
@@ -391,7 +391,7 @@ void decrement_counters_in_path(struct path *p_s_search_path)
         p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 }
 
-int reiserfs_check_path(struct path *p)
+int reiserfs_check_path(struct treepath *p)
 {
         RFALSE(p->path_length != ILLEGAL_PATH_ELEMENT_OFFSET,
                "path not properly relsed");
@@ -403,7 +403,7 @@ int reiserfs_check_path(struct path *p)
 **
 ** only called from fix_nodes()
 */
-void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path)
+void pathrelse_and_restore(struct super_block *s, struct treepath *p_s_search_path)
 {
         int n_path_offset = p_s_search_path->path_length;
 
@@ -421,7 +421,7 @@ void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path)
 }
 
 /* Release all buffers in the path. */
-void pathrelse(struct path *p_s_search_path)
+void pathrelse(struct treepath *p_s_search_path)
 {
         int n_path_offset = p_s_search_path->path_length;
 
@@ -602,7 +602,7 @@ static void search_by_key_reada(struct super_block *s,
    correctness of the bottom of the path */
 /* The function is NOT SCHEDULE-SAFE! */
 int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key,    /* Key to search. */
-                  struct path *p_s_search_path, /* This structure was
+                  struct treepath *p_s_search_path,/* This structure was
                                                    allocated and initialized
                                                    by the calling
                                                    function. It is filled up
@@ -813,7 +813,7 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key,	/*
 /* The function is NOT SCHEDULE-SAFE! */
 int search_for_position_by_key(struct super_block *p_s_sb,      /* Pointer to the super block.          */
                                const struct cpu_key *p_cpu_key, /* Key to search (cpu variable)         */
-                               struct path *p_s_search_path     /* Filled up by this function.          */
+                               struct treepath *p_s_search_path /* Filled up by this function.          */
     )
 {
         struct item_head *p_le_ih;      /* pointer to on-disk structure */
@@ -884,7 +884,7 @@ int search_for_position_by_key(struct super_block *p_s_sb,	/* Pointer to the sup
 }
 
 /* Compare given item and item pointed to by the path. */
-int comp_items(const struct item_head *stored_ih, const struct path *p_s_path)
+int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path)
 {
         struct buffer_head *p_s_bh;
         struct item_head *ih;
@@ -911,7 +911,7 @@ int comp_items(const struct item_head *stored_ih, const struct path *p_s_path)
 #define block_in_use(bh) (buffer_locked(bh) || (held_by_others(bh)))
 
 // prepare for delete or cut of direct item
-static inline int prepare_for_direct_item(struct path *path,
+static inline int prepare_for_direct_item(struct treepath *path,
                                           struct item_head *le_ih,
                                           struct inode *inode,
                                           loff_t new_file_length, int *cut_size)
@@ -952,7 +952,7 @@ static inline int prepare_for_direct_item(struct path *path,
         return M_CUT;           /* Cut from this item. */
 }
 
-static inline int prepare_for_direntry_item(struct path *path,
+static inline int prepare_for_direntry_item(struct treepath *path,
                                             struct item_head *le_ih,
                                             struct inode *inode,
                                             loff_t new_file_length,
@@ -987,7 +987,7 @@ static inline int prepare_for_direntry_item(struct path *path,
     In case of file truncate calculate whether this item must be deleted/truncated or last
     unformatted node of this item will be converted to a direct item.
     This function returns a determination of what balance mode the calling function should employ. */
-static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct path *p_s_path, const struct cpu_key *p_s_item_key, int *p_n_removed, /* Number of unformatted nodes which were removed
+static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct treepath *p_s_path, const struct cpu_key *p_s_item_key, int *p_n_removed,     /* Number of unformatted nodes which were removed
                                                                                                                                                                                    from end of the file. */
                                       int *p_n_cut_size, unsigned long long n_new_file_length   /* MAX_KEY_OFFSET in case of delete. */
     )
@@ -1125,7 +1125,7 @@ static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
 static void init_tb_struct(struct reiserfs_transaction_handle *th,
                            struct tree_balance *p_s_tb,
                            struct super_block *p_s_sb,
-                           struct path *p_s_path, int n_size)
+                           struct treepath *p_s_path, int n_size)
 {
 
         BUG_ON(!th->t_trans_id);
@@ -1176,7 +1176,7 @@ char head2type(struct item_head *ih)
 #endif
 
 /* Delete object item. */
-int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the deleted item. */
+int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_path,     /* Path to the deleted item. */
                          const struct cpu_key *p_s_item_key,    /* Key to search for the deleted item.  */
                          struct inode *p_s_inode,       /* inode is here just to update i_blocks and quotas */
                          struct buffer_head *p_s_un_bh)
@@ -1468,7 +1468,7 @@ static void unmap_buffers(struct page *page, loff_t pos)
 static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
                                     struct inode *p_s_inode,
                                     struct page *page,
-                                    struct path *p_s_path,
+                                    struct treepath *p_s_path,
                                     const struct cpu_key *p_s_item_key,
                                     loff_t n_new_file_size, char *p_c_mode)
 {
@@ -1503,7 +1503,7 @@ static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
    pointer being converted. Therefore we have to delete inserted
    direct item(s) */
 static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
-                                         struct inode *inode, struct path *path)
+                                         struct inode *inode, struct treepath *path)
 {
         struct cpu_key tail_key;
         int tail_len;
@@ -1545,7 +1545,7 @@ static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
 
 /* (Truncate or cut entry) or delete object item. Returns < 0 on failure */
 int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
-                           struct path *p_s_path,
+                           struct treepath *p_s_path,
                            struct cpu_key *p_s_item_key,
                            struct inode *p_s_inode,
                            struct page *page, loff_t n_new_file_size)
@@ -1920,7 +1920,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p
 
 #ifdef CONFIG_REISERFS_CHECK
 // this makes sure, that we __append__, not overwrite or add holes
-static void check_research_for_paste(struct path *path,
+static void check_research_for_paste(struct treepath *path,
                                      const struct cpu_key *p_s_key)
 {
         struct item_head *found_ih = get_ih(path);
@@ -1954,7 +1954,7 @@ static void check_research_for_paste(struct path *path,
 #endif                          /* config reiserfs check */
 
 /* Paste bytes to the existing item. Returns bytes number pasted into the item. */
-int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct path *p_s_search_path,      /* Path to the pasted item.          */
+int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_search_path,  /* Path to the pasted item.          */
                              const struct cpu_key *p_s_key,     /* Key to search for the needed item. */
                              struct inode *inode,       /* Inode item belongs to */
                              const char *p_c_body,      /* Pointer to the bytes to paste.    */
@@ -2036,7 +2036,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct path
 }
 
 /* Insert new item into the buffer at the path. */
-int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the inserteded item.         */
+int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath *p_s_path,     /* Path to the inserteded item.         */
                          const struct cpu_key *key, struct item_head *p_s_ih,   /* Pointer to the item header to insert. */
                          struct inode *inode, const char *p_c_body)
 {                               /* Pointer to the bytes to insert.      */
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 7fb5fb036f90..58ad4551a7c1 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -23,7 +23,7 @@
 #include <linux/blkdev.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/quotaops.h>
diff --git a/fs/reiserfs/tail_conversion.c b/fs/reiserfs/tail_conversion.c
index 36f108fc1cf5..f8121a1147e8 100644
--- a/fs/reiserfs/tail_conversion.c
+++ b/fs/reiserfs/tail_conversion.c
@@ -15,7 +15,7 @@
 /* path points to first direct item of the file regarless of how many of
    them are there */
 int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
-                    struct path *path, struct buffer_head *unbh,
+                    struct treepath *path, struct buffer_head *unbh,
                     loff_t tail_offset)
 {
         struct super_block *sb = inode->i_sb;
@@ -171,7 +171,7 @@ void reiserfs_unmap_buffer(struct buffer_head *bh)
    what we expect from it (number of cut bytes). But when tail remains
    in the unformatted node, we set mode to SKIP_BALANCING and unlock
    inode */
-int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_inode, struct page *page, struct path *p_s_path,  /* path to the indirect item. */
+int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_inode, struct page *page, struct treepath *p_s_path,      /* path to the indirect item. */
                     const struct cpu_key *p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
                     loff_t n_new_file_size,     /* New file size. */
                     char *p_c_mode)
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 1e4d68590178..f01389fd162e 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -274,7 +274,7 @@ static struct file *open_xa_file(const struct inode *inode, const char *name,
  */
 static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
         INITIALIZE_PATH(path_to_entry);
         struct buffer_head *bh;
@@ -420,7 +420,7 @@ static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
 static
 int xattr_readdir(struct file *file, filldir_t filler, void *buf)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int res = -ENOTDIR;
         if (!file->f_op || !file->f_op->readdir)
                 goto out;
@@ -508,7 +508,7 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
                 goto out;
         }
 
-        xinode = fp->f_dentry->d_inode;
+        xinode = fp->f_path.dentry->d_inode;
         REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
 
         /* we need to copy it off.. */
@@ -527,7 +527,7 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
         newattrs.ia_size = buffer_size;
         newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
         mutex_lock(&xinode->i_mutex);
-        err = notify_change(fp->f_dentry, &newattrs);
+        err = notify_change(fp->f_path.dentry, &newattrs);
         if (err)
                 goto out_filp;
 
@@ -626,7 +626,7 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
                 goto out;
         }
 
-        xinode = fp->f_dentry->d_inode;
+        xinode = fp->f_path.dentry->d_inode;
         isize = xinode->i_size;
         REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
 
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index c5af088d4a4c..d3e243a6f609 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -276,7 +276,7 @@ static unsigned char romfs_dtype_table[] = {
 static int
 romfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *i = filp->f_dentry->d_inode;
+        struct inode *i = filp->f_path.dentry->d_inode;
         struct romfs_inode ri;
         unsigned long offset, maxoff;
         int j, ino, nextfh;
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 10690aa401c7..0ac22af7afe5 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -269,7 +269,7 @@ EXPORT_SYMBOL(seq_lseek);
 /**
  *      seq_release -   free the structures associated with sequential file.
  *      @file: file in question
- *      @inode: file->f_dentry->d_inode
+ *      @inode: file->f_path.dentry->d_inode
  *
  *      Frees the structures associated with sequential file; can be used
  *      as ->f_op->release() if you don't have private data to destroy.
diff --git a/fs/smbfs/cache.c b/fs/smbfs/cache.c
index 74b86d9725a6..8182f0542a21 100644
--- a/fs/smbfs/cache.c
+++ b/fs/smbfs/cache.c
@@ -125,7 +125,7 @@ smb_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                struct smb_cache_control *ctrl, struct qstr *qname,
                struct smb_fattr *entry)
 {
-        struct dentry *newdent, *dentry = filp->f_dentry;
+        struct dentry *newdent, *dentry = filp->f_path.dentry;
         struct inode *newino, *inode = dentry->d_inode;
         struct smb_cache_control ctl = *ctrl;
         int valid = 0;
diff --git a/fs/smbfs/dir.c b/fs/smbfs/dir.c
index 70d9c5a37f5a..b1e58d1ac9ca 100644
--- a/fs/smbfs/dir.c
+++ b/fs/smbfs/dir.c
@@ -78,7 +78,7 @@ struct inode_operations smb_dir_inode_operations_unix =
 static int 
 smb_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct inode *dir = dentry->d_inode;
         struct smb_sb_info *server = server_from_dentry(dentry);
         union  smb_dir_cache *cache = NULL;
@@ -238,12 +238,12 @@ out:
 static int
 smb_dir_open(struct inode *dir, struct file *file)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct smb_sb_info *server;
         int error = 0;
 
         VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name);
+                file->f_path.dentry->d_name.name);
 
         /*
          * Directory timestamps in the core protocol aren't updated
diff --git a/fs/smbfs/file.c b/fs/smbfs/file.c
index 50784d13c87b..e50533a79517 100644
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
@@ -102,7 +102,7 @@ static int
 smb_readpage(struct file *file, struct page *page)
 {
         int             error;
-        struct dentry  *dentry = file->f_dentry;
+        struct dentry  *dentry = file->f_path.dentry;
 
         page_cache_get(page);
         error = smb_readpage_sync(dentry, page);
@@ -205,7 +205,7 @@ static int
 smb_updatepage(struct file *file, struct page *page, unsigned long offset,
                unsigned int count)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
 
         DEBUG1("(%s/%s %d@%lld)\n", DENTRY_PATH(dentry), count,
                 ((unsigned long long)page->index << PAGE_CACHE_SHIFT) + offset);
@@ -218,7 +218,7 @@ smb_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
                         unsigned long nr_segs, loff_t pos)
 {
         struct file * file = iocb->ki_filp;
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         ssize_t status;
 
         VERBOSE("file %s/%s, count=%lu@%lu\n", DENTRY_PATH(dentry),
@@ -243,7 +243,7 @@ out:
 static int
 smb_file_mmap(struct file * file, struct vm_area_struct * vma)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         int     status;
 
         VERBOSE("file %s/%s, address %lu - %lu\n",
@@ -264,7 +264,7 @@ static ssize_t
 smb_file_sendfile(struct file *file, loff_t *ppos,
                   size_t count, read_actor_t actor, void *target)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         ssize_t status;
 
         VERBOSE("file %s/%s, pos=%Ld, count=%d\n",
@@ -323,7 +323,7 @@ smb_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                unsigned long nr_segs, loff_t pos)
 {
         struct file * file = iocb->ki_filp;
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         ssize_t result;
 
         VERBOSE("file %s/%s, count=%lu@%lu\n",
@@ -355,7 +355,7 @@ static int
 smb_file_open(struct inode *inode, struct file * file)
 {
         int result;
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         int smb_mode = (file->f_mode & O_ACCMODE) - 1;
 
         lock_kernel();
diff --git a/fs/smbfs/proc.c b/fs/smbfs/proc.c
index 40e174db9872..a5ced9e0c6c4 100644
--- a/fs/smbfs/proc.c
+++ b/fs/smbfs/proc.c
@@ -873,7 +873,7 @@ smb_newconn(struct smb_sb_info *server, struct smb_conn_opt *opt)
         filp = fget(opt->fd);
         if (!filp)
                 goto out;
-        if (!smb_valid_socket(filp->f_dentry->d_inode))
+        if (!smb_valid_socket(filp->f_path.dentry->d_inode))
                 goto out_putf;
 
         server->sock_file = filp;
@@ -898,7 +898,7 @@ smb_newconn(struct smb_sb_info *server, struct smb_conn_opt *opt)
         /*
          * Store the server in sock user_data (Only used by sunrpc)
          */
-        sk = SOCKET_I(filp->f_dentry->d_inode)->sk;
+        sk = SOCKET_I(filp->f_path.dentry->d_inode)->sk;
         sk->sk_user_data = server;
 
         /* chain into the data_ready callback */
@@ -1939,7 +1939,7 @@ static int
 smb_proc_readdir_short(struct file *filp, void *dirent, filldir_t filldir,
                        struct smb_cache_control *ctl)
 {
-        struct dentry *dir = filp->f_dentry;
+        struct dentry *dir = filp->f_path.dentry;
         struct smb_sb_info *server = server_from_dentry(dir);
         struct qstr qname;
         struct smb_fattr fattr;
@@ -2291,7 +2291,7 @@ static int
 smb_proc_readdir_long(struct file *filp, void *dirent, filldir_t filldir,
                       struct smb_cache_control *ctl)
 {
-        struct dentry *dir = filp->f_dentry;
+        struct dentry *dir = filp->f_path.dentry;
         struct smb_sb_info *server = server_from_dentry(dir);
         struct qstr qname;
         struct smb_fattr fattr;
@@ -2859,7 +2859,7 @@ static int
 smb_proc_readdir_null(struct file *filp, void *dirent, filldir_t filldir,
                       struct smb_cache_control *ctl)
 {
-        struct smb_sb_info *server = server_from_dentry(filp->f_dentry);
+        struct smb_sb_info *server = server_from_dentry(filp->f_path.dentry);
 
         if (smb_proc_ops_wait(server) < 0)
                 return -EIO;
diff --git a/fs/smbfs/sock.c b/fs/smbfs/sock.c
index 6815b1b12b68..92ea6b2367d7 100644
--- a/fs/smbfs/sock.c
+++ b/fs/smbfs/sock.c
@@ -82,10 +82,10 @@ server_sock(struct smb_sb_info *server)
         if (server && (file = server->sock_file))
         {
 #ifdef SMBFS_PARANOIA
-                if (!smb_valid_socket(file->f_dentry->d_inode))
+                if (!smb_valid_socket(file->f_path.dentry->d_inode))
                         PARANOIA("bad socket!\n");
 #endif
-                return SOCKET_I(file->f_dentry->d_inode);
+                return SOCKET_I(file->f_path.dentry->d_inode);
         }
         return NULL;
 }
diff --git a/fs/splice.c b/fs/splice.c
index da74583a00ee..bbd0aeb3f68e 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -844,7 +844,7 @@ generic_file_splice_write_nolock(struct pipe_inode_info *pipe, struct file *out,
         ssize_t ret;
         int err;
 
-        err = remove_suid(out->f_dentry);
+        err = remove_suid(out->f_path.dentry);
         if (unlikely(err))
                 return err;
 
@@ -890,10 +890,10 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
         ssize_t ret;
         int err;
 
-        err = should_remove_suid(out->f_dentry);
+        err = should_remove_suid(out->f_path.dentry);
         if (unlikely(err)) {
                 mutex_lock(&inode->i_mutex);
-                err = __remove_suid(out->f_dentry, err);
+                err = __remove_suid(out->f_path.dentry, err);
                 mutex_unlock(&inode->i_mutex);
                 if (err)
                         return err;
@@ -1008,7 +1008,7 @@ long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
          * randomly drop data for eg socket -> socket splicing. Use the
          * piped splicing for that!
          */
-        i_mode = in->f_dentry->d_inode->i_mode;
+        i_mode = in->f_path.dentry->d_inode->i_mode;
         if (unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))
                 return -EINVAL;
 
@@ -1132,7 +1132,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
         loff_t offset, *off;
         long ret;
 
-        pipe = pipe_info(in->f_dentry->d_inode);
+        pipe = pipe_info(in->f_path.dentry->d_inode);
         if (pipe) {
                 if (off_in)
                         return -ESPIPE;
@@ -1153,7 +1153,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
                 return ret;
         }
 
-        pipe = pipe_info(out->f_dentry->d_inode);
+        pipe = pipe_info(out->f_path.dentry->d_inode);
         if (pipe) {
                 if (off_out)
                         return -ESPIPE;
@@ -1321,7 +1321,7 @@ static long do_vmsplice(struct file *file, const struct iovec __user *iov,
                 .ops = &user_page_pipe_buf_ops,
         };
 
-        pipe = pipe_info(file->f_dentry->d_inode);
+        pipe = pipe_info(file->f_path.dentry->d_inode);
         if (!pipe)
                 return -EBADF;
         if (unlikely(nr_segs > UIO_MAXIOV))
@@ -1549,8 +1549,8 @@ static int link_pipe(struct pipe_inode_info *ipipe,
 static long do_tee(struct file *in, struct file *out, size_t len,
                    unsigned int flags)
 {
-        struct pipe_inode_info *ipipe = pipe_info(in->f_dentry->d_inode);
-        struct pipe_inode_info *opipe = pipe_info(out->f_dentry->d_inode);
+        struct pipe_inode_info *ipipe = pipe_info(in->f_path.dentry->d_inode);
+        struct pipe_inode_info *opipe = pipe_info(out->f_path.dentry->d_inode);
         int ret = -EINVAL;
 
         /*
diff --git a/fs/stack.c b/fs/stack.c
new file mode 100644
index 000000000000..5ddbc34535f9
--- /dev/null
+++ b/fs/stack.c
@@ -0,0 +1,40 @@
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/fs_stack.h>
+
+/* does _NOT_ require i_mutex to be held.
+ *
+ * This function cannot be inlined since i_size_{read,write} is rather
+ * heavy-weight on 32-bit systems
+ */
+void fsstack_copy_inode_size(struct inode *dst, const struct inode *src)
+{
+        i_size_write(dst, i_size_read((struct inode *)src));
+        dst->i_blocks = src->i_blocks;
+}
+EXPORT_SYMBOL_GPL(fsstack_copy_inode_size);
+
+/* copy all attributes; get_nlinks is optional way to override the i_nlink
+ * copying
+ */
+void fsstack_copy_attr_all(struct inode *dest, const struct inode *src,
+                                int (*get_nlinks)(struct inode *))
+{
+        if (!get_nlinks)
+                dest->i_nlink = src->i_nlink;
+        else
+                dest->i_nlink = (*get_nlinks)(dest);
+
+        dest->i_mode = src->i_mode;
+        dest->i_uid = src->i_uid;
+        dest->i_gid = src->i_gid;
+        dest->i_rdev = src->i_rdev;
+        dest->i_atime = src->i_atime;
+        dest->i_mtime = src->i_mtime;
+        dest->i_ctime = src->i_ctime;
+        dest->i_blkbits = src->i_blkbits;
+        dest->i_flags = src->i_flags;
+
+        fsstack_copy_inode_size(dest, src);
+}
+EXPORT_SYMBOL_GPL(fsstack_copy_attr_all);
diff --git a/fs/stat.c b/fs/stat.c
index a0ebfc7f8a64..38a8cb2a28de 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -102,7 +102,7 @@ int vfs_fstat(unsigned int fd, struct kstat *stat)
         int error = -EBADF;
 
         if (f) {
-                error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
+                error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);
                 fput(f);
         }
         return error;
diff --git a/fs/super.c b/fs/super.c
index 84c320f6ad7e..f961e0307997 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -570,7 +570,7 @@ static void mark_files_ro(struct super_block *sb)
 
         file_list_lock();
         list_for_each_entry(f, &sb->s_files, f_u.fu_list) {
-                if (S_ISREG(f->f_dentry->d_inode->i_mode) && file_count(f))
+                if (S_ISREG(f->f_path.dentry->d_inode->i_mode) && file_count(f))
                         f->f_mode &= ~FMODE_WRITE;
         }
         file_list_unlock();
diff --git a/fs/sync.c b/fs/sync.c
index 865f32be386e..d0feff61e6aa 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -94,7 +94,7 @@ long do_fsync(struct file *file, int datasync)
          * livelocks in fsync_buffers_list().
          */
         mutex_lock(&mapping->host->i_mutex);
-        err = file->f_op->fsync(file, file->f_dentry, datasync);
+        err = file->f_op->fsync(file, file->f_path.dentry, datasync);
         if (!ret)
                 ret = err;
         mutex_unlock(&mapping->host->i_mutex);
@@ -223,7 +223,7 @@ asmlinkage long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
         if (!file)
                 goto out;
 
-        i_mode = file->f_dentry->d_inode->i_mode;
+        i_mode = file->f_path.dentry->d_inode->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 98022e41cda1..e8f540d38d48 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -35,7 +35,7 @@ static ssize_t
 read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
 {
         char *buffer = file->private_data;
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         int size = dentry->d_inode->i_size;
         loff_t offs = *off;
         int ret;
@@ -81,7 +81,7 @@ static ssize_t write(struct file * file, const char __user * userbuf,
                      size_t count, loff_t * off)
 {
         char *buffer = file->private_data;
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         int size = dentry->d_inode->i_size;
         loff_t offs = *off;
 
@@ -105,7 +105,7 @@ static ssize_t write(struct file * file, const char __user * userbuf,
 
 static int mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct bin_attribute *attr = to_bin_attr(dentry);
         struct kobject *kobj = to_kobj(dentry->d_parent);
 
@@ -117,8 +117,8 @@ static int mmap(struct file *file, struct vm_area_struct *vma)
 
 static int open(struct inode * inode, struct file * file)
 {
-        struct kobject *kobj = sysfs_get_kobject(file->f_dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_dentry);
+        struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
+        struct bin_attribute * attr = to_bin_attr(file->f_path.dentry);
         int error = -EINVAL;
 
         if (!kobj || !attr)
@@ -153,8 +153,8 @@ static int open(struct inode * inode, struct file * file)
 
 static int release(struct inode * inode, struct file * file)
 {
-        struct kobject * kobj = to_kobj(file->f_dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_dentry);
+        struct kobject * kobj = to_kobj(file->f_path.dentry->d_parent);
+        struct bin_attribute * attr = to_bin_attr(file->f_path.dentry);
         u8 * buffer = file->private_data;
 
         if (kobj) 
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index a5782e8c7f07..511edef8b321 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -419,7 +419,7 @@ out:
 
 static int sysfs_dir_open(struct inode *inode, struct file *file)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
 
         mutex_lock(&dentry->d_inode->i_mutex);
@@ -432,7 +432,7 @@ static int sysfs_dir_open(struct inode *inode, struct file *file)
 
 static int sysfs_dir_close(struct inode *inode, struct file *file)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
         struct sysfs_dirent * cursor = file->private_data;
 
         mutex_lock(&dentry->d_inode->i_mutex);
@@ -452,7 +452,7 @@ static inline unsigned char dt_type(struct sysfs_dirent *sd)
 
 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-        struct dentry *dentry = filp->f_dentry;
+        struct dentry *dentry = filp->f_path.dentry;
         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
         struct sysfs_dirent *cursor = filp->private_data;
         struct list_head *p, *q = &cursor->s_sibling;
@@ -509,7 +509,7 @@ static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 
 static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
 {
-        struct dentry * dentry = file->f_dentry;
+        struct dentry * dentry = file->f_path.dentry;
 
         mutex_lock(&dentry->d_inode->i_mutex);
         switch (origin) {
@@ -519,7 +519,7 @@ static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index 95c165101c98..9cfe53e1e00d 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -154,7 +154,7 @@ sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 
         down(&buffer->sem);
         if (buffer->needs_read_fill) {
-                if ((retval = fill_read_buffer(file->f_dentry,buffer)))
+                if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
                         goto out;
         }
         pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
@@ -245,7 +245,7 @@ sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t
         down(&buffer->sem);
         len = fill_write_buffer(buffer, buf, count);
         if (len > 0)
-                len = flush_write_buffer(file->f_dentry, buffer, len);
+                len = flush_write_buffer(file->f_path.dentry, buffer, len);
         if (len > 0)
                 *ppos += len;
         up(&buffer->sem);
@@ -254,8 +254,8 @@ sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t
 
 static int check_perm(struct inode * inode, struct file * file)
 {
-        struct kobject *kobj = sysfs_get_kobject(file->f_dentry->d_parent);
-        struct attribute * attr = to_attr(file->f_dentry);
+        struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
+        struct attribute * attr = to_attr(file->f_path.dentry);
         struct sysfs_buffer * buffer;
         struct sysfs_ops * ops = NULL;
         int error = 0;
@@ -337,8 +337,8 @@ static int sysfs_open_file(struct inode * inode, struct file * filp)
 
 static int sysfs_release(struct inode * inode, struct file * filp)
 {
-        struct kobject * kobj = to_kobj(filp->f_dentry->d_parent);
-        struct attribute * attr = to_attr(filp->f_dentry);
+        struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
+        struct attribute * attr = to_attr(filp->f_path.dentry);
         struct module * owner = attr->owner;
         struct sysfs_buffer * buffer = filp->private_data;
 
@@ -372,8 +372,8 @@ static int sysfs_release(struct inode * inode, struct file * filp)
 static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
 {
         struct sysfs_buffer * buffer = filp->private_data;
-        struct kobject * kobj = to_kobj(filp->f_dentry->d_parent);
-        struct sysfs_dirent * sd = filp->f_dentry->d_fsdata;
+        struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
+        struct sysfs_dirent * sd = filp->f_path.dentry->d_fsdata;
         int res = 0;
 
         poll_wait(filp, &kobj->poll, wait);
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index f2bef962d309..ebf7007fa161 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -70,7 +70,7 @@ fail:
 static int sysv_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
         unsigned long pos = filp->f_pos;
-        struct inode *inode = filp->f_dentry->d_inode;
+        struct inode *inode = filp->f_path.dentry->d_inode;
         struct super_block *sb = inode->i_sb;
         unsigned offset = pos & ~PAGE_CACHE_MASK;
         unsigned long n = pos >> PAGE_CACHE_SHIFT;
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index 8c28efa3b8ff..2391c9150c49 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -77,7 +77,7 @@ const struct file_operations udf_dir_operations = {
 
 int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct inode *dir = filp->f_dentry->d_inode;
+        struct inode *dir = filp->f_path.dentry->d_inode;
         int result;
 
         lock_kernel();
@@ -225,7 +225,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
 
                 if ( cfi.fileCharacteristics & FID_FILE_CHAR_PARENT )
                 {
-                        iblock = parent_ino(filp->f_dentry);
+                        iblock = parent_ino(filp->f_path.dentry);
                         flen = 2;
                         memcpy(fname, "..", flen);
                         dt_type = DT_DIR;
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 7aedd552cba1..d81f2db7b0e3 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -108,7 +108,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_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int err, pos;
         size_t count = iocb->ki_left;
 
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 7f0a0aa63584..433b6f68403a 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -426,7 +426,7 @@ static int
 ufs_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 = filp->f_path.dentry->d_inode;
         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/xattr.c b/fs/xattr.c
index 0901bdc2ce24..38646132ab0e 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -268,7 +268,7 @@ sys_fsetxattr(int fd, char __user *name, void __user *value,
         f = fget(fd);
         if (!f)
                 return error;
-        dentry = f->f_dentry;
+        dentry = f->f_path.dentry;
         audit_inode(NULL, dentry->d_inode);
         error = setxattr(dentry, name, value, size, flags);
         fput(f);
@@ -351,7 +351,7 @@ sys_fgetxattr(int fd, char __user *name, void __user *value, size_t size)
         f = fget(fd);
         if (!f)
                 return error;
-        error = getxattr(f->f_dentry, name, value, size);
+        error = getxattr(f->f_path.dentry, name, value, size);
         fput(f);
         return error;
 }
@@ -423,7 +423,7 @@ sys_flistxattr(int fd, char __user *list, size_t size)
         f = fget(fd);
         if (!f)
                 return error;
-        error = listxattr(f->f_dentry, list, size);
+        error = listxattr(f->f_path.dentry, list, size);
         fput(f);
         return error;
 }
@@ -484,7 +484,7 @@ sys_fremovexattr(int fd, char __user *name)
         f = fget(fd);
         if (!f)
                 return error;
-        dentry = f->f_dentry;
+        dentry = f->f_path.dentry;
         audit_inode(NULL, dentry->d_inode);
         error = removexattr(dentry, name);
         fput(f);
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index d93d8dd1958d..d26f5cd2ba70 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -55,7 +55,7 @@ __xfs_file_read(
         loff_t                  pos)
 {
         struct file             *file = iocb->ki_filp;
-        bhv_vnode_t             *vp = vn_from_inode(file->f_dentry->d_inode);
+        bhv_vnode_t             *vp = vn_from_inode(file->f_path.dentry->d_inode);
 
         BUG_ON(iocb->ki_pos != pos);
         if (unlikely(file->f_flags & O_DIRECT))
@@ -131,7 +131,7 @@ xfs_file_sendfile(
         read_actor_t            actor,
         void                    *target)
 {
-        return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode),
+        return bhv_vop_sendfile(vn_from_inode(filp->f_path.dentry->d_inode),
                                 filp, pos, 0, count, actor, target, NULL);
 }
 
@@ -143,7 +143,7 @@ xfs_file_sendfile_invis(
         read_actor_t            actor,
         void                    *target)
 {
-        return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode),
+        return bhv_vop_sendfile(vn_from_inode(filp->f_path.dentry->d_inode),
                                 filp, pos, IO_INVIS, count, actor, target, NULL);
 }
 
@@ -155,7 +155,7 @@ xfs_file_splice_read(
         size_t                  len,
         unsigned int            flags)
 {
-        return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode),
+        return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
                                    infilp, ppos, pipe, len, flags, 0, NULL);
 }
 
@@ -167,7 +167,7 @@ xfs_file_splice_read_invis(
         size_t                  len,
         unsigned int            flags)
 {
-        return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode),
+        return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
                                    infilp, ppos, pipe, len, flags, IO_INVIS,
                                    NULL);
 }
@@ -180,7 +180,7 @@ xfs_file_splice_write(
         size_t                  len,
         unsigned int            flags)
 {
-        return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode),
+        return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
                                     pipe, outfilp, ppos, len, flags, 0, NULL);
 }
 
@@ -192,7 +192,7 @@ xfs_file_splice_write_invis(
         size_t                  len,
         unsigned int            flags)
 {
-        return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode),
+        return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
                                     pipe, outfilp, ppos, len, flags, IO_INVIS,
                                     NULL);
 }
@@ -212,7 +212,7 @@ xfs_file_close(
         struct file     *filp,
         fl_owner_t      id)
 {
-        return -bhv_vop_close(vn_from_inode(filp->f_dentry->d_inode), 0,
+        return -bhv_vop_close(vn_from_inode(filp->f_path.dentry->d_inode), 0,
                                 file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL);
 }
 
@@ -251,7 +251,7 @@ xfs_vm_nopage(
         unsigned long           address,
         int                     *type)
 {
-        struct inode    *inode = area->vm_file->f_dentry->d_inode;
+        struct inode    *inode = area->vm_file->f_path.dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
 
         ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
@@ -268,7 +268,7 @@ xfs_file_readdir(
         filldir_t       filldir)
 {
         int             error = 0;
-        bhv_vnode_t     *vp = vn_from_inode(filp->f_dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(filp->f_path.dentry->d_inode);
         uio_t           uio;
         iovec_t         iov;
         int             eof = 0;
@@ -345,7 +345,7 @@ xfs_file_mmap(
         vma->vm_ops = &xfs_file_vm_ops;
 
 #ifdef CONFIG_XFS_DMAPI
-        if (vn_from_inode(filp->f_dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
+        if (vn_from_inode(filp->f_path.dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
                 vma->vm_ops = &xfs_dmapi_file_vm_ops;
 #endif /* CONFIG_XFS_DMAPI */
 
@@ -360,7 +360,7 @@ xfs_file_ioctl(
         unsigned long   p)
 {
         int             error;
-        struct inode    *inode = filp->f_dentry->d_inode;
+        struct inode    *inode = filp->f_path.dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
 
         error = bhv_vop_ioctl(vp, inode, filp, 0, cmd, (void __user *)p);
@@ -382,7 +382,7 @@ xfs_file_ioctl_invis(
         unsigned long   p)
 {
         int             error;
-        struct inode    *inode = filp->f_dentry->d_inode;
+        struct inode    *inode = filp->f_path.dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
 
         error = bhv_vop_ioctl(vp, inode, filp, IO_INVIS, cmd, (void __user *)p);
@@ -404,7 +404,7 @@ xfs_vm_mprotect(
         struct vm_area_struct *vma,
         unsigned int    newflags)
 {
-        bhv_vnode_t     *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(vma->vm_file->f_path.dentry->d_inode);
         int             error = 0;
 
         if (vp->v_vfsp->vfs_flag & VFS_DMI) {
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 74d094829a4d..f011c9cd0d62 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -107,9 +107,9 @@ xfs_find_handle(
                 if (!file)
                     return -EBADF;
 
-                ASSERT(file->f_dentry);
-                ASSERT(file->f_dentry->d_inode);
-                inode = igrab(file->f_dentry->d_inode);
+                ASSERT(file->f_path.dentry);
+                ASSERT(file->f_path.dentry->d_inode);
+                inode = igrab(file->f_path.dentry->d_inode);
                 fput(file);
                 break;
         }
@@ -333,10 +333,10 @@ xfs_open_by_handle(
         }
 
         /* Ensure umount returns EBUSY on umounts while this file is open. */
-        mntget(parfilp->f_vfsmnt);
+        mntget(parfilp->f_path.mnt);
 
         /* Create file pointer. */
-        filp = dentry_open(dentry, parfilp->f_vfsmnt, hreq.oflags);
+        filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
         if (IS_ERR(filp)) {
                 put_unused_fd(new_fd);
                 return -XFS_ERROR(-PTR_ERR(filp));
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index 270db0f3861d..b83cebc165f1 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -112,7 +112,7 @@ xfs_compat_ioctl(
         unsigned        cmd,
         unsigned long   arg)
 {
-        struct inode    *inode = file->f_dentry->d_inode;
+        struct inode    *inode = file->f_path.dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
         int             error;
 
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index fa842f1c9fa2..65e79b471d49 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -805,7 +805,7 @@ start:
              !capable(CAP_FSETID)) {
                 error = xfs_write_clear_setuid(xip);
                 if (likely(!error))
-                        error = -remove_suid(file->f_dentry);
+                        error = -remove_suid(file->f_path.dentry);
                 if (unlikely(error)) {
                         xfs_iunlock(xip, iolock);
                         goto out_unlock_mutex;
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 80562b60fb95..50d0faea371d 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -71,7 +71,7 @@ xfs_swapext(
 
         /* Pull information for the target fd */
         if (((fp = fget((int)sxp->sx_fdtarget)) == NULL) ||
-            ((vp = vn_from_inode(fp->f_dentry->d_inode)) == NULL))  {
+            ((vp = vn_from_inode(fp->f_path.dentry->d_inode)) == NULL))  {
                 error = XFS_ERROR(EINVAL);
                 goto error0;
         }
@@ -83,7 +83,7 @@ xfs_swapext(
         }
 
         if (((tfp = fget((int)sxp->sx_fdtmp)) == NULL) ||
-            ((tvp = vn_from_inode(tfp->f_dentry->d_inode)) == NULL)) {
+            ((tvp = vn_from_inode(tfp->f_path.dentry->d_inode)) == NULL)) {
                 error = XFS_ERROR(EINVAL);
                 goto error0;
         }