188 files changed, 1744 insertions, 1944 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_path.dentry->d_parent,
-               file->f_dentry->d_parent ?
+               file->f_path.dentry->d_parent ?
-               file->f_dentry->d_parent->d_name.name :
+               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 dentry *dentry = file->f_path.dentry;
-        struct vfsmount *mnt = file->f_vfsmnt;
+        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)
+static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,
-{
+                        int for_part);
-        int ret = 0;
+static int __blkdev_put(struct block_device *bdev, int for_part);
-        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
+static int do_open(struct block_device *bdev, struct file *file, int for_part)
-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)
 {
        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);
+int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags)
-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)
 {
-        /*
+        return __blkdev_get(bdev, mode, flags, 0);
-         * 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);
 }
+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/buffer.c b/fs/buffer.c
index 517860f2d75b..d1f1b54d3108 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -35,6 +35,7 @@
 #include <linux/hash.h>
 #include <linux/suspend.h>
 #include <linux/buffer_head.h>
+#include <linux/task_io_accounting_ops.h>
 #include <linux/bio.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
@@ -724,20 +725,21 @@ int __set_page_dirty_buffers(struct page *page)
        }
        spin_unlock(&mapping->private_lock);
-        if (!TestSetPageDirty(page)) {
+        if (TestSetPageDirty(page))
-                write_lock_irq(&mapping->tree_lock);
+                return 0;
-                if (page->mapping) {    /* Race with truncate? */
-                        if (mapping_cap_account_dirty(mapping))
+        write_lock_irq(&mapping->tree_lock);
-                                __inc_zone_page_state(page, NR_FILE_DIRTY);
+        if (page->mapping) {    /* Race with truncate? */
-                        radix_tree_tag_set(&mapping->page_tree,
+                if (mapping_cap_account_dirty(mapping)) {
-                                                page_index(page),
+                        __inc_zone_page_state(page, NR_FILE_DIRTY);
-                                                PAGECACHE_TAG_DIRTY);
+                        task_io_account_write(PAGE_CACHE_SIZE);
                }
-                write_unlock_irq(&mapping->tree_lock);
+                radix_tree_tag_set(&mapping->page_tree,
-                __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
+                                page_index(page), PAGECACHE_TAG_DIRTY);
-                return 1;
        }
-        return 0;
+        write_unlock_irq(&mapping->tree_lock);
+        __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
+        return 1;
 }
 EXPORT_SYMBOL(__set_page_dirty_buffers);
@@ -2851,8 +2853,13 @@ int try_to_free_buffers(struct page *page)
                 * could encounter a non-uptodate page, which is unresolvable.
                 * This only applies in the rare case where try_to_free_buffers
                 * succeeds but the page is not freed.
+                 *
+                 * Also, during truncate, discard_buffer will have marked all
+                 * the page's buffers clean.  We discover that here and clean
+                 * the page also.
                 */
-                clear_page_dirty(page);
+                if (test_clear_page_dirty(page))
+                        task_io_account_cancelled_write(PAGE_CACHE_SIZE);
        }
 out:
        if (buffers_to_free) {
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 0b3c37ef52e0..3539d6ef9611 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -5,7 +5,8 @@ Allow null user to be specified on mount ("username="). Do not return
 EINVAL on readdir when filldir fails due to overwritten blocksize
 (fixes FC problem).  Return error in rename 2nd attempt retry (ie report
 if rename by handle also fails, after rename by path fails, we were
-not reporting whether the retry worked or not).
+not reporting whether the retry worked or not). Fix NTLMv2 to
+work to Windows servers (mount with option "sec=ntlmv2").
 Version 1.45
 ------------
diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
index 4bc250b2d9fc..fdeda519eace 100644
--- a/fs/cifs/cifsencrypt.c
+++ b/fs/cifs/cifsencrypt.c
@@ -372,8 +372,10 @@ void setup_ntlmv2_rsp(struct cifsSesInfo * ses, char * resp_buf,
        buf->time = cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
        get_random_bytes(&buf->client_chal, sizeof(buf->client_chal));
        buf->reserved2 = 0;
-        buf->names[0].type = 0;
+        buf->names[0].type = cpu_to_le16(NTLMSSP_DOMAIN_TYPE);
        buf->names[0].length = 0;
+        buf->names[1].type = 0;
+        buf->names[1].length = 0;
        /* calculate buf->ntlmv2_hash */
        rc = calc_ntlmv2_hash(ses, nls_cp);
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/cifspdu.h b/fs/cifs/cifspdu.h
index 6df9dadba647..068ef51edbf7 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -580,6 +580,12 @@ typedef union smb_com_session_setup_andx {
 /* format of NLTMv2 Response ie "case sensitive password" hash when NTLMv2 */
+#define NTLMSSP_SERVER_TYPE     1
+#define NTLMSSP_DOMAIN_TYPE     2
+#define NTLMSSP_FQ_DOMAIN_TYPE  3
+#define NTLMSSP_DNS_DOMAIN_TYPE 4
+#define NTLMSSP_DNS_PARENT_TYPE 5
 struct ntlmssp2_name {
        __le16 type;
        __le16 length;
@@ -593,7 +599,7 @@ struct ntlmv2_resp {
        __le64  time;
        __u64  client_chal; /* random */
        __u32  reserved2;
-        struct ntlmssp2_name names[1];
+        struct ntlmssp2_name names[2];
        /* array of name entries could follow ending in minimum 4 byte struct */
 } __attribute__((packed));
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..0f05cab5d24a 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -29,6 +29,7 @@
 #include <linux/pagevec.h>
 #include <linux/smp_lock.h>
 #include <linux/writeback.h>
+#include <linux/task_io_accounting_ops.h>
 #include <linux/delay.h>
 #include <asm/div64.h>
 #include "cifsfs.h"
@@ -122,34 +123,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) && 
+        if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
-                           (file->f_dentry->d_inode->i_size == 
+                           (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 +179,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 +207,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 +292,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 +367,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 +379,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 +445,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 +552,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 +665,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 +792,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 +803,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 +811,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 +841,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) ||
+                                if ((file->f_path.dentry == NULL) ||
-                                    (file->f_dentry->d_inode == NULL)) {
+                                    (file->f_path.dentry->d_inode == NULL)) {
                                        FreeXid(xid);
                                        return total_written;
                                }
@@ -849,7 +850,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 +879,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_path.dentry) {
-                if (file->f_dentry->d_inode) {
+                if (file->f_path.dentry->d_inode) {
-                        struct inode *inode = file->f_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)
+                                if (*poffset > file->f_path.dentry->d_inode->i_size)
-                                        i_size_write(file->f_dentry->d_inode,
+                                        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 +907,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 +925,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 +956,8 @@ static ssize_t cifs_write(struct file *file, const char *write_data,
                                        return -EBADF;
                        }
                        if (open_file->invalidHandle) {
-                                if ((file->f_dentry == NULL) ||
+                                if ((file->f_path.dentry == NULL) ||
-                                   (file->f_dentry->d_inode == NULL)) {
+                                   (file->f_path.dentry->d_inode == NULL)) {
                                        FreeXid(xid);
                                        return total_written;
                                }
@@ -964,7 +965,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 +1012,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_path.dentry) {
-                if (file->f_dentry->d_inode) {
+                if (file->f_path.dentry->d_inode) {
-                        file->f_dentry->d_inode->i_ctime = 
+                        file->f_path.dentry->d_inode->i_ctime =
-                        file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
+                        file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;
                        if (total_written > 0) {
-                                if (*poffset > file->f_dentry->d_inode->i_size)
+                                if (*poffset > file->f_path.dentry->d_inode->i_size)
-                                        i_size_write(file->f_dentry->d_inode, 
+                                        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 +1385,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 +1435,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 +1483,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 +1520,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 +1543,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 +1602,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 +1630,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 +1659,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 +1745,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 +1787,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;
@@ -1812,6 +1813,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                        cFYI(1, ("Read error in readpages: %d", rc));
                        break;
                } else if (bytes_read > 0) {
+                        task_io_account_read(bytes_read);
                        pSMBr = (struct smb_com_read_rsp *)smb_read_data;
                        cifs_copy_cache_pages(mapping, page_list, bytes_read,
                                smb_read_data + 4 /* RFC1001 hdr */ +
@@ -1880,8 +1882,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 =
+        file->f_path.dentry->d_inode->i_atime =
-                current_fs_time(file->f_dentry->d_inode->i_sb);
+                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;
+        coda_inode = coda_file->f_path.dentry->d_inode;
-        host_inode = host_file->f_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..0ec70e3cee0a 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
@@ -1679,19 +1679,19 @@ int compat_core_sys_select(int n, compat_ulong_t __user *inp,
 {
        fd_set_bits fds;
        char *bits;
-        int size, max_fdset, ret = -EINVAL;
+        int size, max_fds, ret = -EINVAL;
        struct fdtable *fdt;
        if (n < 0)
                goto out_nofds;
-        /* max_fdset can increase, so grab it once to avoid race */
+        /* max_fds can increase, so grab it once to avoid race */
        rcu_read_lock();
        fdt = files_fdtable(current->files);
-        max_fdset = fdt->max_fdset;
+        max_fds = fdt->max_fds;
        rcu_read_unlock();
-        if (n > max_fdset)
+        if (n > max_fds)
-                n = max_fdset;
+                n = max_fds;
        /*
         * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
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 config_item *item = configfs_get_config_item(file->f_path.dentry->d_parent);
-        struct configfs_attribute * attr = to_attr(file->f_dentry);
+        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 config_item * item = to_item(filp->f_path.dentry->d_parent);
-        struct configfs_attribute * attr = to_attr(filp->f_dentry);
+        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/direct-io.c b/fs/direct-io.c
index 5981e17f46f0..d9d0833444f5 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
+#include <linux/task_io_accounting_ops.h>
 #include <linux/bio.h>
 #include <linux/wait.h>
 #include <linux/err.h>
@@ -121,8 +122,7 @@ struct dio {
        /* BIO completion state */
        spinlock_t bio_lock;            /* protects BIO fields below */
-        int bio_count;                  /* nr bios to be completed */
+        unsigned long refcount;         /* direct_io_worker() and bios */
-        int bios_in_flight;             /* nr bios in flight */
        struct bio *bio_list;           /* singly linked via bi_private */
        struct task_struct *waiter;     /* waiting task (NULL if none) */
@@ -209,76 +209,55 @@ static struct page *dio_get_page(struct dio *dio)
        return dio->pages[dio->head++];
 }
-/*
+/**
- * Called when all DIO BIO I/O has been completed - let the filesystem
+ * dio_complete() - called when all DIO BIO I/O has been completed
- * know, if it registered an interest earlier via get_block.  Pass the
+ * @offset: the byte offset in the file of the completed operation
- * private field of the map buffer_head so that filesystems can use it
+ *
- * to hold additional state between get_block calls and dio_complete.
+ * This releases locks as dictated by the locking type, lets interested parties
- */
+ * know that a DIO operation has completed, and calculates the resulting return
-static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)
+ * code for the operation.
-{
+ *
-        if (dio->end_io && dio->result)
+ * It lets the filesystem know if it registered an interest earlier via
-                dio->end_io(dio->iocb, offset, bytes, dio->map_bh.b_private);
+ * get_block.  Pass the private field of the map buffer_head so that
-        if (dio->lock_type == DIO_LOCKING)
+ * filesystems can use it to hold additional state between get_block calls and
-                /* lockdep: non-owner release */
+ * dio_complete.
-                up_read_non_owner(&dio->inode->i_alloc_sem);
-}
-/*
- * Called when a BIO has been processed.  If the count goes to zero then IO is
- * complete and we can signal this to the AIO layer.
 */
-static void finished_one_bio(struct dio *dio)
+static int dio_complete(struct dio *dio, loff_t offset, int ret)
 {
-        unsigned long flags;
+        ssize_t transferred = 0;
-        spin_lock_irqsave(&dio->bio_lock, flags);
+        /*
-        if (dio->bio_count == 1) {
+         * AIO submission can race with bio completion to get here while
-                if (dio->is_async) {
+         * expecting to have the last io completed by bio completion.
-                        ssize_t transferred;
+         * In that case -EIOCBQUEUED is in fact not an error we want
-                        loff_t offset;
+         * to preserve through this call.
+         */
-                        /*
+        if (ret == -EIOCBQUEUED)
-                         * Last reference to the dio is going away.
+                ret = 0;
-                         * Drop spinlock and complete the DIO.
-                         */
-                        spin_unlock_irqrestore(&dio->bio_lock, flags);
-                        /* Check for short read case */
+        if (dio->result) {
-                        transferred = dio->result;
+                transferred = dio->result;
-                        offset = dio->iocb->ki_pos;
-                        if ((dio->rw == READ) &&
+                /* Check for short read case */
-                            ((offset + transferred) > dio->i_size))
+                if ((dio->rw == READ) && ((offset + transferred) > dio->i_size))
-                                transferred = dio->i_size - offset;
+                        transferred = dio->i_size - offset;
+        }
-                        /* check for error in completion path */
+        if (dio->end_io && dio->result)
-                        if (dio->io_error)
+                dio->end_io(dio->iocb, offset, transferred,
-                                transferred = dio->io_error;
+                            dio->map_bh.b_private);
+        if (dio->lock_type == DIO_LOCKING)
+                /* lockdep: non-owner release */
+                up_read_non_owner(&dio->inode->i_alloc_sem);
-                        dio_complete(dio, offset, transferred);
+        if (ret == 0)
+                ret = dio->page_errors;
+        if (ret == 0)
+                ret = dio->io_error;
+        if (ret == 0)
+                ret = transferred;
-                        /* Complete AIO later if falling back to buffered i/o */
+        return ret;
-                        if (dio->result == dio->size ||
-                                ((dio->rw == READ) && dio->result)) {
-                                aio_complete(dio->iocb, transferred, 0);
-                                kfree(dio);
-                                return;
-                        } else {
-                                /*
-                                 * Falling back to buffered
-                                 */
-                                spin_lock_irqsave(&dio->bio_lock, flags);
-                                dio->bio_count--;
-                                if (dio->waiter)
-                                        wake_up_process(dio->waiter);
-                                spin_unlock_irqrestore(&dio->bio_lock, flags);
-                                return;
-                        }
-                }
-        }
-        dio->bio_count--;
-        spin_unlock_irqrestore(&dio->bio_lock, flags);
 }
 static int dio_bio_complete(struct dio *dio, struct bio *bio);
@@ -288,12 +267,27 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio);
 static int dio_bio_end_aio(struct bio *bio, unsigned int bytes_done, int error)
 {
        struct dio *dio = bio->bi_private;
+        unsigned long remaining;
+        unsigned long flags;
        if (bio->bi_size)
                return 1;
        /* cleanup the bio */
        dio_bio_complete(dio, bio);
+        spin_lock_irqsave(&dio->bio_lock, flags);
+        remaining = --dio->refcount;
+        if (remaining == 1 && dio->waiter)
+                wake_up_process(dio->waiter);
+        spin_unlock_irqrestore(&dio->bio_lock, flags);
+        if (remaining == 0) {
+                int ret = dio_complete(dio, dio->iocb->ki_pos, 0);
+                aio_complete(dio->iocb, ret, 0);
+                kfree(dio);
+        }
        return 0;
 }
@@ -315,8 +309,7 @@ static int dio_bio_end_io(struct bio *bio, unsigned int bytes_done, int error)
        spin_lock_irqsave(&dio->bio_lock, flags);
        bio->bi_private = dio->bio_list;
        dio->bio_list = bio;
-        dio->bios_in_flight--;
+        if (--dio->refcount == 1 && dio->waiter)
-        if (dio->waiter && dio->bios_in_flight == 0)
                wake_up_process(dio->waiter);
        spin_unlock_irqrestore(&dio->bio_lock, flags);
        return 0;
@@ -347,6 +340,8 @@ dio_bio_alloc(struct dio *dio, struct block_device *bdev,
 * In the AIO read case we speculatively dirty the pages before starting IO.
 * During IO completion, any of these pages which happen to have been written
 * back will be redirtied by bio_check_pages_dirty().
+ *
+ * bios hold a dio reference between submit_bio and ->end_io.
 */
 static void dio_bio_submit(struct dio *dio)
 {
@@ -354,12 +349,14 @@ static void dio_bio_submit(struct dio *dio)
        unsigned long flags;
        bio->bi_private = dio;
        spin_lock_irqsave(&dio->bio_lock, flags);
-        dio->bio_count++;
+        dio->refcount++;
-        dio->bios_in_flight++;
        spin_unlock_irqrestore(&dio->bio_lock, flags);
        if (dio->is_async && dio->rw == READ)
                bio_set_pages_dirty(bio);
        submit_bio(dio->rw, bio);
        dio->bio = NULL;
@@ -376,28 +373,37 @@ static void dio_cleanup(struct dio *dio)
 }
 /*
- * Wait for the next BIO to complete.  Remove it and return it.
+ * Wait for the next BIO to complete.  Remove it and return it.  NULL is
+ * returned once all BIOs have been completed.  This must only be called once
+ * all bios have been issued so that dio->refcount can only decrease.  This
+ * requires that that the caller hold a reference on the dio.
 */
 static struct bio *dio_await_one(struct dio *dio)
 {
        unsigned long flags;
-        struct bio *bio;
+        struct bio *bio = NULL;
        spin_lock_irqsave(&dio->bio_lock, flags);
-        while (dio->bio_list == NULL) {
-                set_current_state(TASK_UNINTERRUPTIBLE);
+        /*
-                if (dio->bio_list == NULL) {
+         * Wait as long as the list is empty and there are bios in flight.  bio
-                        dio->waiter = current;
+         * completion drops the count, maybe adds to the list, and wakes while
-                        spin_unlock_irqrestore(&dio->bio_lock, flags);
+         * holding the bio_lock so we don't need set_current_state()'s barrier
-                        blk_run_address_space(dio->inode->i_mapping);
+         * and can call it after testing our condition.
-                        io_schedule();
+         */
-                        spin_lock_irqsave(&dio->bio_lock, flags);
+        while (dio->refcount > 1 && dio->bio_list == NULL) {
-                        dio->waiter = NULL;
+                __set_current_state(TASK_UNINTERRUPTIBLE);
-                }
+                dio->waiter = current;
-                set_current_state(TASK_RUNNING);
+                spin_unlock_irqrestore(&dio->bio_lock, flags);
+                io_schedule();
+                /* wake up sets us TASK_RUNNING */
+                spin_lock_irqsave(&dio->bio_lock, flags);
+                dio->waiter = NULL;
+        }
+        if (dio->bio_list) {
+                bio = dio->bio_list;
+                dio->bio_list = bio->bi_private;
        }
-        bio = dio->bio_list;
-        dio->bio_list = bio->bi_private;
        spin_unlock_irqrestore(&dio->bio_lock, flags);
        return bio;
 }
@@ -426,34 +432,24 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio)
                }
                bio_put(bio);
        }
-        finished_one_bio(dio);
        return uptodate ? 0 : -EIO;
 }
 /*
- * Wait on and process all in-flight BIOs.
+ * Wait on and process all in-flight BIOs.  This must only be called once
+ * all bios have been issued so that the refcount can only decrease.
+ * This just waits for all bios to make it through dio_bio_complete.  IO
+ * errors are propogated through dio->io_error and should be propogated via
+ * dio_complete().
 */
-static int dio_await_completion(struct dio *dio)
+static void dio_await_completion(struct dio *dio)
 {
-        int ret = 0;
+        struct bio *bio;
+        do {
-        if (dio->bio)
+                bio = dio_await_one(dio);
-                dio_bio_submit(dio);
+                if (bio)
+                        dio_bio_complete(dio, bio);
-        /*
+        } while (bio);
-         * The bio_lock is not held for the read of bio_count.
-         * This is ok since it is the dio_bio_complete() that changes
-         * bio_count.
-         */
-        while (dio->bio_count) {
-                struct bio *bio = dio_await_one(dio);
-                int ret2;
-                ret2 = dio_bio_complete(dio, bio);
-                if (ret == 0)
-                        ret = ret2;
-        }
-        return ret;
 }
 /*
@@ -675,6 +671,13 @@ submit_page_section(struct dio *dio, struct page *page,
 {
        int ret = 0;
+        if (dio->rw & WRITE) {
+                /*
+                 * Read accounting is performed in submit_bio()
+                 */
+                task_io_account_write(len);
+        }
        /*
         * Can we just grow the current page's presence in the dio?
         */
@@ -953,6 +956,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        struct dio *dio)
 {
        unsigned long user_addr; 
+        unsigned long flags;
        int seg;
        ssize_t ret = 0;
        ssize_t ret2;
@@ -983,17 +987,8 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        dio->iocb = iocb;
        dio->i_size = i_size_read(inode);
-        /*
-         * BIO completion state.
-         *
-         * ->bio_count starts out at one, and we decrement it to zero after all
-         * BIOs are submitted.  This to avoid the situation where a really fast
-         * (or synchronous) device could take the count to zero while we're
-         * still submitting BIOs.
-         */
-        dio->bio_count = 1;
-        dio->bios_in_flight = 0;
        spin_lock_init(&dio->bio_lock);
+        dio->refcount = 1;
        dio->bio_list = NULL;
        dio->waiter = NULL;
@@ -1069,6 +1064,9 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        if (dio->bio)
                dio_bio_submit(dio);
+        /* All IO is now issued, send it on its way */
+        blk_run_address_space(inode->i_mapping);
        /*
         * It is possible that, we return short IO due to end of file.
         * In that case, we need to release all the pages we got hold on.
@@ -1084,74 +1082,41 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
                mutex_unlock(&dio->inode->i_mutex);
        /*
-         * OK, all BIOs are submitted, so we can decrement bio_count to truly
+         * The only time we want to leave bios in flight is when a successful
-         * reflect the number of to-be-processed BIOs.
+         * partial aio read or full aio write have been setup.  In that case
+         * bio completion will call aio_complete.  The only time it's safe to
+         * call aio_complete is when we return -EIOCBQUEUED, so we key on that.
+         * This had *better* be the only place that raises -EIOCBQUEUED.
         */
-        if (dio->is_async) {
+        BUG_ON(ret == -EIOCBQUEUED);
-                int should_wait = 0;
+        if (dio->is_async && ret == 0 && dio->result &&
+            ((rw & READ) || (dio->result == dio->size)))
+                ret = -EIOCBQUEUED;
-                if (dio->result < dio->size && (rw & WRITE)) {
+        if (ret != -EIOCBQUEUED)
-                        dio->waiter = current;
+                dio_await_completion(dio);
-                        should_wait = 1;
-                }
-                if (ret == 0)
-                        ret = dio->result;
-                finished_one_bio(dio);          /* This can free the dio */
-                blk_run_address_space(inode->i_mapping);
-                if (should_wait) {
-                        unsigned long flags;
-                        /*
-                         * Wait for already issued I/O to drain out and
-                         * release its references to user-space pages
-                         * before returning to fallback on buffered I/O
-                         */
-                        spin_lock_irqsave(&dio->bio_lock, flags);
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        while (dio->bio_count) {
-                                spin_unlock_irqrestore(&dio->bio_lock, flags);
-                                io_schedule();
-                                spin_lock_irqsave(&dio->bio_lock, flags);
-                                set_current_state(TASK_UNINTERRUPTIBLE);
-                        }
-                        spin_unlock_irqrestore(&dio->bio_lock, flags);
-                        set_current_state(TASK_RUNNING);
-                        kfree(dio);
-                }
-        } else {
-                ssize_t transferred = 0;
-                finished_one_bio(dio);
-                ret2 = dio_await_completion(dio);
-                if (ret == 0)
-                        ret = ret2;
-                if (ret == 0)
-                        ret = dio->page_errors;
-                if (dio->result) {
-                        loff_t i_size = i_size_read(inode);
-                        transferred = dio->result;
-                        /*
-                         * Adjust the return value if the read crossed a
-                         * non-block-aligned EOF.
-                         */
-                        if (rw == READ && (offset + transferred > i_size))
-                                transferred = i_size - offset;
-                }
-                dio_complete(dio, offset, transferred);
-                if (ret == 0)
-                        ret = transferred;
-                /* We could have also come here on an AIO file extend */
+        /*
-                if (!is_sync_kiocb(iocb) && (rw & WRITE) &&
+         * Sync will always be dropping the final ref and completing the
-                    ret >= 0 && dio->result == dio->size)
+         * operation.  AIO can if it was a broken operation described above or
-                        /*
+         * in fact if all the bios race to complete before we get here.  In
-                         * For AIO writes where we have completed the
+         * that case dio_complete() translates the EIOCBQUEUED into the proper
-                         * i/o, we have to mark the the aio complete.
+         * return code that the caller will hand to aio_complete().
-                         */
+         *
-                        aio_complete(iocb, ret, 0);
+         * This is managed by the bio_lock instead of being an atomic_t so that
+         * completion paths can drop their ref and use the remaining count to
+         * decide to wake the submission path atomically.
+         */
+        spin_lock_irqsave(&dio->bio_lock, flags);
+        ret2 = --dio->refcount;
+        spin_unlock_irqrestore(&dio->bio_lock, flags);
+        BUG_ON(!dio->is_async && ret2 != 0);
+        if (ret2 == 0) {
+                ret = dio_complete(dio, offset, ret);
                kfree(dio);
-        }
+        } else
+                BUG_ON(ret != -EIOCBQUEUED);
        return ret;
 }
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(tty, ": write failed, ");
-        tty_write_message(current->signal->tty, quotatypes[dquot->dq_type]);
+        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 path lower_path;
-        struct vfsmount *lower_mnt;
        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_dentry = ecryptfs_dentry_to_lower(file->f_path.dentry);
-                lower_vfsmount = ecryptfs_dentry_to_lower_mnt(file->f_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,
+        fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_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,
+                fsstack_copy_attr_atime(dentry->d_inode,
-                                         lower_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));
+        BUG_ON(!(file && file->f_path.dentry && file->f_path.dentry->d_inode));
-        crypt_stat =
+        crypt_stat = &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)
-                &ecryptfs_inode_to_private(file->f_dentry->d_inode)->crypt_stat;
+                        ->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 =
+        crypt_stat = &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)
-                &ecryptfs_inode_to_private(file->f_dentry->d_inode)->crypt_stat;
+                                ->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_path.mnt = mntget(eventpoll_mnt);
-        file->f_dentry = dentry;
+        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..11fe93f7363c 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))
+        if (unlikely(tsk->group_leader == child_reaper(tsk)))
-                child_reaper = tsk;
+                tsk->nsproxy->pid_ns->child_reaper = tsk;
        zap_other_threads(tsk);
        read_unlock(&tasklist_lock);
@@ -782,7 +783,7 @@ static void flush_old_files(struct files_struct * files)
                j++;
                i = j * __NFDBITS;
                fdt = files_fdtable(files);
-                if (i >= fdt->max_fds || i >= fdt->max_fdset)
+                if (i >= fdt->max_fds)
                        break;
                set = fdt->close_on_exec->fds_bits[j];
                if (!set)
@@ -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_addr_per_block_bits = ilog2(EXT3_ADDR_PER_BLOCK(sb));
-        sbi->s_desc_per_block_bits = log2(EXT3_DESC_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..8e382a5d51bd 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -77,10 +77,9 @@ repeat:
                start = files->next_fd;
        newfd = start;
-        if (start < fdt->max_fdset) {
+        if (start < fdt->max_fds)
                newfd = find_next_zero_bit(fdt->open_fds->fds_bits,
-                        fdt->max_fdset, start);
+                                           fdt->max_fds, start);
-        }
        
        error = -EMFILE;
        if (newfd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
@@ -204,7 +203,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.c b/fs/file.c
index 51aef675470f..857fa49e984c 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -32,46 +32,28 @@ struct fdtable_defer {
 */
 static DEFINE_PER_CPU(struct fdtable_defer, fdtable_defer_list);
+static inline void * alloc_fdmem(unsigned int size)
-/*
- * Allocate an fd array, using kmalloc or vmalloc.
- * Note: the array isn't cleared at allocation time.
- */
-struct file ** alloc_fd_array(int num)
 {
-        struct file **new_fds;
-        int size = num * sizeof(struct file *);
        if (size <= PAGE_SIZE)
-                new_fds = (struct file **) kmalloc(size, GFP_KERNEL);
+                return kmalloc(size, GFP_KERNEL);
-        else 
+        else
-                new_fds = (struct file **) vmalloc(size);
+                return vmalloc(size);
-        return new_fds;
 }
-void free_fd_array(struct file **array, int num)
+static inline void free_fdarr(struct fdtable *fdt)
 {
-        int size = num * sizeof(struct file *);
+        if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *)))
+                kfree(fdt->fd);
-        if (!array) {
-                printk (KERN_ERR "free_fd_array: array = 0 (num = %d)\n", num);
-                return;
-        }
-        if (num <= NR_OPEN_DEFAULT) /* Don't free the embedded fd array! */
-                return;
-        else if (size <= PAGE_SIZE)
-                kfree(array);
        else
-                vfree(array);
+                vfree(fdt->fd);
 }
-static void __free_fdtable(struct fdtable *fdt)
+static inline void free_fdset(struct fdtable *fdt)
 {
-        free_fdset(fdt->open_fds, fdt->max_fdset);
+        if (fdt->max_fds <= (PAGE_SIZE * BITS_PER_BYTE / 2))
-        free_fdset(fdt->close_on_exec, fdt->max_fdset);
+                kfree(fdt->open_fds);
-        free_fd_array(fdt->fd, fdt->max_fds);
+        else
-        kfree(fdt);
+                vfree(fdt->open_fds);
 }
 static void free_fdtable_work(struct work_struct *work)
@@ -86,41 +68,32 @@ static void free_fdtable_work(struct work_struct *work)
        spin_unlock_bh(&f->lock);
        while(fdt) {
                struct fdtable *next = fdt->next;
-                __free_fdtable(fdt);
+                vfree(fdt->fd);
+                free_fdset(fdt);
+                kfree(fdt);
                fdt = next;
        }
 }
-static void free_fdtable_rcu(struct rcu_head *rcu)
+void free_fdtable_rcu(struct rcu_head *rcu)
 {
        struct fdtable *fdt = container_of(rcu, struct fdtable, rcu);
-        int fdset_size, fdarray_size;
        struct fdtable_defer *fddef;
        BUG_ON(!fdt);
-        fdset_size = fdt->max_fdset / 8;
-        fdarray_size = fdt->max_fds * sizeof(struct file *);
-        if (fdt->free_files) {
+        if (fdt->max_fds <= NR_OPEN_DEFAULT) {
                /*
-                 * The this fdtable was embedded in the files structure
+                 * This fdtable is embedded in the files structure and that
-                 * and the files structure itself was getting destroyed.
+                 * structure itself is getting destroyed.
-                 * It is now safe to free the files structure.
                 */
-                kmem_cache_free(files_cachep, fdt->free_files);
+                kmem_cache_free(files_cachep,
+                                container_of(fdt, struct files_struct, fdtab));
                return;
        }
-        if (fdt->max_fdset <= EMBEDDED_FD_SET_SIZE &&
+        if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *))) {
-                fdt->max_fds <= NR_OPEN_DEFAULT) {
-                /*
-                 * The fdtable was embedded
-                 */
-                return;
-        }
-        if (fdset_size <= PAGE_SIZE && fdarray_size <= PAGE_SIZE) {
-                kfree(fdt->open_fds);
-                kfree(fdt->close_on_exec);
                kfree(fdt->fd);
+                kfree(fdt->open_fds);
                kfree(fdt);
        } else {
                fddef = &get_cpu_var(fdtable_defer_list);
@@ -134,136 +107,74 @@ static void free_fdtable_rcu(struct rcu_head *rcu)
        }
 }
-void free_fdtable(struct fdtable *fdt)
-{
-        if (fdt->free_files ||
-                fdt->max_fdset > EMBEDDED_FD_SET_SIZE ||
-                fdt->max_fds > NR_OPEN_DEFAULT)
-                call_rcu(&fdt->rcu, free_fdtable_rcu);
-}
 /*
 * Expand the fdset in the files_struct.  Called with the files spinlock
 * held for write.
 */
-static void copy_fdtable(struct fdtable *nfdt, struct fdtable *fdt)
+static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
 {
-        int i;
+        unsigned int cpy, set;
-        int count;
-        BUG_ON(nfdt->max_fdset < fdt->max_fdset);
-        BUG_ON(nfdt->max_fds < fdt->max_fds);
-        /* Copy the existing tables and install the new pointers */
-        i = fdt->max_fdset / (sizeof(unsigned long) * 8);
-        count = (nfdt->max_fdset - fdt->max_fdset) / 8;
-        /*
+        BUG_ON(nfdt->max_fds < ofdt->max_fds);
-         * Don't copy the entire array if the current fdset is
+        if (ofdt->max_fds == 0)
-         * not yet initialised.
+                return;
-         */
-        if (i) {
-                memcpy (nfdt->open_fds, fdt->open_fds,
-                                                fdt->max_fdset/8);
-                memcpy (nfdt->close_on_exec, fdt->close_on_exec,
-                                                fdt->max_fdset/8);
-                memset (&nfdt->open_fds->fds_bits[i], 0, count);
-                memset (&nfdt->close_on_exec->fds_bits[i], 0, count);
-        }
-        /* Don't copy/clear the array if we are creating a new
-           fd array for fork() */
-        if (fdt->max_fds) {
-                memcpy(nfdt->fd, fdt->fd,
-                        fdt->max_fds * sizeof(struct file *));
-                /* clear the remainder of the array */
-                memset(&nfdt->fd[fdt->max_fds], 0,
-                       (nfdt->max_fds - fdt->max_fds) *
-                                        sizeof(struct file *));
-        }
-}
-/*
- * Allocate an fdset array, using kmalloc or vmalloc.
- * Note: the array isn't cleared at allocation time.
- */
-fd_set * alloc_fdset(int num)
-{
-        fd_set *new_fdset;
-        int size = num / 8;
-        if (size <= PAGE_SIZE)
+        cpy = ofdt->max_fds * sizeof(struct file *);
-                new_fdset = (fd_set *) kmalloc(size, GFP_KERNEL);
+        set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *);
-        else
+        memcpy(nfdt->fd, ofdt->fd, cpy);
-                new_fdset = (fd_set *) vmalloc(size);
+        memset((char *)(nfdt->fd) + cpy, 0, set);
-        return new_fdset;
+        cpy = ofdt->max_fds / BITS_PER_BYTE;
+        set = (nfdt->max_fds - ofdt->max_fds) / BITS_PER_BYTE;
+        memcpy(nfdt->open_fds, ofdt->open_fds, cpy);
+        memset((char *)(nfdt->open_fds) + cpy, 0, set);
+        memcpy(nfdt->close_on_exec, ofdt->close_on_exec, cpy);
+        memset((char *)(nfdt->close_on_exec) + cpy, 0, set);
 }
-void free_fdset(fd_set *array, int num)
+static struct fdtable * alloc_fdtable(unsigned int nr)
 {
-        if (num <= EMBEDDED_FD_SET_SIZE) /* Don't free an embedded fdset */
+        struct fdtable *fdt;
-                return;
+        char *data;
-        else if (num <= 8 * PAGE_SIZE)
-                kfree(array);
-        else
-                vfree(array);
-}
-static struct fdtable *alloc_fdtable(int nr)
+        /*
-{
+         * Figure out how many fds we actually want to support in this fdtable.
-        struct fdtable *fdt = NULL;
+         * Allocation steps are keyed to the size of the fdarray, since it
-        int nfds = 0;
+         * grows far faster than any of the other dynamic data. We try to fit
-        fd_set *new_openset = NULL, *new_execset = NULL;
+         * the fdarray into comfortable page-tuned chunks: starting at 1024B
-        struct file **new_fds;
+         * and growing in powers of two from there on.
+         */
+        nr /= (1024 / sizeof(struct file *));
+        nr = roundup_pow_of_two(nr + 1);
+        nr *= (1024 / sizeof(struct file *));
+        if (nr > NR_OPEN)
+                nr = NR_OPEN;
-        fdt = kzalloc(sizeof(*fdt), GFP_KERNEL);
+        fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL);
        if (!fdt)
-                goto out;
+                goto out;
+        fdt->max_fds = nr;
-        nfds = max_t(int, 8 * L1_CACHE_BYTES, roundup_pow_of_two(nr + 1));
+        data = alloc_fdmem(nr * sizeof(struct file *));
-        if (nfds > NR_OPEN)
+        if (!data)
-                nfds = NR_OPEN;
+                goto out_fdt;
+        fdt->fd = (struct file **)data;
+        data = alloc_fdmem(max_t(unsigned int,
+                                 2 * nr / BITS_PER_BYTE, L1_CACHE_BYTES));
+        if (!data)
+                goto out_arr;
+        fdt->open_fds = (fd_set *)data;
+        data += nr / BITS_PER_BYTE;
+        fdt->close_on_exec = (fd_set *)data;
+        INIT_RCU_HEAD(&fdt->rcu);
+        fdt->next = NULL;
-        new_openset = alloc_fdset(nfds);
-        new_execset = alloc_fdset(nfds);
-        if (!new_openset || !new_execset)
-                goto out;
-        fdt->open_fds = new_openset;
-        fdt->close_on_exec = new_execset;
-        fdt->max_fdset = nfds;
-        nfds = NR_OPEN_DEFAULT;
-        /*
-         * Expand to the max in easy steps, and keep expanding it until
-         * we have enough for the requested fd array size.
-         */
-        do {
-#if NR_OPEN_DEFAULT < 256
-                if (nfds < 256)
-                        nfds = 256;
-                else
-#endif
-                if (nfds < (PAGE_SIZE / sizeof(struct file *)))
-                        nfds = PAGE_SIZE / sizeof(struct file *);
-                else {
-                        nfds = nfds * 2;
-                        if (nfds > NR_OPEN)
-                                nfds = NR_OPEN;
-                }
-        } while (nfds <= nr);
-        new_fds = alloc_fd_array(nfds);
-        if (!new_fds)
-                goto out2;
-        fdt->fd = new_fds;
-        fdt->max_fds = nfds;
-        fdt->free_files = NULL;
        return fdt;
-out2:
-        nfds = fdt->max_fdset;
+out_arr:
-out:
+        free_fdarr(fdt);
-        free_fdset(new_openset, nfds);
+out_fdt:
-        free_fdset(new_execset, nfds);
        kfree(fdt);
+out:
        return NULL;
 }
@@ -290,14 +201,17 @@ static int expand_fdtable(struct files_struct *files, int nr)
         * we dropped the lock
         */
        cur_fdt = files_fdtable(files);
-        if (nr >= cur_fdt->max_fds || nr >= cur_fdt->max_fdset) {
+        if (nr >= cur_fdt->max_fds) {
                /* Continue as planned */
                copy_fdtable(new_fdt, cur_fdt);
                rcu_assign_pointer(files->fdt, new_fdt);
-                free_fdtable(cur_fdt);
+                if (cur_fdt->max_fds > NR_OPEN_DEFAULT)
+                        call_rcu(&cur_fdt->rcu, free_fdtable_rcu);
        } else {
                /* Somebody else expanded, so undo our attempt */
-                __free_fdtable(new_fdt);
+                free_fdarr(new_fdt);
+                free_fdset(new_fdt);
+                kfree(new_fdt);
        }
        return 1;
 }
@@ -316,11 +230,10 @@ int expand_files(struct files_struct *files, int nr)
        fdt = files_fdtable(files);
        /* Do we need to expand? */
-        if (nr < fdt->max_fdset && nr < fdt->max_fds)
+        if (nr < fdt->max_fds)
                return 0;
        /* Can we expand? */
-        if (fdt->max_fdset >= NR_OPEN || fdt->max_fds >= NR_OPEN ||
+        if (nr >= NR_OPEN)
-            nr >= NR_OPEN)
                return -EMFILE;
        /* All good, so we try */
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 dentry *dentry = file->f_path.dentry;
-        struct vfsmount *mnt = file->f_vfsmnt;
+        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_path.dentry = NULL;
-        file->f_vfsmnt = 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->vfsmount = mntget(file->f_path.mnt);
-                req->dentry = dget(file->f_dentry);
+                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_path.mnt = mntget(hugetlbfs_vfsmount);
-        file->f_dentry = dentry;
+        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_path.mnt = mntget(inotify_mnt);
-        filp->f_dentry = dget(inotify_mnt->mnt_root);
+        filp->f_path.dentry = dget(inotify_mnt->mnt_root);
-        filp->f_mapping = filp->f_dentry->d_inode->i_mapping;
+        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) ||
+                        if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) ||
-                            S_ISREG(filp->f_dentry->d_inode->i_mode) ||
+                            S_ISREG(filp->f_path.dentry->d_inode->i_mode) ||
-                            S_ISLNK(filp->f_dentry->d_inode->i_mode)) {
+                            S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) {
-                                loff_t res = inode_get_bytes(filp->f_dentry->d_inode);
+                                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/jbd/transaction.c b/fs/jbd/transaction.c
index d38e0d575e48..cceaf57e3778 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -55,7 +55,7 @@ get_transaction(journal_t *journal, transaction_t *transaction)
        spin_lock_init(&transaction->t_handle_lock);
        /* Set up the commit timer for the new transaction. */
-        journal->j_commit_timer.expires = transaction->t_expires;
+        journal->j_commit_timer.expires = round_jiffies(transaction->t_expires);
        add_timer(&journal->j_commit_timer);
        J_ASSERT(journal->j_running_transaction == 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;
+                        p = file->f_path.dentry->d_subdirs.next;
-                        while (n && p != &file->f_dentry->d_subdirs) {
+                        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 50643b6a5556..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",
@@ -730,7 +730,7 @@ static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
                goto retry_cancel;
        }
-        dprintk("lockd: cancel status %d (task %d)\n",
+        dprintk("lockd: cancel status %u (task %u)\n",
                        req->a_res.status, task->tk_pid);
        switch (req->a_res.status) {
diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c
index 0ce5c81ff507..f67146a8199a 100644
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -234,7 +234,7 @@ nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
 */
 static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
 {
-        dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
+        dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
                        -task->tk_status);
 }
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_path.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_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_path.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_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_path.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_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_path.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_ino,
                                lock->fl.fl_pid,
                                (long long)lock->fl.fl_start,
                                (long long)lock->fl.fl_end);
diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c
index 32e99a6e8dca..3707c3a23e93 100644
--- a/fs/lockd/svcproc.c
+++ b/fs/lockd/svcproc.c
@@ -263,7 +263,7 @@ nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
 */
 static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
 {
-        dprintk("lockd: %4d callback returned %d\n", task->tk_pid,
+        dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
                        -task->tk_status);
 }
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);
+        time_out_leases(filp->f_path.dentry->d_inode);
-        for (fl = filp->f_dentry->d_inode->i_flock; fl && IS_LEASE(fl);
+        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);
+                __touch_mnt_namespace(p->mnt_ns);
-                p->mnt_namespace = NULL;
+                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;
+                ns = mnt->mnt_ns;
-                if (!namespace || !namespace->root)
+                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 mnt_namespace *mnt_ns = tsk->nsproxy->mnt_ns;
-        struct namespace *new_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 mnt_namespace *ns = tsk->nsproxy->mnt_ns;
-        struct namespace *new_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);
+        ns = kmalloc(sizeof(*ns), GFP_KERNEL);
-        if (!namespace)
+        if (!ns)
                panic("Can't allocate initial namespace");
-        atomic_set(&namespace->count, 1);
+        atomic_set(&ns->count, 1);
-        INIT_LIST_HEAD(&namespace->list);
+        INIT_LIST_HEAD(&ns->list);
-        init_waitqueue_head(&namespace->poll);
+        init_waitqueue_head(&ns->poll);
-        namespace->event = 0;
+        ns->event = 0;
-        list_add(&mnt->mnt_list, &namespace->list);
+        list_add(&mnt->mnt_list, &ns->list);
-        namespace->root = mnt;
+        ns->root = mnt;
-        mnt->mnt_namespace = namespace;
+        mnt->mnt_ns = ns;
-        init_task.nsproxy->namespace = namespace;
+        init_task.nsproxy->mnt_ns = ns;
-        get_namespace(namespace);
+        get_mnt_ns(ns);
-        set_fs_pwd(current->fs, namespace->root, namespace->root->mnt_root);
+        set_fs_pwd(current->fs, ns->root, ns->root->mnt_root);
-        set_fs_root(current->fs, namespace->root, namespace->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 2f488e1d9b6c..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;
@@ -307,9 +307,7 @@ static ssize_t nfs_direct_read_schedule(struct nfs_direct_req *dreq, unsigned lo
                data->task.tk_cookie = (unsigned long) inode;
-                lock_kernel();
                rpc_execute(&data->task);
-                unlock_kernel();
                dfprintk(VFS, "NFS: %5u initiated direct read call (req %s/%Ld, %zu bytes @ offset %Lu)\n",
                                data->task.tk_pid,
@@ -475,9 +473,7 @@ static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
        dprintk("NFS: %5u initiated commit call\n", data->task.tk_pid);
-        lock_kernel();
        rpc_execute(&data->task);
-        unlock_kernel();
 }
 static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)
@@ -641,9 +637,7 @@ static ssize_t nfs_direct_write_schedule(struct nfs_direct_req *dreq, unsigned l
                data->task.tk_priority = RPC_PRIORITY_NORMAL;
                data->task.tk_cookie = (unsigned long) inode;
-                lock_kernel();
                rpc_execute(&data->task);
-                unlock_kernel();
                dfprintk(VFS, "NFS: %5u initiated direct write call (req %s/%Ld, %zu bytes @ offset %Lu)\n",
                                data->task.tk_pid,
@@ -740,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_path.dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name,
+                file->f_path.dentry->d_name.name,
                (unsigned long) count, (long long) pos);
        if (nr_segs != 1)
@@ -804,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_path.dentry->d_parent->d_name.name,
-                file->f_dentry->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 cc93865cea93..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;
@@ -307,28 +307,28 @@ static int nfs_commit_write(struct file *file, struct page *page, unsigned offse
 static void nfs_invalidate_page(struct page *page, unsigned long offset)
 {
-        struct inode *inode = page->mapping->host;
+        if (offset != 0)
+                return;
        /* Cancel any unstarted writes on this page */
-        if (offset == 0)
+        nfs_wb_page_priority(page->mapping->host, page, FLUSH_INVALIDATE);
-                nfs_sync_inode_wait(inode, page->index, 1, FLUSH_INVALIDATE);
 }
 static int nfs_release_page(struct page *page, gfp_t gfp)
 {
-        if (gfp & __GFP_FS)
+        /*
-                return !nfs_wb_page(page->mapping->host, page);
+         * Avoid deadlock on nfs_wait_on_request().
-        else
+         */
-                /*
+        if (!(gfp & __GFP_FS))
-                 * Avoid deadlock on nfs_wait_on_request().
-                 */
                return 0;
+        /* Hack... Force nfs_wb_page() to write out the page */
+        SetPageDirty(page);
+        return !nfs_wb_page(page->mapping->host, page);
 }
 const struct address_space_operations nfs_file_aops = {
        .readpage = nfs_readpage,
        .readpages = nfs_readpages,
-        .set_page_dirty = __set_page_dirty_nobuffers,
+        .set_page_dirty = nfs_set_page_dirty,
        .writepage = nfs_writepage,
        .writepages = nfs_writepages,
        .prepare_write = nfs_prepare_write,
@@ -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);
@@ -375,6 +375,12 @@ static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
        nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, count);
        result = generic_file_aio_write(iocb, iov, nr_segs, pos);
+        /* Return error values for O_SYNC and IS_SYNC() */
+        if (result >= 0 && (IS_SYNC(inode) || (iocb->ki_filp->f_flags & O_SYNC))) {
+                int err = nfs_fsync(iocb->ki_filp, dentry, 1);
+                if (err < 0)
+                        result = err;
+        }
 out:
        return result;
@@ -529,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_path.dentry->d_inode->i_sb->s_id,
-                        filp->f_dentry->d_inode->i_ino,
+                        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 15afa460e629..63e470279309 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -422,7 +422,7 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
        int err;
        /* Flush out writes to the server in order to update c/mtime */
-        nfs_sync_inode_wait(inode, 0, 0, FLUSH_NOCOMMIT);
+        nfs_sync_mapping_range(inode->i_mapping, 0, 0, FLUSH_NOCOMMIT);
        /*
         * We may force a getattr if the user cares about atime.
@@ -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/internal.h b/fs/nfs/internal.h
index d205466233f6..a28f6ce2e131 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -217,3 +217,21 @@ void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
        if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
                sb->s_maxbytes = MAX_LFS_FILESIZE;
 }
+/*
+ * Determine the number of bytes of data the page contains
+ */
+static inline
+unsigned int nfs_page_length(struct page *page)
+{
+        loff_t i_size = i_size_read(page->mapping->host);
+        if (i_size > 0) {
+                pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
+                if (page->index < end_index)
+                        return PAGE_CACHE_SIZE;
+                if (page->index == end_index)
+                        return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
+        }
+        return 0;
+}
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index e5f128ffc32d..acd8fe9762d3 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -276,51 +276,6 @@ static int nfs3_proc_read(struct nfs_read_data *rdata)
        return status;
 }
-static int nfs3_proc_write(struct nfs_write_data *wdata)
-{
-        int                     rpcflags = wdata->flags;
-        struct inode *          inode = wdata->inode;
-        struct nfs_fattr *      fattr = wdata->res.fattr;
-        struct rpc_message      msg = {
-                .rpc_proc       = &nfs3_procedures[NFS3PROC_WRITE],
-                .rpc_argp       = &wdata->args,
-                .rpc_resp       = &wdata->res,
-                .rpc_cred       = wdata->cred,
-        };
-        int                     status;
-        dprintk("NFS call  write %d @ %Ld\n", wdata->args.count,
-                        (long long) wdata->args.offset);
-        nfs_fattr_init(fattr);
-        status = rpc_call_sync(NFS_CLIENT(inode), &msg, rpcflags);
-        if (status >= 0)
-                nfs_post_op_update_inode(inode, fattr);
-        dprintk("NFS reply write: %d\n", status);
-        return status < 0? status : wdata->res.count;
-}
-static int nfs3_proc_commit(struct nfs_write_data *cdata)
-{
-        struct inode *          inode = cdata->inode;
-        struct nfs_fattr *      fattr = cdata->res.fattr;
-        struct rpc_message      msg = {
-                .rpc_proc       = &nfs3_procedures[NFS3PROC_COMMIT],
-                .rpc_argp       = &cdata->args,
-                .rpc_resp       = &cdata->res,
-                .rpc_cred       = cdata->cred,
-        };
-        int                     status;
-        dprintk("NFS call  commit %d @ %Ld\n", cdata->args.count,
-                        (long long) cdata->args.offset);
-        nfs_fattr_init(fattr);
-        status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
-        if (status >= 0)
-                nfs_post_op_update_inode(inode, fattr);
-        dprintk("NFS reply commit: %d\n", status);
-        return status;
-}
 /*
 * Create a regular file.
 * For now, we don't implement O_EXCL.
@@ -369,7 +324,7 @@ again:
        /* If the server doesn't support the exclusive creation semantics,
         * try again with simple 'guarded' mode. */
-        if (status == NFSERR_NOTSUPP) {
+        if (status == -ENOTSUPP) {
                switch (arg.createmode) {
                        case NFS3_CREATE_EXCLUSIVE:
                                arg.createmode = NFS3_CREATE_GUARDED;
@@ -690,8 +645,6 @@ nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
        };
        int                     status;
-        lock_kernel();
        if (plus)
                msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
@@ -702,7 +655,6 @@ nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
        status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
        nfs_refresh_inode(dir, &dir_attr);
        dprintk("NFS reply readdir: %d\n", status);
-        unlock_kernel();
        return status;
 }
@@ -889,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 = {
@@ -904,8 +856,6 @@ const struct nfs_rpc_ops nfs_v3_clientops = {
        .access         = nfs3_proc_access,
        .readlink       = nfs3_proc_readlink,
        .read           = nfs3_proc_read,
-        .write          = nfs3_proc_write,
-        .commit         = nfs3_proc_commit,
        .create         = nfs3_proc_create,
        .remove         = nfs3_proc_remove,
        .unlink_setup   = nfs3_proc_unlink_setup,
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 8118036cc449..ee458aeab24a 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -636,7 +636,7 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
                smp_wmb();
        } else
                status = data->rpc_status;
-        rpc_release_task(task);
+        rpc_put_task(task);
        return status;
 }
@@ -742,7 +742,7 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
                smp_wmb();
        } else
                status = data->rpc_status;
-        rpc_release_task(task);
+        rpc_put_task(task);
        if (status != 0)
                return status;
@@ -1775,89 +1775,6 @@ static int nfs4_proc_read(struct nfs_read_data *rdata)
        return err;
 }
-static int _nfs4_proc_write(struct nfs_write_data *wdata)
-{
-        int rpcflags = wdata->flags;
-        struct inode *inode = wdata->inode;
-        struct nfs_fattr *fattr = wdata->res.fattr;
-        struct nfs_server *server = NFS_SERVER(inode);
-        struct rpc_message msg = {
-                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
-                .rpc_argp       = &wdata->args,
-                .rpc_resp       = &wdata->res,
-                .rpc_cred       = wdata->cred,
-        };
-        int status;
-        dprintk("NFS call  write %d @ %Ld\n", wdata->args.count,
-                        (long long) wdata->args.offset);
-        wdata->args.bitmask = server->attr_bitmask;
-        wdata->res.server = server;
-        wdata->timestamp = jiffies;
-        nfs_fattr_init(fattr);
-        status = rpc_call_sync(server->client, &msg, rpcflags);
-        dprintk("NFS reply write: %d\n", status);
-        if (status < 0)
-                return status;
-        renew_lease(server, wdata->timestamp);
-        nfs_post_op_update_inode(inode, fattr);
-        return wdata->res.count;
-}
-static int nfs4_proc_write(struct nfs_write_data *wdata)
-{
-        struct nfs4_exception exception = { };
-        int err;
-        do {
-                err = nfs4_handle_exception(NFS_SERVER(wdata->inode),
-                                _nfs4_proc_write(wdata),
-                                &exception);
-        } while (exception.retry);
-        return err;
-}
-static int _nfs4_proc_commit(struct nfs_write_data *cdata)
-{
-        struct inode *inode = cdata->inode;
-        struct nfs_fattr *fattr = cdata->res.fattr;
-        struct nfs_server *server = NFS_SERVER(inode);
-        struct rpc_message msg = {
-                .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],
-                .rpc_argp       = &cdata->args,
-                .rpc_resp       = &cdata->res,
-                .rpc_cred       = cdata->cred,
-        };
-        int status;
-        dprintk("NFS call  commit %d @ %Ld\n", cdata->args.count,
-                        (long long) cdata->args.offset);
-        cdata->args.bitmask = server->attr_bitmask;
-        cdata->res.server = server;
-        cdata->timestamp = jiffies;
-        nfs_fattr_init(fattr);
-        status = rpc_call_sync(server->client, &msg, 0);
-        if (status >= 0)
-                renew_lease(server, cdata->timestamp);
-        dprintk("NFS reply commit: %d\n", status);
-        if (status >= 0)
-                nfs_post_op_update_inode(inode, fattr);
-        return status;
-}
-static int nfs4_proc_commit(struct nfs_write_data *cdata)
-{
-        struct nfs4_exception exception = { };
-        int err;
-        do {
-                err = nfs4_handle_exception(NFS_SERVER(cdata->inode),
-                                _nfs4_proc_commit(cdata),
-                                &exception);
-        } while (exception.retry);
-        return err;
-}
 /*
 * Got race?
 * We will need to arrange for the VFS layer to provide an atomic open.
@@ -2223,13 +2140,11 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                        dentry->d_parent->d_name.name,
                        dentry->d_name.name,
                        (unsigned long long)cookie);
-        lock_kernel();
        nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);
        res.pgbase = args.pgbase;
        status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
        if (status == 0)
                memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);
-        unlock_kernel();
        dprintk("%s: returns %d\n", __FUNCTION__, status);
        return status;
 }
@@ -3067,7 +2982,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
                if (status == 0)
                        nfs_post_op_update_inode(inode, &data->fattr);
        }
-        rpc_release_task(task);
+        rpc_put_task(task);
        return status;
 }
@@ -3314,7 +3229,7 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
        if (IS_ERR(task))
                goto out;
        status = nfs4_wait_for_completion_rpc_task(task);
-        rpc_release_task(task);
+        rpc_put_task(task);
 out:
        return status;
 }
@@ -3430,7 +3345,7 @@ static void nfs4_lock_release(void *calldata)
                task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
                                data->arg.lock_seqid);
                if (!IS_ERR(task))
-                        rpc_release_task(task);
+                        rpc_put_task(task);
                dprintk("%s: cancelling lock!\n", __FUNCTION__);
        } else
                nfs_free_seqid(data->arg.lock_seqid);
@@ -3472,7 +3387,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
                        ret = -EAGAIN;
        } else
                data->cancelled = 1;
-        rpc_release_task(task);
+        rpc_put_task(task);
        dprintk("%s: done, ret = %d!\n", __FUNCTION__, ret);
        return ret;
 }
@@ -3732,8 +3647,6 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
        .access         = nfs4_proc_access,
        .readlink       = nfs4_proc_readlink,
        .read           = nfs4_proc_read,
-        .write          = nfs4_proc_write,
-        .commit         = nfs4_proc_commit,
        .create         = nfs4_proc_create,
        .remove         = nfs4_proc_remove,
        .unlink_setup   = nfs4_proc_unlink_setup,
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 3fbfc2f03307..ca4b1d4ff42b 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -17,6 +17,7 @@
 #include <linux/nfs_page.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_mount.h>
+#include <linux/writeback.h>
 #define NFS_PARANOIA 1
@@ -268,11 +269,10 @@ nfs_coalesce_requests(struct list_head *head, struct list_head *dst,
 #define NFS_SCAN_MAXENTRIES 16
 /**
- * nfs_scan_lock_dirty - Scan the radix tree for dirty requests
+ * nfs_scan_dirty - Scan the radix tree for dirty requests
- * @nfsi: NFS inode
+ * @mapping: pointer to address space
+ * @wbc: writeback_control structure
 * @dst: Destination list
- * @idx_start: lower bound of page->index to scan
- * @npages: idx_start + npages sets the upper bound to scan.
 *
 * Moves elements from one of the inode request lists.
 * If the number of requests is set to 0, the entire address_space
@@ -280,46 +280,63 @@ nfs_coalesce_requests(struct list_head *head, struct list_head *dst,
 * The requests are *not* checked to ensure that they form a contiguous set.
 * You must be holding the inode's req_lock when calling this function
 */
-int
+long nfs_scan_dirty(struct address_space *mapping,
-nfs_scan_lock_dirty(struct nfs_inode *nfsi, struct list_head *dst,
+                        struct writeback_control *wbc,
-              unsigned long idx_start, unsigned int npages)
+                        struct list_head *dst)
 {
+        struct nfs_inode *nfsi = NFS_I(mapping->host);
        struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
        struct nfs_page *req;
-        unsigned long idx_end;
+        pgoff_t idx_start, idx_end;
+        long res = 0;
        int found, i;
-        int res;
-        res = 0;
+        if (nfsi->ndirty == 0)
-        if (npages == 0)
+                return 0;
-                idx_end = ~0;
+        if (wbc->range_cyclic) {
-        else
+                idx_start = 0;
-                idx_end = idx_start + npages - 1;
+                idx_end = ULONG_MAX;
+        } else if (wbc->range_end == 0) {
+                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
+                idx_end = ULONG_MAX;
+        } else {
+                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
+                idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
+        }
        for (;;) {
+                unsigned int toscan = NFS_SCAN_MAXENTRIES;
                found = radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree,
-                                (void **)&pgvec[0], idx_start, NFS_SCAN_MAXENTRIES,
+                                (void **)&pgvec[0], idx_start, toscan,
                                NFS_PAGE_TAG_DIRTY);
+                /* Did we make progress? */
                if (found <= 0)
                        break;
                for (i = 0; i < found; i++) {
                        req = pgvec[i];
-                        if (req->wb_index > idx_end)
+                        if (!wbc->range_cyclic && req->wb_index > idx_end)
                                goto out;
+                        /* Try to lock request and mark it for writeback */
+                        if (!nfs_set_page_writeback_locked(req))
+                                goto next;
+                        radix_tree_tag_clear(&nfsi->nfs_page_tree,
+                                        req->wb_index, NFS_PAGE_TAG_DIRTY);
+                        nfsi->ndirty--;
+                        nfs_list_remove_request(req);
+                        nfs_list_add_request(req, dst);
+                        res++;
+                        if (res == LONG_MAX)
+                                goto out;
+next:
                        idx_start = req->wb_index + 1;
-                        if (nfs_set_page_writeback_locked(req)) {
-                                radix_tree_tag_clear(&nfsi->nfs_page_tree,
-                                                req->wb_index, NFS_PAGE_TAG_DIRTY);
-                                nfs_list_remove_request(req);
-                                nfs_list_add_request(req, dst);
-                                dec_zone_page_state(req->wb_page, NR_FILE_DIRTY);
-                                res++;
-                        }
                }
        }
 out:
+        WARN_ON ((nfsi->ndirty == 0) != list_empty(&nfsi->dirty));
        return res;
 }
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 4529cc4f3f8f..560536ad74a4 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -215,32 +215,6 @@ static int nfs_proc_read(struct nfs_read_data *rdata)
        return status;
 }
-static int nfs_proc_write(struct nfs_write_data *wdata)
-{
-        int                     flags = wdata->flags;
-        struct inode *          inode = wdata->inode;
-        struct nfs_fattr *      fattr = wdata->res.fattr;
-        struct rpc_message      msg = {
-                .rpc_proc       = &nfs_procedures[NFSPROC_WRITE],
-                .rpc_argp       = &wdata->args,
-                .rpc_resp       = &wdata->res,
-                .rpc_cred       = wdata->cred,
-        };
-        int                     status;
-        dprintk("NFS call  write %d @ %Ld\n", wdata->args.count,
-                        (long long) wdata->args.offset);
-        nfs_fattr_init(fattr);
-        status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
-        if (status >= 0) {
-                nfs_post_op_update_inode(inode, fattr);
-                wdata->res.count = wdata->args.count;
-                wdata->verf.committed = NFS_FILE_SYNC;
-        }
-        dprintk("NFS reply write: %d\n", status);
-        return status < 0? status : wdata->res.count;
-}
 static int
 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                int flags, struct nameidata *nd)
@@ -545,13 +519,10 @@ nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
        };
        int                     status;
-        lock_kernel();
        dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
        status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
        dprintk("NFS reply readdir: %d\n", status);
-        unlock_kernel();
        return status;
 }
@@ -680,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);
 }
@@ -696,8 +667,6 @@ const struct nfs_rpc_ops nfs_v2_clientops = {
        .access         = NULL,                /* access */
        .readlink       = nfs_proc_readlink,
        .read           = nfs_proc_read,
-        .write          = nfs_proc_write,
-        .commit         = NULL,                /* commit */
        .create         = nfs_proc_create,
        .remove         = nfs_proc_remove,
        .unlink_setup   = nfs_proc_unlink_setup,
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 244a8c45b68e..a9c26521a9e2 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -30,6 +30,7 @@
 #include <asm/system.h>
+#include "internal.h"
 #include "iostat.h"
 #define NFSDBG_FACILITY         NFSDBG_PAGECACHE
@@ -65,32 +66,22 @@ struct nfs_read_data *nfs_readdata_alloc(size_t len)
        return p;
 }
-static void nfs_readdata_free(struct nfs_read_data *p)
+static void nfs_readdata_rcu_free(struct rcu_head *head)
 {
+        struct nfs_read_data *p = container_of(head, struct nfs_read_data, task.u.tk_rcu);
        if (p && (p->pagevec != &p->page_array[0]))
                kfree(p->pagevec);
        mempool_free(p, nfs_rdata_mempool);
 }
-void nfs_readdata_release(void *data)
+static void nfs_readdata_free(struct nfs_read_data *rdata)
 {
-        nfs_readdata_free(data);
+        call_rcu_bh(&rdata->task.u.tk_rcu, nfs_readdata_rcu_free);
 }
-static
+void nfs_readdata_release(void *data)
-unsigned int nfs_page_length(struct inode *inode, struct page *page)
 {
-        loff_t i_size = i_size_read(inode);
+        nfs_readdata_free(data);
-        unsigned long idx;
-        if (i_size <= 0)
-                return 0;
-        idx = (i_size - 1) >> PAGE_CACHE_SHIFT;
-        if (page->index > idx)
-                return 0;
-        if (page->index != idx)
-                return PAGE_CACHE_SIZE;
-        return 1 + ((i_size - 1) & (PAGE_CACHE_SIZE - 1));
 }
 static
@@ -139,12 +130,12 @@ static int nfs_readpage_sync(struct nfs_open_context *ctx, struct inode *inode,
 {
        unsigned int    rsize = NFS_SERVER(inode)->rsize;
        unsigned int    count = PAGE_CACHE_SIZE;
-        int             result;
+        int result = -ENOMEM;
        struct nfs_read_data *rdata;
        rdata = nfs_readdata_alloc(count);
        if (!rdata)
-                return -ENOMEM;
+                goto out_unlock;
        memset(rdata, 0, sizeof(*rdata));
        rdata->flags = (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
@@ -212,8 +203,9 @@ static int nfs_readpage_sync(struct nfs_open_context *ctx, struct inode *inode,
        result = 0;
 io_error:
-        unlock_page(page);
        nfs_readdata_free(rdata);
+out_unlock:
+        unlock_page(page);
        return result;
 }
@@ -224,7 +216,7 @@ static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
        struct nfs_page *new;
        unsigned int len;
-        len = nfs_page_length(inode, page);
+        len = nfs_page_length(page);
        if (len == 0)
                return nfs_return_empty_page(page);
        new = nfs_create_request(ctx, inode, page, 0, len);
@@ -316,9 +308,7 @@ static void nfs_execute_read(struct nfs_read_data *data)
        sigset_t oldset;
        rpc_clnt_sigmask(clnt, &oldset);
-        lock_kernel();
        rpc_execute(&data->task);
-        unlock_kernel();
        rpc_clnt_sigunmask(clnt, &oldset);
 }
@@ -455,6 +445,55 @@ nfs_pagein_list(struct list_head *head, int rpages)
 }
 /*
+ * This is the callback from RPC telling us whether a reply was
+ * received or some error occurred (timeout or socket shutdown).
+ */
+int nfs_readpage_result(struct rpc_task *task, struct nfs_read_data *data)
+{
+        int status;
+        dprintk("%s: %4d, (status %d)\n", __FUNCTION__, task->tk_pid,
+                        task->tk_status);
+        status = NFS_PROTO(data->inode)->read_done(task, data);
+        if (status != 0)
+                return status;
+        nfs_add_stats(data->inode, NFSIOS_SERVERREADBYTES, data->res.count);
+        if (task->tk_status == -ESTALE) {
+                set_bit(NFS_INO_STALE, &NFS_FLAGS(data->inode));
+                nfs_mark_for_revalidate(data->inode);
+        }
+        spin_lock(&data->inode->i_lock);
+        NFS_I(data->inode)->cache_validity |= NFS_INO_INVALID_ATIME;
+        spin_unlock(&data->inode->i_lock);
+        return 0;
+}
+static int nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data)
+{
+        struct nfs_readargs *argp = &data->args;
+        struct nfs_readres *resp = &data->res;
+        if (resp->eof || resp->count == argp->count)
+                return 0;
+        /* This is a short read! */
+        nfs_inc_stats(data->inode, NFSIOS_SHORTREAD);
+        /* Has the server at least made some progress? */
+        if (resp->count == 0)
+                return 0;
+        /* Yes, so retry the read at the end of the data */
+        argp->offset += resp->count;
+        argp->pgbase += resp->count;
+        argp->count -= resp->count;
+        rpc_restart_call(task);
+        return -EAGAIN;
+}
+/*
 * Handle a read reply that fills part of a page.
 */
 static void nfs_readpage_result_partial(struct rpc_task *task, void *calldata)
@@ -463,12 +502,16 @@ static void nfs_readpage_result_partial(struct rpc_task *task, void *calldata)
        struct nfs_page *req = data->req;
        struct page *page = req->wb_page;
 
-        if (likely(task->tk_status >= 0))
-                nfs_readpage_truncate_uninitialised_page(data);
-        else
-                SetPageError(page);
        if (nfs_readpage_result(task, data) != 0)
                return;
+        if (likely(task->tk_status >= 0)) {
+                nfs_readpage_truncate_uninitialised_page(data);
+                if (nfs_readpage_retry(task, data) != 0)
+                        return;
+        }
+        if (unlikely(task->tk_status < 0))
+                SetPageError(page);
        if (atomic_dec_and_test(&req->wb_complete)) {
                if (!PageError(page))
                        SetPageUptodate(page);
@@ -496,25 +539,13 @@ static void nfs_readpage_set_pages_uptodate(struct nfs_read_data *data)
        count += base;
        for (;count >= PAGE_CACHE_SIZE; count -= PAGE_CACHE_SIZE, pages++)
                SetPageUptodate(*pages);
-        if (count != 0)
+        if (count == 0)
+                return;
+        /* Was this a short read? */
+        if (data->res.eof || data->res.count == data->args.count)
                SetPageUptodate(*pages);
 }
-static void nfs_readpage_set_pages_error(struct nfs_read_data *data)
-{
-        unsigned int count = data->args.count;
-        unsigned int base = data->args.pgbase;
-        struct page **pages;
-        pages = &data->args.pages[base >> PAGE_CACHE_SHIFT];
-        base &= ~PAGE_CACHE_MASK;
-        count += base;
-        for (;count >= PAGE_CACHE_SIZE; count -= PAGE_CACHE_SIZE, pages++)
-                SetPageError(*pages);
-        if (count != 0)
-                SetPageError(*pages);
-}
 /*
 * This is the callback from RPC telling us whether a reply was
 * received or some error occurred (timeout or socket shutdown).
@@ -523,19 +554,20 @@ static void nfs_readpage_result_full(struct rpc_task *task, void *calldata)
 {
        struct nfs_read_data *data = calldata;
+        if (nfs_readpage_result(task, data) != 0)
+                return;
        /*
-         * Note: nfs_readpage_result may change the values of
+         * Note: nfs_readpage_retry may change the values of
         * data->args. In the multi-page case, we therefore need
-         * to ensure that we call the next nfs_readpage_set_page_uptodate()
+         * to ensure that we call nfs_readpage_set_pages_uptodate()
-         * first in the multi-page case.
+         * first.
         */
        if (likely(task->tk_status >= 0)) {
                nfs_readpage_truncate_uninitialised_page(data);
                nfs_readpage_set_pages_uptodate(data);
-        } else
+                if (nfs_readpage_retry(task, data) != 0)
-                nfs_readpage_set_pages_error(data);
+                        return;
-        if (nfs_readpage_result(task, data) != 0)
+        }
-                return;
        while (!list_empty(&data->pages)) {
                struct nfs_page *req = nfs_list_entry(data->pages.next);
@@ -550,50 +582,6 @@ static const struct rpc_call_ops nfs_read_full_ops = {
 };
 /*
- * This is the callback from RPC telling us whether a reply was
- * received or some error occurred (timeout or socket shutdown).
- */
-int nfs_readpage_result(struct rpc_task *task, struct nfs_read_data *data)
-{
-        struct nfs_readargs *argp = &data->args;
-        struct nfs_readres *resp = &data->res;
-        int status;
-        dprintk("NFS: %4d nfs_readpage_result, (status %d)\n",
-                task->tk_pid, task->tk_status);
-        status = NFS_PROTO(data->inode)->read_done(task, data);
-        if (status != 0)
-                return status;
-        nfs_add_stats(data->inode, NFSIOS_SERVERREADBYTES, resp->count);
-        if (task->tk_status < 0) {
-                if (task->tk_status == -ESTALE) {
-                        set_bit(NFS_INO_STALE, &NFS_FLAGS(data->inode));
-                        nfs_mark_for_revalidate(data->inode);
-                }
-        } else if (resp->count < argp->count && !resp->eof) {
-                /* This is a short read! */
-                nfs_inc_stats(data->inode, NFSIOS_SHORTREAD);
-                /* Has the server at least made some progress? */
-                if (resp->count != 0) {
-                        /* Yes, so retry the read at the end of the data */
-                        argp->offset += resp->count;
-                        argp->pgbase += resp->count;
-                        argp->count -= resp->count;
-                        rpc_restart_call(task);
-                        return -EAGAIN;
-                }
-                task->tk_status = -EIO;
-        }
-        spin_lock(&data->inode->i_lock);
-        NFS_I(data->inode)->cache_validity |= NFS_INO_INVALID_ATIME;
-        spin_unlock(&data->inode->i_lock);
-        return 0;
-}
-/*
 * Read a page over NFS.
 * We read the page synchronously in the following case:
 *  -   The error flag is set for this page. This happens only when a
@@ -626,9 +614,10 @@ int nfs_readpage(struct file *file, struct page *page)
                goto out_error;
        if (file == NULL) {
+                error = -EBADF;
                ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
                if (ctx == NULL)
-                        return -EBADF;
+                        goto out_error;
        } else
                ctx = get_nfs_open_context((struct nfs_open_context *)
                                file->private_data);
@@ -663,7 +652,7 @@ readpage_async_filler(void *data, struct page *page)
        unsigned int len;
        nfs_wb_page(inode, page);
-        len = nfs_page_length(inode, page);
+        len = nfs_page_length(page);
        if (len == 0)
                return nfs_return_empty_page(page);
        new = nfs_create_request(desc->ctx, inode, page, 0, len);
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index 600bbe630abd..6c686112cc03 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -33,9 +33,7 @@ static int nfs_symlink_filler(struct inode *inode, struct page *page)
 {
        int error;
-        lock_kernel();
        error = NFS_PROTO(inode)->readlink(inode, page, 0, PAGE_SIZE);
-        unlock_kernel();
        if (error < 0)
                goto error;
        SetPageUptodate(page);
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 41b07288f99e..345492e78643 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -63,6 +63,7 @@
 #include <linux/smp_lock.h>
 #include "delegation.h"
+#include "internal.h"
 #include "iostat.h"
 #define NFSDBG_FACILITY         NFSDBG_PAGECACHE
@@ -74,13 +75,12 @@
 * Local function declarations
 */
 static struct nfs_page * nfs_update_request(struct nfs_open_context*,
-                                            struct inode *,
                                            struct page *,
                                            unsigned int, unsigned int);
+static void nfs_mark_request_dirty(struct nfs_page *req);
 static int nfs_wait_on_write_congestion(struct address_space *, int);
 static int nfs_wait_on_requests(struct inode *, unsigned long, unsigned int);
-static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,
+static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how);
-                           unsigned int npages, int how);
 static const struct rpc_call_ops nfs_write_partial_ops;
 static const struct rpc_call_ops nfs_write_full_ops;
 static const struct rpc_call_ops nfs_commit_ops;
@@ -102,13 +102,19 @@ struct nfs_write_data *nfs_commit_alloc(void)
        return p;
 }
-void nfs_commit_free(struct nfs_write_data *p)
+void nfs_commit_rcu_free(struct rcu_head *head)
 {
+        struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
        if (p && (p->pagevec != &p->page_array[0]))
                kfree(p->pagevec);
        mempool_free(p, nfs_commit_mempool);
 }
+void nfs_commit_free(struct nfs_write_data *wdata)
+{
+        call_rcu_bh(&wdata->task.u.tk_rcu, nfs_commit_rcu_free);
+}
 struct nfs_write_data *nfs_writedata_alloc(size_t len)
 {
        unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
@@ -131,18 +137,47 @@ struct nfs_write_data *nfs_writedata_alloc(size_t len)
        return p;
 }
-static void nfs_writedata_free(struct nfs_write_data *p)
+static void nfs_writedata_rcu_free(struct rcu_head *head)
 {
+        struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
        if (p && (p->pagevec != &p->page_array[0]))
                kfree(p->pagevec);
        mempool_free(p, nfs_wdata_mempool);
 }
+static void nfs_writedata_free(struct nfs_write_data *wdata)
+{
+        call_rcu_bh(&wdata->task.u.tk_rcu, nfs_writedata_rcu_free);
+}
 void nfs_writedata_release(void *wdata)
 {
        nfs_writedata_free(wdata);
 }
+static struct nfs_page *nfs_page_find_request_locked(struct page *page)
+{
+        struct nfs_page *req = NULL;
+        if (PagePrivate(page)) {
+                req = (struct nfs_page *)page_private(page);
+                if (req != NULL)
+                        atomic_inc(&req->wb_count);
+        }
+        return req;
+}
+static struct nfs_page *nfs_page_find_request(struct page *page)
+{
+        struct nfs_page *req = NULL;
+        spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
+        spin_lock(req_lock);
+        req = nfs_page_find_request_locked(page);
+        spin_unlock(req_lock);
+        return req;
+}
 /* Adjust the file length if we're writing beyond the end */
 static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
 {
@@ -164,113 +199,34 @@ static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int c
 */
 static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int count)
 {
-        loff_t end_offs;
        if (PageUptodate(page))
                return;
        if (base != 0)
                return;
-        if (count == PAGE_CACHE_SIZE) {
+        if (count != nfs_page_length(page))
-                SetPageUptodate(page);
-                return;
-        }
-        end_offs = i_size_read(page->mapping->host) - 1;
-        if (end_offs < 0)
                return;
-        /* Is this the last page? */
+        if (count != PAGE_CACHE_SIZE)
-        if (page->index != (unsigned long)(end_offs >> PAGE_CACHE_SHIFT))
-                return;
-        /* This is the last page: set PG_uptodate if we cover the entire
-         * extent of the data, then zero the rest of the page.
-         */
-        if (count == (unsigned int)(end_offs & (PAGE_CACHE_SIZE - 1)) + 1) {
                memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
-                SetPageUptodate(page);
+        SetPageUptodate(page);
-        }
 }
-/*
+static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
- * Write a page synchronously.
- * Offset is the data offset within the page.
- */
-static int nfs_writepage_sync(struct nfs_open_context *ctx, struct inode *inode,
-                struct page *page, unsigned int offset, unsigned int count,
-                int how)
-{
-        unsigned int    wsize = NFS_SERVER(inode)->wsize;
-        int             result, written = 0;
-        struct nfs_write_data *wdata;
-        wdata = nfs_writedata_alloc(wsize);
-        if (!wdata)
-                return -ENOMEM;
-        wdata->flags = how;
-        wdata->cred = ctx->cred;
-        wdata->inode = inode;
-        wdata->args.fh = NFS_FH(inode);
-        wdata->args.context = ctx;
-        wdata->args.pages = &page;
-        wdata->args.stable = NFS_FILE_SYNC;
-        wdata->args.pgbase = offset;
-        wdata->args.count = wsize;
-        wdata->res.fattr = &wdata->fattr;
-        wdata->res.verf = &wdata->verf;
-        dprintk("NFS:      nfs_writepage_sync(%s/%Ld %d@%Ld)\n",
-                inode->i_sb->s_id,
-                (long long)NFS_FILEID(inode),
-                count, (long long)(page_offset(page) + offset));
-        set_page_writeback(page);
-        nfs_begin_data_update(inode);
-        do {
-                if (count < wsize)
-                        wdata->args.count = count;
-                wdata->args.offset = page_offset(page) + wdata->args.pgbase;
-                result = NFS_PROTO(inode)->write(wdata);
-                if (result < 0) {
-                        /* Must mark the page invalid after I/O error */
-                        ClearPageUptodate(page);
-                        goto io_error;
-                }
-                if (result < wdata->args.count)
-                        printk(KERN_WARNING "NFS: short write, count=%u, result=%d\n",
-                                        wdata->args.count, result);
-                wdata->args.offset += result;
-                wdata->args.pgbase += result;
-                written += result;
-                count -= result;
-                nfs_add_stats(inode, NFSIOS_SERVERWRITTENBYTES, result);
-        } while (count);
-        /* Update file length */
-        nfs_grow_file(page, offset, written);
-        /* Set the PG_uptodate flag? */
-        nfs_mark_uptodate(page, offset, written);
-        if (PageError(page))
-                ClearPageError(page);
-io_error:
-        nfs_end_data_update(inode);
-        end_page_writeback(page);
-        nfs_writedata_free(wdata);
-        return written ? written : result;
-}
-static int nfs_writepage_async(struct nfs_open_context *ctx,
-                struct inode *inode, struct page *page,
                unsigned int offset, unsigned int count)
 {
        struct nfs_page *req;
+        int ret;
-        req = nfs_update_request(ctx, inode, page, offset, count);
+        for (;;) {
-        if (IS_ERR(req))
+                req = nfs_update_request(ctx, page, offset, count);
-                return PTR_ERR(req);
+                if (!IS_ERR(req))
+                        break;
+                ret = PTR_ERR(req);
+                if (ret != -EBUSY)
+                        return ret;
+                ret = nfs_wb_page(page->mapping->host, page);
+                if (ret != 0)
+                        return ret;
+        }
        /* Update file length */
        nfs_grow_file(page, offset, count);
        /* Set the PG_uptodate flag? */
@@ -289,73 +245,94 @@ static int wb_priority(struct writeback_control *wbc)
 }
 /*
+ * Find an associated nfs write request, and prepare to flush it out
+ * Returns 1 if there was no write request, or if the request was
+ * already tagged by nfs_set_page_dirty.Returns 0 if the request
+ * was not tagged.
+ * May also return an error if the user signalled nfs_wait_on_request().
+ */
+static int nfs_page_mark_flush(struct page *page)
+{
+        struct nfs_page *req;
+        spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
+        int ret;
+        spin_lock(req_lock);
+        for(;;) {
+                req = nfs_page_find_request_locked(page);
+                if (req == NULL) {
+                        spin_unlock(req_lock);
+                        return 1;
+                }
+                if (nfs_lock_request_dontget(req))
+                        break;
+                /* Note: If we hold the page lock, as is the case in nfs_writepage,
+                 *       then the call to nfs_lock_request_dontget() will always
+                 *       succeed provided that someone hasn't already marked the
+                 *       request as dirty (in which case we don't care).
+                 */
+                spin_unlock(req_lock);
+                ret = nfs_wait_on_request(req);
+                nfs_release_request(req);
+                if (ret != 0)
+                        return ret;
+                spin_lock(req_lock);
+        }
+        spin_unlock(req_lock);
+        if (test_and_set_bit(PG_FLUSHING, &req->wb_flags) == 0) {
+                nfs_mark_request_dirty(req);
+                set_page_writeback(page);
+        }
+        ret = test_bit(PG_NEED_FLUSH, &req->wb_flags);
+        nfs_unlock_request(req);
+        return ret;
+}
+/*
 * Write an mmapped page to the server.
 */
-int nfs_writepage(struct page *page, struct writeback_control *wbc)
+static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc)
 {
        struct nfs_open_context *ctx;
        struct inode *inode = page->mapping->host;
-        unsigned long end_index;
+        unsigned offset;
-        unsigned offset = PAGE_CACHE_SIZE;
-        loff_t i_size = i_size_read(inode);
-        int inode_referenced = 0;
-        int priority = wb_priority(wbc);
        int err;
        nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
        nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
-        /*
+        err = nfs_page_mark_flush(page);
-         * Note: We need to ensure that we have a reference to the inode
+        if (err <= 0)
-         *       if we are to do asynchronous writes. If not, waiting
+                goto out;
-         *       in nfs_wait_on_request() may deadlock with clear_inode().
+        err = 0;
-         *
+        offset = nfs_page_length(page);
-         *       If igrab() fails here, then it is in any case safe to
+        if (!offset)
-         *       call nfs_wb_page(), since there will be no pending writes.
-         */
-        if (igrab(inode) != 0)
-                inode_referenced = 1;
-        end_index = i_size >> PAGE_CACHE_SHIFT;
-        /* Ensure we've flushed out any previous writes */
-        nfs_wb_page_priority(inode, page, priority);
-        /* easy case */
-        if (page->index < end_index)
-                goto do_it;
-        /* things got complicated... */
-        offset = i_size & (PAGE_CACHE_SIZE-1);
-        /* OK, are we completely out? */
-        err = 0; /* potential race with truncate - ignore */
-        if (page->index >= end_index+1 || !offset)
                goto out;
-do_it:
        ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE);
        if (ctx == NULL) {
                err = -EBADF;
                goto out;
        }
-        lock_kernel();
+        err = nfs_writepage_setup(ctx, page, 0, offset);
-        if (!IS_SYNC(inode) && inode_referenced) {
-                err = nfs_writepage_async(ctx, inode, page, 0, offset);
-                if (!wbc->for_writepages)
-                        nfs_flush_inode(inode, 0, 0, wb_priority(wbc));
-        } else {
-                err = nfs_writepage_sync(ctx, inode, page, 0,
-                                                offset, priority);
-                if (err >= 0) {
-                        if (err != offset)
-                                redirty_page_for_writepage(wbc, page);
-                        err = 0;
-                }
-        }
-        unlock_kernel();
        put_nfs_open_context(ctx);
+        if (err != 0)
+                goto out;
+        err = nfs_page_mark_flush(page);
+        if (err > 0)
+                err = 0;
 out:
+        if (!wbc->for_writepages)
+                nfs_flush_mapping(page->mapping, wbc, wb_priority(wbc));
+        return err;
+}
+int nfs_writepage(struct page *page, struct writeback_control *wbc)
+{
+        int err;
+        err = nfs_writepage_locked(page, wbc);
        unlock_page(page);
-        if (inode_referenced)
-                iput(inode);
        return err; 
 }
@@ -379,21 +356,18 @@ int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
                        return 0;
                nfs_wait_on_write_congestion(mapping, 0);
        }
-        err = nfs_flush_inode(inode, 0, 0, wb_priority(wbc));
+        err = nfs_flush_mapping(mapping, wbc, wb_priority(wbc));
        if (err < 0)
                goto out;
        nfs_add_stats(inode, NFSIOS_WRITEPAGES, err);
-        wbc->nr_to_write -= err;
        if (!wbc->nonblocking && wbc->sync_mode == WB_SYNC_ALL) {
                err = nfs_wait_on_requests(inode, 0, 0);
                if (err < 0)
                        goto out;
        }
        err = nfs_commit_inode(inode, wb_priority(wbc));
-        if (err > 0) {
+        if (err > 0)
-                wbc->nr_to_write -= err;
                err = 0;
-        }
 out:
        clear_bit(BDI_write_congested, &bdi->state);
        wake_up_all(&nfs_write_congestion);
@@ -420,6 +394,7 @@ static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
                        nfsi->change_attr++;
        }
        SetPagePrivate(req->wb_page);
+        set_page_private(req->wb_page, (unsigned long)req);
        nfsi->npages++;
        atomic_inc(&req->wb_count);
        return 0;
@@ -436,6 +411,7 @@ static void nfs_inode_remove_request(struct nfs_page *req)
        BUG_ON (!NFS_WBACK_BUSY(req));
        spin_lock(&nfsi->req_lock);
+        set_page_private(req->wb_page, 0);
        ClearPagePrivate(req->wb_page);
        radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
        nfsi->npages--;
@@ -450,33 +426,6 @@ static void nfs_inode_remove_request(struct nfs_page *req)
 }
 /*
- * Find a request
- */
-static inline struct nfs_page *
-_nfs_find_request(struct inode *inode, unsigned long index)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-        struct nfs_page *req;
-        req = (struct nfs_page*)radix_tree_lookup(&nfsi->nfs_page_tree, index);
-        if (req)
-                atomic_inc(&req->wb_count);
-        return req;
-}
-static struct nfs_page *
-nfs_find_request(struct inode *inode, unsigned long index)
-{
-        struct nfs_page         *req;
-        struct nfs_inode        *nfsi = NFS_I(inode);
-        spin_lock(&nfsi->req_lock);
-        req = _nfs_find_request(inode, index);
-        spin_unlock(&nfsi->req_lock);
-        return req;
-}
-/*
 * Add a request to the inode's dirty list.
 */
 static void
@@ -491,8 +440,14 @@ nfs_mark_request_dirty(struct nfs_page *req)
        nfs_list_add_request(req, &nfsi->dirty);
        nfsi->ndirty++;
        spin_unlock(&nfsi->req_lock);
-        inc_zone_page_state(req->wb_page, NR_FILE_DIRTY);
+        __mark_inode_dirty(inode, I_DIRTY_PAGES);
-        mark_inode_dirty(inode);
+}
+static void
+nfs_redirty_request(struct nfs_page *req)
+{
+        clear_bit(PG_FLUSHING, &req->wb_flags);
+        __set_page_dirty_nobuffers(req->wb_page);
 }
 /*
@@ -501,8 +456,7 @@ nfs_mark_request_dirty(struct nfs_page *req)
 static inline int
 nfs_dirty_request(struct nfs_page *req)
 {
-        struct nfs_inode *nfsi = NFS_I(req->wb_context->dentry->d_inode);
+        return test_bit(PG_FLUSHING, &req->wb_flags) == 0;
-        return !list_empty(&req->wb_list) && req->wb_list_head == &nfsi->dirty;
 }
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
@@ -520,7 +474,7 @@ nfs_mark_request_commit(struct nfs_page *req)
        nfsi->ncommit++;
        spin_unlock(&nfsi->req_lock);
        inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
-        mark_inode_dirty(inode);
+        __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
 }
 #endif
@@ -597,31 +551,6 @@ static void nfs_cancel_commit_list(struct list_head *head)
        }
 }
-/*
- * nfs_scan_dirty - Scan an inode for dirty requests
- * @inode: NFS inode to scan
- * @dst: destination list
- * @idx_start: lower bound of page->index to scan.
- * @npages: idx_start + npages sets the upper bound to scan.
- *
- * Moves requests from the inode's dirty page list.
- * The requests are *not* checked to ensure that they form a contiguous set.
- */
-static int
-nfs_scan_dirty(struct inode *inode, struct list_head *dst, unsigned long idx_start, unsigned int npages)
-{
-        struct nfs_inode *nfsi = NFS_I(inode);
-        int res = 0;
-        if (nfsi->ndirty != 0) {
-                res = nfs_scan_lock_dirty(nfsi, dst, idx_start, npages);
-                nfsi->ndirty -= res;
-                if ((nfsi->ndirty == 0) != list_empty(&nfsi->dirty))
-                        printk(KERN_ERR "NFS: desynchronized value of nfs_i.ndirty.\n");
-        }
-        return res;
-}
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
 /*
 * nfs_scan_commit - Scan an inode for commit requests
@@ -698,27 +627,27 @@ static int nfs_wait_on_write_congestion(struct address_space *mapping, int intr)
 * Note: Should always be called with the Page Lock held!
 */
 static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
-                struct inode *inode, struct page *page,
+                struct page *page, unsigned int offset, unsigned int bytes)
-                unsigned int offset, unsigned int bytes)
 {
-        struct nfs_server *server = NFS_SERVER(inode);
+        struct inode *inode = page->mapping->host;
        struct nfs_inode *nfsi = NFS_I(inode);
        struct nfs_page         *req, *new = NULL;
        unsigned long           rqend, end;
        end = offset + bytes;
-        if (nfs_wait_on_write_congestion(page->mapping, server->flags & NFS_MOUNT_INTR))
+        if (nfs_wait_on_write_congestion(page->mapping, NFS_SERVER(inode)->flags & NFS_MOUNT_INTR))
                return ERR_PTR(-ERESTARTSYS);
        for (;;) {
                /* Loop over all inode entries and see if we find
                 * A request for the page we wish to update
                 */
                spin_lock(&nfsi->req_lock);
-                req = _nfs_find_request(inode, page->index);
+                req = nfs_page_find_request_locked(page);
                if (req) {
                        if (!nfs_lock_request_dontget(req)) {
                                int error;
                                spin_unlock(&nfsi->req_lock);
                                error = nfs_wait_on_request(req);
                                nfs_release_request(req);
@@ -745,7 +674,6 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
                                return ERR_PTR(error);
                        }
                        spin_unlock(&nfsi->req_lock);
-                        nfs_mark_request_dirty(new);
                        return new;
                }
                spin_unlock(&nfsi->req_lock);
@@ -786,9 +714,8 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
 int nfs_flush_incompatible(struct file *file, struct page *page)
 {
        struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
-        struct inode    *inode = page->mapping->host;
        struct nfs_page *req;
-        int             status = 0;
+        int do_flush, status;
        /*
         * Look for a request corresponding to this page. If there
         * is one, and it belongs to another file, we flush it out
@@ -797,13 +724,18 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
         * Also do the same if we find a request from an existing
         * dropped page.
         */
-        req = nfs_find_request(inode, page->index);
+        do {
-        if (req) {
+                req = nfs_page_find_request(page);
-                if (req->wb_page != page || ctx != req->wb_context)
+                if (req == NULL)
-                        status = nfs_wb_page(inode, page);
+                        return 0;
+                do_flush = req->wb_page != page || req->wb_context != ctx
+                        || !nfs_dirty_request(req);
                nfs_release_request(req);
-        }
+                if (!do_flush)
-        return (status < 0) ? status : 0;
+                        return 0;
+                status = nfs_wb_page(page->mapping->host, page);
+        } while (status == 0);
+        return status;
 }
 /*
@@ -817,72 +749,27 @@ int nfs_updatepage(struct file *file, struct page *page,
 {
        struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
        struct inode    *inode = page->mapping->host;
-        struct nfs_page *req;
        int             status = 0;
        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_path.dentry->d_parent->d_name.name,
-                file->f_dentry->d_name.name, count,
+                file->f_path.dentry->d_name.name, count,
                (long long)(page_offset(page) +offset));
-        if (IS_SYNC(inode)) {
-                status = nfs_writepage_sync(ctx, inode, page, offset, count, 0);
-                if (status > 0) {
-                        if (offset == 0 && status == PAGE_CACHE_SIZE)
-                                SetPageUptodate(page);
-                        return 0;
-                }
-                return status;
-        }
        /* If we're not using byte range locks, and we know the page
         * is entirely in cache, it may be more efficient to avoid
         * fragmenting write requests.
         */
        if (PageUptodate(page) && inode->i_flock == NULL && !(file->f_mode & O_SYNC)) {
-                loff_t end_offs = i_size_read(inode) - 1;
+                count = max(count + offset, nfs_page_length(page));
-                unsigned long end_index = end_offs >> PAGE_CACHE_SHIFT;
-                count += offset;
                offset = 0;
-                if (unlikely(end_offs < 0)) {
-                        /* Do nothing */
-                } else if (page->index == end_index) {
-                        unsigned int pglen;
-                        pglen = (unsigned int)(end_offs & (PAGE_CACHE_SIZE-1)) + 1;
-                        if (count < pglen)
-                                count = pglen;
-                } else if (page->index < end_index)
-                        count = PAGE_CACHE_SIZE;
        }
-        /*
+        status = nfs_writepage_setup(ctx, page, offset, count);
-         * Try to find an NFS request corresponding to this page
+        __set_page_dirty_nobuffers(page);
-         * and update it.
-         * If the existing request cannot be updated, we must flush
-         * it out now.
-         */
-        do {
-                req = nfs_update_request(ctx, inode, page, offset, count);
-                status = (IS_ERR(req)) ? PTR_ERR(req) : 0;
-                if (status != -EBUSY)
-                        break;
-                /* Request could not be updated. Flush it out and try again */
-                status = nfs_wb_page(inode, page);
-        } while (status >= 0);
-        if (status < 0)
-                goto done;
-        status = 0;
-        /* Update file length */
-        nfs_grow_file(page, offset, count);
-        /* Set the PG_uptodate flag? */
-        nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
-        nfs_unlock_request(req);
-done:
        dprintk("NFS:      nfs_updatepage returns %d (isize %Ld)\n",
                        status, (long long)i_size_read(inode));
        if (status < 0)
@@ -897,7 +784,7 @@ static void nfs_writepage_release(struct nfs_page *req)
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
        if (!PageError(req->wb_page)) {
                if (NFS_NEED_RESCHED(req)) {
-                        nfs_mark_request_dirty(req);
+                        nfs_redirty_request(req);
                        goto out;
                } else if (NFS_NEED_COMMIT(req)) {
                        nfs_mark_request_commit(req);
@@ -979,9 +866,7 @@ static void nfs_execute_write(struct nfs_write_data *data)
        sigset_t oldset;
        rpc_clnt_sigmask(clnt, &oldset);
-        lock_kernel();
        rpc_execute(&data->task);
-        unlock_kernel();
        rpc_clnt_sigunmask(clnt, &oldset);
 }
@@ -1015,7 +900,6 @@ static int nfs_flush_multi(struct inode *inode, struct list_head *head, int how)
        atomic_set(&req->wb_complete, requests);
        ClearPageError(page);
-        set_page_writeback(page);
        offset = 0;
        nbytes = req->wb_bytes;
        do {
@@ -1043,9 +927,9 @@ out_bad:
        while (!list_empty(&list)) {
                data = list_entry(list.next, struct nfs_write_data, pages);
                list_del(&data->pages);
-                nfs_writedata_free(data);
+                nfs_writedata_release(data);
        }
-        nfs_mark_request_dirty(req);
+        nfs_redirty_request(req);
        nfs_clear_page_writeback(req);
        return -ENOMEM;
 }
@@ -1076,7 +960,6 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, int how)
                nfs_list_remove_request(req);
                nfs_list_add_request(req, &data->pages);
                ClearPageError(req->wb_page);
-                set_page_writeback(req->wb_page);
                *pages++ = req->wb_page;
                count += req->wb_bytes;
        }
@@ -1091,7 +974,7 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, int how)
        while (!list_empty(head)) {
                struct nfs_page *req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
-                nfs_mark_request_dirty(req);
+                nfs_redirty_request(req);
                nfs_clear_page_writeback(req);
        }
        return -ENOMEM;
@@ -1126,7 +1009,7 @@ out_err:
        while (!list_empty(head)) {
                req = nfs_list_entry(head->next);
                nfs_list_remove_request(req);
-                nfs_mark_request_dirty(req);
+                nfs_redirty_request(req);
                nfs_clear_page_writeback(req);
        }
        return error;
@@ -1442,7 +1325,7 @@ static void nfs_commit_done(struct rpc_task *task, void *calldata)
                }
                /* We have a mismatch. Write the page again */
                dprintk(" mismatch\n");
-                nfs_mark_request_dirty(req);
+                nfs_redirty_request(req);
        next:
                nfs_clear_page_writeback(req);
        }
@@ -1459,18 +1342,17 @@ static inline int nfs_commit_list(struct inode *inode, struct list_head *head, i
 }
 #endif
-static int nfs_flush_inode(struct inode *inode, unsigned long idx_start,
+static long nfs_flush_mapping(struct address_space *mapping, struct writeback_control *wbc, int how)
-                           unsigned int npages, int how)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
+        struct nfs_inode *nfsi = NFS_I(mapping->host);
        LIST_HEAD(head);
-        int res;
+        long res;
        spin_lock(&nfsi->req_lock);
-        res = nfs_scan_dirty(inode, &head, idx_start, npages);
+        res = nfs_scan_dirty(mapping, wbc, &head);
        spin_unlock(&nfsi->req_lock);
        if (res) {
-                int error = nfs_flush_list(inode, &head, res, how);
+                int error = nfs_flush_list(mapping->host, &head, res, how);
                if (error < 0)
                        return error;
        }
@@ -1496,38 +1378,62 @@ int nfs_commit_inode(struct inode *inode, int how)
 }
 #endif
-int nfs_sync_inode_wait(struct inode *inode, unsigned long idx_start,
+long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
-                unsigned int npages, int how)
 {
+        struct inode *inode = mapping->host;
        struct nfs_inode *nfsi = NFS_I(inode);
+        unsigned long idx_start, idx_end;
+        unsigned int npages = 0;
        LIST_HEAD(head);
        int nocommit = how & FLUSH_NOCOMMIT;
-        int pages, ret;
+        long pages, ret;
+        /* FIXME */
+        if (wbc->range_cyclic)
+                idx_start = 0;
+        else {
+                idx_start = wbc->range_start >> PAGE_CACHE_SHIFT;
+                idx_end = wbc->range_end >> PAGE_CACHE_SHIFT;
+                if (idx_end > idx_start) {
+                        unsigned long l_npages = 1 + idx_end - idx_start;
+                        npages = l_npages;
+                        if (sizeof(npages) != sizeof(l_npages) &&
+                                        (unsigned long)npages != l_npages)
+                                npages = 0;
+                }
+        }
        how &= ~FLUSH_NOCOMMIT;
        spin_lock(&nfsi->req_lock);
        do {
+                wbc->pages_skipped = 0;
                ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
                if (ret != 0)
                        continue;
-                pages = nfs_scan_dirty(inode, &head, idx_start, npages);
+                pages = nfs_scan_dirty(mapping, wbc, &head);
                if (pages != 0) {
                        spin_unlock(&nfsi->req_lock);
-                        if (how & FLUSH_INVALIDATE)
+                        if (how & FLUSH_INVALIDATE) {
                                nfs_cancel_dirty_list(&head);
-                        else
+                                ret = pages;
+                        } else
                                ret = nfs_flush_list(inode, &head, pages, how);
                        spin_lock(&nfsi->req_lock);
                        continue;
                }
+                if (wbc->pages_skipped != 0)
+                        continue;
                if (nocommit)
                        break;
                pages = nfs_scan_commit(inode, &head, idx_start, npages);
-                if (pages == 0)
+                if (pages == 0) {
+                        if (wbc->pages_skipped != 0)
+                                continue;
                        break;
+                }
                if (how & FLUSH_INVALIDATE) {
                        spin_unlock(&nfsi->req_lock);
                        nfs_cancel_commit_list(&head);
+                        ret = pages;
                        spin_lock(&nfsi->req_lock);
                        continue;
                }
@@ -1540,6 +1446,106 @@ int nfs_sync_inode_wait(struct inode *inode, unsigned long idx_start,
        return ret;
 }
+/*
+ * flush the inode to disk.
+ */
+int nfs_wb_all(struct inode *inode)
+{
+        struct address_space *mapping = inode->i_mapping;
+        struct writeback_control wbc = {
+                .bdi = mapping->backing_dev_info,
+                .sync_mode = WB_SYNC_ALL,
+                .nr_to_write = LONG_MAX,
+                .for_writepages = 1,
+                .range_cyclic = 1,
+        };
+        int ret;
+        ret = generic_writepages(mapping, &wbc);
+        if (ret < 0)
+                goto out;
+        ret = nfs_sync_mapping_wait(mapping, &wbc, 0);
+        if (ret >= 0)
+                return 0;
+out:
+        __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
+        return ret;
+}
+int nfs_sync_mapping_range(struct address_space *mapping, loff_t range_start, loff_t range_end, int how)
+{
+        struct writeback_control wbc = {
+                .bdi = mapping->backing_dev_info,
+                .sync_mode = WB_SYNC_ALL,
+                .nr_to_write = LONG_MAX,
+                .range_start = range_start,
+                .range_end = range_end,
+                .for_writepages = 1,
+        };
+        int ret;
+        if (!(how & FLUSH_NOWRITEPAGE)) {
+                ret = generic_writepages(mapping, &wbc);
+                if (ret < 0)
+                        goto out;
+        }
+        ret = nfs_sync_mapping_wait(mapping, &wbc, how);
+        if (ret >= 0)
+                return 0;
+out:
+        __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
+        return ret;
+}
+int nfs_wb_page_priority(struct inode *inode, struct page *page, int how)
+{
+        loff_t range_start = page_offset(page);
+        loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
+        struct writeback_control wbc = {
+                .bdi = page->mapping->backing_dev_info,
+                .sync_mode = WB_SYNC_ALL,
+                .nr_to_write = LONG_MAX,
+                .range_start = range_start,
+                .range_end = range_end,
+        };
+        int ret;
+        BUG_ON(!PageLocked(page));
+        if (!(how & FLUSH_NOWRITEPAGE) && clear_page_dirty_for_io(page)) {
+                ret = nfs_writepage_locked(page, &wbc);
+                if (ret < 0)
+                        goto out;
+        }
+        ret = nfs_sync_mapping_wait(page->mapping, &wbc, how);
+        if (ret >= 0)
+                return 0;
+out:
+        __mark_inode_dirty(inode, I_DIRTY_PAGES);
+        return ret;
+}
+/*
+ * Write back all requests on one page - we do this before reading it.
+ */
+int nfs_wb_page(struct inode *inode, struct page* page)
+{
+        return nfs_wb_page_priority(inode, page, FLUSH_STABLE);
+}
+int nfs_set_page_dirty(struct page *page)
+{
+        struct nfs_page *req;
+        req = nfs_page_find_request(page);
+        if (req != NULL) {
+                /* Mark any existing write requests for flushing */
+                set_bit(PG_NEED_FLUSH, &req->wb_flags);
+                nfs_release_request(req);
+        }
+        return __set_page_dirty_nobuffers(page);
+}
 int __init nfs_init_writepagecache(void)
 {
        nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
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;
+        struct inode *inode = filp->f_path.dentry->d_inode;
-        dprintk("nfsd: sync file %s\n", filp->f_dentry->d_name.name);
+        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);
+        raparml = kcalloc(cache_size, sizeof(struct raparms), GFP_KERNEL);
-        if (raparml != NULL) {
+        if (!raparml) {
-                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 {
                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_path.dentry->d_name.len,
-                       file->f_dentry->d_name.name);
+                       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_path.dentry->d_name.len,
-                   filp->f_dentry->d_name.name);
+                   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_path.dentry->d_name.len,
-                   out->f_dentry->d_name.name);
+                   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_path.dentry->d_name.len,
-                   in->f_dentry->d_name.name);
+                   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_path.dentry->d_name.len,
-                   filp->f_dentry->d_name.name);
+                   filp->f_path.dentry->d_name.name);
        if (!inode) {
                ret = -EINVAL;
diff --git a/fs/open.c b/fs/open.c
index 89e0c237a636..c989fb4cf7b9 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;
+        dentry = file->f_path.dentry;
-        mnt = file->f_vfsmnt;
+        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_path.dentry = dentry;
-        f->f_vfsmnt = mnt;
+        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_path.dentry = NULL;
-        f->f_vfsmnt = 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);
@@ -864,8 +864,7 @@ int get_unused_fd(void)
 repeat:
        fdt = files_fdtable(files);
-        fd = find_next_zero_bit(fdt->open_fds->fds_bits,
+        fd = find_next_zero_bit(fdt->open_fds->fds_bits, fdt->max_fds,
-                                fdt->max_fdset,
                                files->next_fd);
        /*
@@ -965,7 +964,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 +1086,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/Kconfig b/fs/partitions/Kconfig
index e478f1941831..74552c60b671 100644
--- a/fs/partitions/Kconfig
+++ b/fs/partitions/Kconfig
@@ -194,7 +194,7 @@ config LDM_DEBUG
 config SGI_PARTITION
        bool "SGI partition support" if PARTITION_ADVANCED
-        default y if (SGI_IP22 || SGI_IP27 || ((MACH_JAZZ || SNI_RM200_PCI) && !CPU_LITTLE_ENDIAN))
+        default y if (SGI_IP22 || SGI_IP27 || ((MACH_JAZZ || SNI_RM) && !CPU_LITTLE_ENDIAN))
        help
          Say Y here if you would like to be able to read the hard disk
          partition table format used by SGI machines.
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_path.mnt = mntget(pipe_mnt);
-        f->f_dentry = dentry;
+        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);
+        mntput(f->f_path.mnt);
-        dput(f->f_dentry);
+        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_path.mnt = mntget(wrf->f_path.mnt);
-        f->f_dentry = dget(wrf->f_dentry);
+        f->f_path.dentry = dget(wrf->f_path.dentry);
-        f->f_mapping = wrf->f_dentry->d_inode->i_mapping;
+        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 (sig->tty) {
-                if (tty) {
+                        tty_pgrp = sig->tty->pgrp;
-                        /*
+                        tty_nr = new_encode_dev(tty_devnum(sig->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));
                }
                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..77a57b5799c4 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;
+                ns = task->nsproxy->mnt_ns;
-                if (namespace)
+                if (ns)
-                        get_namespace(namespace);
+                        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->m.private = ns;
-                                p->event = namespace->event;
+                                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;
+        struct mnt_namespace *ns = m->private;
-        put_namespace(namespace);
+        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;
+                                mnt_ns = task->nsproxy->mnt_ns;
-                        if (namespace)
+                        if (mnt_ns)
-                                get_namespace(namespace);
+                                get_mnt_ns(mnt_ns);
                        task_unlock(task);
                        put_task_struct(task);
                }
-                if (namespace)
+                if (mnt_ns)
-                        m->private = namespace;
+                        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);
+                        *mnt = mntget(file->f_path.mnt);
-                        *dentry = dget(file->f_dentry);
+                        *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);
@@ -1745,6 +1804,27 @@ static int proc_base_fill_cache(struct file *filp, void *dirent, filldir_t filld
                                proc_base_instantiate, task, p);
 }
+#ifdef CONFIG_TASK_IO_ACCOUNTING
+static int proc_pid_io_accounting(struct task_struct *task, char *buffer)
+{
+        return sprintf(buffer,
+                        "rchar: %llu\n"
+                        "wchar: %llu\n"
+                        "syscr: %llu\n"
+                        "syscw: %llu\n"
+                        "read_bytes: %llu\n"
+                        "write_bytes: %llu\n"
+                        "cancelled_write_bytes: %llu\n",
+                        (unsigned long long)task->rchar,
+                        (unsigned long long)task->wchar,
+                        (unsigned long long)task->syscr,
+                        (unsigned long long)task->syscw,
+                        (unsigned long long)task->ioac.read_bytes,
+                        (unsigned long long)task->ioac.write_bytes,
+                        (unsigned long long)task->ioac.cancelled_write_bytes);
+}
+#endif
 /*
 * Thread groups
 */
@@ -1793,6 +1873,12 @@ 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
+#ifdef CONFIG_TASK_IO_ACCOUNTING
+        INF("io",       S_IRUGO, pid_io_accounting),
+#endif
 };
 static int proc_tgid_base_readdir(struct file * filp,
@@ -1994,7 +2080,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 +2154,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 +2324,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 = sprintf(page, linux_banner,
-        len = strlen(page);
+                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);
+                *mnt = mntget(vma->vm_file->f_path.mnt);
-                *dentry = dget(vma->vm_file->f_dentry);
+                *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);
+                *mnt = mntget(vma->vm_file->f_path.mnt);
-                *dentry = dget(vma->vm_file->f_dentry);
+                *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/select.c b/fs/select.c
index dcbc1112b7ec..fe0893afd931 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -311,7 +311,7 @@ static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
 {
        fd_set_bits fds;
        void *bits;
-        int ret, max_fdset;
+        int ret, max_fds;
        unsigned int size;
        struct fdtable *fdt;
        /* Allocate small arguments on the stack to save memory and be faster */
@@ -321,13 +321,13 @@ static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
        if (n < 0)
                goto out_nofds;
-        /* max_fdset can increase, so grab it once to avoid race */
+        /* max_fds can increase, so grab it once to avoid race */
        rcu_read_lock();
        fdt = files_fdtable(current->files);
-        max_fdset = fdt->max_fdset;
+        max_fds = fdt->max_fds;
        rcu_read_unlock();
-        if (n > max_fdset)
+        if (n > max_fds)
-                n = max_fdset;
+                n = max_fds;
        /*
         * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
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 *ipipe = pipe_info(in->f_path.dentry->d_inode);
-        struct pipe_inode_info *opipe = pipe_info(out->f_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 kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_dentry);
+        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 kobject * kobj = to_kobj(file->f_path.dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_dentry);
+        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 kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
-        struct attribute * attr = to_attr(file->f_dentry);
+        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 kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
-        struct attribute * attr = to_attr(filp->f_dentry);
+        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 kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
-        struct sysfs_dirent * sd = filp->f_dentry->d_fsdata;
+        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_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 8e6b56fc1cad..b56eb754e2d2 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1406,7 +1406,7 @@ xfs_vm_direct_IO(
                        xfs_end_io_direct);
        }
-        if (unlikely(ret <= 0 && iocb->private))
+        if (unlikely(ret != -EIOCBQUEUED && iocb->private))
                xfs_destroy_ioend(iocb->private);
        return ret;
 }
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_path.dentry);
-                ASSERT(file->f_dentry->d_inode);
+                ASSERT(file->f_path.dentry->d_inode);
-                inode = igrab(file->f_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;
        }