115 files changed, 1242 insertions, 1070 deletions
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 61c599b4a1e3..872943004e59 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -99,12 +99,13 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,
 * @flags: mount flags
 * @dev_name: device name that was mounted
 * @data: mount options
+ * @mnt: mountpoint record to be instantiated
 *
 */
-static struct super_block *v9fs_get_sb(struct file_system_type
+static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
-                                       *fs_type, int flags,
+                       const char *dev_name, void *data,
-                                       const char *dev_name, void *data)
+                       struct vfsmount *mnt)
 {
        struct super_block *sb = NULL;
        struct v9fs_fcall *fcall = NULL;
@@ -123,17 +124,19 @@ static struct super_block *v9fs_get_sb(struct file_system_type
        v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
        if (!v9ses)
-                return ERR_PTR(-ENOMEM);
+                return -ENOMEM;
        if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
                dprintk(DEBUG_ERROR, "problem initiating session\n");
-                sb = ERR_PTR(newfid);
+                retval = newfid;
                goto out_free_session;
        }
        sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
-        if (IS_ERR(sb))
+        if (IS_ERR(sb)) {
+                retval = PTR_ERR(sb);
                goto out_close_session;
+        }
        v9fs_fill_super(sb, v9ses, flags);
        inode = v9fs_get_inode(sb, S_IFDIR | mode);
@@ -184,19 +187,19 @@ static struct super_block *v9fs_get_sb(struct file_system_type
                goto put_back_sb;
        }
-        return sb;
+        return simple_set_mnt(mnt, sb);
 out_close_session:
        v9fs_session_close(v9ses);
 out_free_session:
        kfree(v9ses);
-        return sb;
+        return retval;
 put_back_sb:
        /* deactivate_super calls v9fs_kill_super which will frees the rest */
        up_write(&sb->s_umount);
        deactivate_super(sb);
-        return ERR_PTR(retval);
+        return retval;
 }
 /**
diff --git a/fs/Kconfig b/fs/Kconfig
index 20f9b557732d..2aa4624cc018 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -53,7 +53,7 @@ config EXT2_FS_SECURITY
 config EXT2_FS_XIP
        bool "Ext2 execute in place support"
-        depends on EXT2_FS
+        depends on EXT2_FS && MMU
        help
          Execute in place can be used on memory-backed block devices. If you
          enable this option, you can select to mount block devices which are
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 252abda0d200..ba1c88af49fe 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -196,17 +196,17 @@ static int adfs_remount(struct super_block *sb, int *flags, char *data)
        return parse_options(sb, data);
 }
-static int adfs_statfs(struct super_block *sb, struct kstatfs *buf)
+static int adfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct adfs_sb_info *asb = ADFS_SB(sb);
+        struct adfs_sb_info *asb = ADFS_SB(dentry->d_sb);
        buf->f_type    = ADFS_SUPER_MAGIC;
        buf->f_namelen = asb->s_namelen;
-        buf->f_bsize   = sb->s_blocksize;
+        buf->f_bsize   = dentry->d_sb->s_blocksize;
        buf->f_blocks  = asb->s_size;
        buf->f_files   = asb->s_ids_per_zone * asb->s_map_size;
        buf->f_bavail  =
-        buf->f_bfree   = adfs_map_free(sb);
+        buf->f_bfree   = adfs_map_free(dentry->d_sb);
        buf->f_ffree   = (long)(buf->f_bfree * buf->f_files) / (long)buf->f_blocks;
        return 0;
@@ -470,10 +470,11 @@ error:
        return -EINVAL;
 }
-static struct super_block *adfs_get_sb(struct file_system_type *fs_type,
+static int adfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, adfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, adfs_fill_super,
+                           mnt);
 }
 static struct file_system_type adfs_fs_type = {
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 4d7e5b19e5cd..8765cba35bb9 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -18,7 +18,7 @@
 extern struct timezone sys_tz;
-static int affs_statfs(struct super_block *sb, struct kstatfs *buf);
+static int affs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int affs_remount (struct super_block *sb, int *flags, char *data);
 static void
@@ -508,8 +508,9 @@ affs_remount(struct super_block *sb, int *flags, char *data)
 }
 static int
-affs_statfs(struct super_block *sb, struct kstatfs *buf)
+affs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        int              free;
        pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
@@ -524,10 +525,11 @@ affs_statfs(struct super_block *sb, struct kstatfs *buf)
        return 0;
 }
-static struct super_block *affs_get_sb(struct file_system_type *fs_type,
+static int affs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, affs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, affs_fill_super,
+                           mnt);
 }
 static struct file_system_type affs_fs_type = {
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index a6dff6a4f204..2fc99877cb0d 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -185,9 +185,7 @@ static struct page *afs_dir_get_page(struct inode *dir, unsigned long index)
        _enter("{%lu},%lu", dir->i_ino, index);
-        page = read_cache_page(dir->i_mapping,index,
+        page = read_mapping_page(dir->i_mapping, index, NULL);
-                               (filler_t *) dir->i_mapping->a_ops->readpage,
-                               NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                kmap(page);
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 4e6eeb59b83c..b5cf9e1205ad 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -63,7 +63,6 @@ unsigned long afs_mntpt_expiry_timeout = 20;
 int afs_mntpt_check_symlink(struct afs_vnode *vnode)
 {
        struct page *page;
-        filler_t *filler;
        size_t size;
        char *buf;
        int ret;
@@ -71,10 +70,7 @@ int afs_mntpt_check_symlink(struct afs_vnode *vnode)
        _enter("{%u,%u}", vnode->fid.vnode, vnode->fid.unique);
        /* read the contents of the symlink into the pagecache */
-        filler = (filler_t *) AFS_VNODE_TO_I(vnode)->i_mapping->a_ops->readpage;
+        page = read_mapping_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0, NULL);
-        page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0,
-                               filler, NULL);
        if (IS_ERR(page)) {
                ret = PTR_ERR(page);
                goto out;
@@ -160,7 +156,6 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
        struct page *page = NULL;
        size_t size;
        char *buf, *devname = NULL, *options = NULL;
-        filler_t *filler;
        int ret;
        kenter("{%s}", mntpt->d_name.name);
@@ -182,9 +177,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
                goto error;
        /* read the contents of the AFS special symlink */
-        filler = (filler_t *)mntpt->d_inode->i_mapping->a_ops->readpage;
+        page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL);
-        page = read_cache_page(mntpt->d_inode->i_mapping, 0, filler, NULL);
        if (IS_ERR(page)) {
                ret = PTR_ERR(page);
                goto error;
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 53c56e7231ab..82468df0ba54 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -38,9 +38,9 @@ struct afs_mount_params {
 static void afs_i_init_once(void *foo, kmem_cache_t *cachep,
                            unsigned long flags);
-static struct super_block *afs_get_sb(struct file_system_type *fs_type,
+static int afs_get_sb(struct file_system_type *fs_type,
-                                      int flags, const char *dev_name,
+                      int flags, const char *dev_name,
-                                      void *data);
+                      void *data, struct vfsmount *mnt);
 static struct inode *afs_alloc_inode(struct super_block *sb);
@@ -294,10 +294,11 @@ static int afs_fill_super(struct super_block *sb, void *data, int silent)
 * get an AFS superblock
 * - TODO: don't use get_sb_nodev(), but rather call sget() directly
 */
-static struct super_block *afs_get_sb(struct file_system_type *fs_type,
+static int afs_get_sb(struct file_system_type *fs_type,
-                                      int flags,
+                      int flags,
-                                      const char *dev_name,
+                      const char *dev_name,
-                                      void *options)
+                      void *options,
+                      struct vfsmount *mnt)
 {
        struct afs_mount_params params;
        struct super_block *sb;
@@ -311,7 +312,7 @@ static struct super_block *afs_get_sb(struct file_system_type *fs_type,
        ret = afscm_start();
        if (ret < 0) {
                _leave(" = %d", ret);
-                return ERR_PTR(ret);
+                return ret;
        }
        /* parse the options */
@@ -348,18 +349,19 @@ static struct super_block *afs_get_sb(struct file_system_type *fs_type,
                goto error;
        }
        sb->s_flags |= MS_ACTIVE;
+        simple_set_mnt(mnt, sb);
        afs_put_volume(params.volume);
        afs_put_cell(params.default_cell);
-        _leave(" = %p", sb);
+        _leave(" = 0 [%p]", 0, sb);
-        return sb;
+        return 0;
 error:
        afs_put_volume(params.volume);
        afs_put_cell(params.default_cell);
        afscm_stop();
        _leave(" = %d", ret);
-        return ERR_PTR(ret);
+        return ret;
 } /* end afs_get_sb() */
 /*****************************************************************************/
diff --git a/fs/aio.c b/fs/aio.c
index e41e932ba489..8c34a62df7d7 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -777,11 +777,11 @@ out:
 static int __aio_run_iocbs(struct kioctx *ctx)
 {
        struct kiocb *iocb;
-        LIST_HEAD(run_list);
+        struct list_head run_list;
        assert_spin_locked(&ctx->ctx_lock);
-        list_splice_init(&ctx->run_list, &run_list);
+        list_replace_init(&ctx->run_list, &run_list);
        while (!list_empty(&run_list)) {
                iocb = list_entry(run_list.next, struct kiocb,
                        ki_run_list);
diff --git a/fs/autofs/init.c b/fs/autofs/init.c
index b977ece69f0c..aca123752406 100644
--- a/fs/autofs/init.c
+++ b/fs/autofs/init.c
@@ -14,10 +14,10 @@
 #include <linux/init.h>
 #include "autofs_i.h"
-static struct super_block *autofs_get_sb(struct file_system_type *fs_type,
+static int autofs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, autofs_fill_super);
+        return get_sb_nodev(fs_type, flags, data, autofs_fill_super, mnt);
 }
 static struct file_system_type autofs_fs_type = {
diff --git a/fs/autofs4/init.c b/fs/autofs4/init.c
index acecec8578ce..5d9193332bef 100644
--- a/fs/autofs4/init.c
+++ b/fs/autofs4/init.c
@@ -14,10 +14,10 @@
 #include <linux/init.h>
 #include "autofs_i.h"
-static struct super_block *autofs_get_sb(struct file_system_type *fs_type,
+static int autofs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, autofs4_fill_super);
+        return get_sb_nodev(fs_type, flags, data, autofs4_fill_super, mnt);
 }
 static struct file_system_type autofs_fs_type = {
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 68ebd10f345d..08201fab26cd 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -49,7 +49,7 @@ static int befs_nls2utf(struct super_block *sb, const char *in, int in_len,
                        char **out, int *out_len);
 static void befs_put_super(struct super_block *);
 static int befs_remount(struct super_block *, int *, char *);
-static int befs_statfs(struct super_block *, struct kstatfs *);
+static int befs_statfs(struct dentry *, struct kstatfs *);
 static int parse_options(char *, befs_mount_options *);
 static const struct super_operations befs_sops = {
@@ -880,8 +880,9 @@ befs_remount(struct super_block *sb, int *flags, char *data)
 }
 static int
-befs_statfs(struct super_block *sb, struct kstatfs *buf)
+befs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        befs_debug(sb, "---> befs_statfs()");
@@ -899,11 +900,12 @@ befs_statfs(struct super_block *sb, struct kstatfs *buf)
        return 0;
 }
-static struct super_block *
+static int
 befs_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name,
-            void *data)
+            void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, befs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, befs_fill_super,
+                           mnt);
 }
 static struct file_system_type befs_fs_type = {
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 55a7a78332f8..cf74f3d4d966 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -203,8 +203,9 @@ static void bfs_put_super(struct super_block *s)
        s->s_fs_info = NULL;
 }
-static int bfs_statfs(struct super_block *s, struct kstatfs *buf)
+static int bfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *s = dentry->d_sb;
        struct bfs_sb_info *info = BFS_SB(s);
        u64 id = huge_encode_dev(s->s_bdev->bd_dev);
        buf->f_type = BFS_MAGIC;
@@ -410,10 +411,10 @@ out:
        return -EINVAL;
 }
-static struct super_block *bfs_get_sb(struct file_system_type *fs_type,
+static int bfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, bfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, bfs_fill_super, mnt);
 }
 static struct file_system_type bfs_fs_type = {
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 8a04216e8b4d..d0434406eaeb 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -38,15 +38,13 @@
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/random.h>
+#include <linux/elf.h>
 #include <asm/uaccess.h>
 #include <asm/param.h>
 #include <asm/page.h>
-#include <linux/elf.h>
+static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
+static int load_elf_library(struct file *);
-static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs);
-static int load_elf_library(struct file*);
 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);
 extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
@@ -59,15 +57,15 @@ extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
 * don't even try.
 */
 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
-static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file);
+static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file);
 #else
 #define elf_core_dump   NULL
 #endif
 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
-# define ELF_MIN_ALIGN  ELF_EXEC_PAGESIZE
+#define ELF_MIN_ALIGN   ELF_EXEC_PAGESIZE
 #else
-# define ELF_MIN_ALIGN  PAGE_SIZE
+#define ELF_MIN_ALIGN   PAGE_SIZE
 #endif
 #ifndef ELF_CORE_EFLAGS
@@ -86,7 +84,7 @@ static struct linux_binfmt elf_format = {
                .min_coredump   = ELF_EXEC_PAGESIZE
 };
-#define BAD_ADDR(x)     ((unsigned long)(x) > TASK_SIZE)
+#define BAD_ADDR(x) ((unsigned long)(x) > TASK_SIZE)
 static int set_brk(unsigned long start, unsigned long end)
 {
@@ -104,13 +102,11 @@ static int set_brk(unsigned long start, unsigned long end)
        return 0;
 }
 /* We need to explicitly zero any fractional pages
   after the data section (i.e. bss).  This would
   contain the junk from the file that should not
-   be in memory */
+   be in memory
+ */
 static int padzero(unsigned long elf_bss)
 {
        unsigned long nbyte;
@@ -129,7 +125,9 @@ static int padzero(unsigned long elf_bss)
 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
 #define STACK_ROUND(sp, items) \
        ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
-#define STACK_ALLOC(sp, len) ({ elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; old_sp; })
+#define STACK_ALLOC(sp, len) ({ \
+        elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
+        old_sp; })
 #else
 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
 #define STACK_ROUND(sp, items) \
@@ -138,7 +136,7 @@ static int padzero(unsigned long elf_bss)
 #endif
 static int
-create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
+create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
                int interp_aout, unsigned long load_addr,
                unsigned long interp_load_addr)
 {
@@ -161,7 +159,6 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
         * for userspace to get any other way, in others (i386) it is
         * merely difficult.
         */
        u_platform = NULL;
        if (k_platform) {
                size_t len = strlen(k_platform) + 1;
@@ -171,7 +168,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
                 * evictions by the processes running on the same package. One
                 * thing we can do is to shuffle the initial stack for them.
                 */
-         
                p = arch_align_stack(p);
                u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
@@ -180,9 +177,12 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        }
        /* Create the ELF interpreter info */
-        elf_info = (elf_addr_t *) current->mm->saved_auxv;
+        elf_info = (elf_addr_t *)current->mm->saved_auxv;
 #define NEW_AUX_ENT(id, val) \
-        do { elf_info[ei_index++] = id; elf_info[ei_index++] = val; } while (0)
+        do { \
+                elf_info[ei_index++] = id; \
+                elf_info[ei_index++] = val; \
+        } while (0)
 #ifdef ARCH_DLINFO
        /* 
@@ -195,21 +195,22 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
        NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
        NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
-        NEW_AUX_ENT(AT_PHENT, sizeof (struct elf_phdr));
+        NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
        NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
        NEW_AUX_ENT(AT_BASE, interp_load_addr);
        NEW_AUX_ENT(AT_FLAGS, 0);
        NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
-        NEW_AUX_ENT(AT_UID, (elf_addr_t) tsk->uid);
+        NEW_AUX_ENT(AT_UID, tsk->uid);
-        NEW_AUX_ENT(AT_EUID, (elf_addr_t) tsk->euid);
+        NEW_AUX_ENT(AT_EUID, tsk->euid);
-        NEW_AUX_ENT(AT_GID, (elf_addr_t) tsk->gid);
+        NEW_AUX_ENT(AT_GID, tsk->gid);
-        NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);
+        NEW_AUX_ENT(AT_EGID, tsk->egid);
-        NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
+        NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
        if (k_platform) {
-                NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);
+                NEW_AUX_ENT(AT_PLATFORM,
+                            (elf_addr_t)(unsigned long)u_platform);
        }
        if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
-                NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);
+                NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
        }
 #undef NEW_AUX_ENT
        /* AT_NULL is zero; clear the rest too */
@@ -232,7 +233,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        /* Point sp at the lowest address on the stack */
 #ifdef CONFIG_STACK_GROWSUP
        sp = (elf_addr_t __user *)bprm->p - items - ei_index;
-        bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */
+        bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
 #else
        sp = (elf_addr_t __user *)bprm->p;
 #endif
@@ -285,7 +286,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
 #ifndef elf_map
 static unsigned long elf_map(struct file *filep, unsigned long addr,
-                        struct elf_phdr *eppnt, int prot, int type)
+                struct elf_phdr *eppnt, int prot, int type)
 {
        unsigned long map_addr;
        unsigned long pageoffset = ELF_PAGEOFFSET(eppnt->p_vaddr);
@@ -310,9 +311,8 @@ static unsigned long elf_map(struct file *filep, unsigned long addr,
   is only provided so that we can read a.out libraries that have
   an ELF header */
-static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
+static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
-                                     struct file * interpreter,
+                struct file *interpreter, unsigned long *interp_load_addr)
-                                     unsigned long *interp_load_addr)
 {
        struct elf_phdr *elf_phdata;
        struct elf_phdr *eppnt;
@@ -342,15 +342,15 @@ static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
                goto out;
        /* Now read in all of the header information */
        size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
        if (size > ELF_MIN_ALIGN)
                goto out;
-        elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
+        elf_phdata = kmalloc(size, GFP_KERNEL);
        if (!elf_phdata)
                goto out;
-        retval = kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);
+        retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
+                             (char *)elf_phdata,size);
        error = -EIO;
        if (retval != size) {
                if (retval < 0)
@@ -359,58 +359,65 @@ static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
        }
        eppnt = elf_phdata;
-        for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
+        for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
-          if (eppnt->p_type == PT_LOAD) {
+                if (eppnt->p_type == PT_LOAD) {
-            int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
+                        int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
-            int elf_prot = 0;
+                        int elf_prot = 0;
-            unsigned long vaddr = 0;
+                        unsigned long vaddr = 0;
-            unsigned long k, map_addr;
+                        unsigned long k, map_addr;
-            if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
+                        if (eppnt->p_flags & PF_R)
-            if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
+                                elf_prot = PROT_READ;
-            if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
+                        if (eppnt->p_flags & PF_W)
-            vaddr = eppnt->p_vaddr;
+                                elf_prot |= PROT_WRITE;
-            if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
+                        if (eppnt->p_flags & PF_X)
-                elf_type |= MAP_FIXED;
+                                elf_prot |= PROT_EXEC;
+                        vaddr = eppnt->p_vaddr;
-            map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type);
+                        if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
-            error = map_addr;
+                                elf_type |= MAP_FIXED;
-            if (BAD_ADDR(map_addr))
-                goto out_close;
+                        map_addr = elf_map(interpreter, load_addr + vaddr,
+                                           eppnt, elf_prot, elf_type);
-            if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
+                        error = map_addr;
-                load_addr = map_addr - ELF_PAGESTART(vaddr);
+                        if (BAD_ADDR(map_addr))
-                load_addr_set = 1;
+                                goto out_close;
-            }
+                        if (!load_addr_set &&
-            /*
+                            interp_elf_ex->e_type == ET_DYN) {
-             * Check to see if the section's size will overflow the
+                                load_addr = map_addr - ELF_PAGESTART(vaddr);
-             * allowed task size. Note that p_filesz must always be
+                                load_addr_set = 1;
-             * <= p_memsize so it is only necessary to check p_memsz.
+                        }
-             */
-            k = load_addr + eppnt->p_vaddr;
+                        /*
-            if (k > TASK_SIZE || eppnt->p_filesz > eppnt->p_memsz ||
+                         * Check to see if the section's size will overflow the
-                eppnt->p_memsz > TASK_SIZE || TASK_SIZE - eppnt->p_memsz < k) {
+                         * allowed task size. Note that p_filesz must always be
-                error = -ENOMEM;
+                         * <= p_memsize so it's only necessary to check p_memsz.
-                goto out_close;
+                         */
-            }
+                        k = load_addr + eppnt->p_vaddr;
+                        if (k > TASK_SIZE ||
-            /*
+                            eppnt->p_filesz > eppnt->p_memsz ||
-             * Find the end of the file mapping for this phdr, and keep
+                            eppnt->p_memsz > TASK_SIZE ||
-             * track of the largest address we see for this.
+                            TASK_SIZE - eppnt->p_memsz < k) {
-             */
+                                error = -ENOMEM;
-            k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
+                                goto out_close;
-            if (k > elf_bss)
+                        }
-                elf_bss = k;
+                        /*
-            /*
+                         * Find the end of the file mapping for this phdr, and
-             * Do the same thing for the memory mapping - between
+                         * keep track of the largest address we see for this.
-             * elf_bss and last_bss is the bss section.
+                         */
-             */
+                        k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
-            k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
+                        if (k > elf_bss)
-            if (k > last_bss)
+                                elf_bss = k;
-                last_bss = k;
-          }
+                        /*
+                         * Do the same thing for the memory mapping - between
+                         * elf_bss and last_bss is the bss section.
+                         */
+                        k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
+                        if (k > last_bss)
+                                last_bss = k;
+                }
        }
        /*
@@ -424,7 +431,8 @@ static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
                goto out_close;
        }
-        elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);   /* What we have mapped so far */
+        /* What we have mapped so far */
+        elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
        /* Map the last of the bss segment */
        if (last_bss > elf_bss) {
@@ -436,7 +444,7 @@ static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
        }
        *interp_load_addr = load_addr;
-        error = ((unsigned long) interp_elf_ex->e_entry) + load_addr;
+        error = ((unsigned long)interp_elf_ex->e_entry) + load_addr;
 out_close:
        kfree(elf_phdata);
@@ -444,8 +452,8 @@ out:
        return error;
 }
-static unsigned long load_aout_interp(struct exec * interp_ex,
+static unsigned long load_aout_interp(struct exec *interp_ex,
-                             struct file * interpreter)
+                struct file *interpreter)
 {
        unsigned long text_data, elf_entry = ~0UL;
        char __user * addr;
@@ -464,7 +472,7 @@ static unsigned long load_aout_interp(struct exec * interp_ex,
        case ZMAGIC:
        case QMAGIC:
                offset = N_TXTOFF(*interp_ex);
-                addr = (char __user *) N_TXTADDR(*interp_ex);
+                addr = (char __user *)N_TXTADDR(*interp_ex);
                break;
        default:
                goto out;
@@ -480,7 +488,6 @@ static unsigned long load_aout_interp(struct exec * interp_ex,
        flush_icache_range((unsigned long)addr,
                           (unsigned long)addr + text_data);
        down_write(&current->mm->mmap_sem);     
        do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
                interp_ex->a_bss);
@@ -519,7 +526,7 @@ static unsigned long randomize_stack_top(unsigned long stack_top)
 #endif
 }
-static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
+static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
 {
        struct file *interpreter = NULL; /* to shut gcc up */
        unsigned long load_addr = 0, load_bias = 0;
@@ -528,7 +535,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        unsigned int interpreter_type = INTERPRETER_NONE;
        unsigned char ibcs2_interpreter = 0;
        unsigned long error;
-        struct elf_phdr * elf_ppnt, *elf_phdata;
+        struct elf_phdr *elf_ppnt, *elf_phdata;
        unsigned long elf_bss, elf_brk;
        int elf_exec_fileno;
        int retval, i;
@@ -553,7 +560,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        }
        
        /* Get the exec-header */
-        loc->elf_ex = *((struct elfhdr *) bprm->buf);
+        loc->elf_ex = *((struct elfhdr *)bprm->buf);
        retval = -ENOEXEC;
        /* First of all, some simple consistency checks */
@@ -568,7 +575,6 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                goto out;
        /* Now read in all of the header information */
        if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
                goto out;
        if (loc->elf_ex.e_phnum < 1 ||
@@ -576,18 +582,19 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                goto out;
        size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
        retval = -ENOMEM;
-        elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
+        elf_phdata = kmalloc(size, GFP_KERNEL);
        if (!elf_phdata)
                goto out;
-        retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);
+        retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
+                             (char *)elf_phdata, size);
        if (retval != size) {
                if (retval >= 0)
                        retval = -EIO;
                goto out_free_ph;
        }
-        files = current->files;         /* Refcounted so ok */
+        files = current->files; /* Refcounted so ok */
        retval = unshare_files();
        if (retval < 0)
                goto out_free_ph;
@@ -598,7 +605,6 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        /* exec will make our files private anyway, but for the a.out
           loader stuff we need to do it earlier */
        retval = get_unused_fd();
        if (retval < 0)
                goto out_free_fh;
@@ -620,7 +626,6 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                         * shared libraries - for now assume that this
                         * is an a.out format binary
                         */
                        retval = -ENOEXEC;
                        if (elf_ppnt->p_filesz > PATH_MAX || 
                            elf_ppnt->p_filesz < 2)
@@ -628,13 +633,13 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                        retval = -ENOMEM;
                        elf_interpreter = kmalloc(elf_ppnt->p_filesz,
-                                                           GFP_KERNEL);
+                                                  GFP_KERNEL);
                        if (!elf_interpreter)
                                goto out_free_file;
                        retval = kernel_read(bprm->file, elf_ppnt->p_offset,
-                                           elf_interpreter,
+                                             elf_interpreter,
-                                           elf_ppnt->p_filesz);
+                                             elf_ppnt->p_filesz);
                        if (retval != elf_ppnt->p_filesz) {
                                if (retval >= 0)
                                        retval = -EIO;
@@ -678,7 +683,8 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                        retval = PTR_ERR(interpreter);
                        if (IS_ERR(interpreter))
                                goto out_free_interp;
-                        retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);
+                        retval = kernel_read(interpreter, 0, bprm->buf,
+                                             BINPRM_BUF_SIZE);
                        if (retval != BINPRM_BUF_SIZE) {
                                if (retval >= 0)
                                        retval = -EIO;
@@ -686,8 +692,8 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                        }
                        /* Get the exec headers */
-                        loc->interp_ex = *((struct exec *) bprm->buf);
+                        loc->interp_ex = *((struct exec *)bprm->buf);
-                        loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);
+                        loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
                        break;
                }
                elf_ppnt++;
@@ -739,7 +745,6 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        /* OK, we are done with that, now set up the arg stuff,
           and then start this sucker up */
        if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
                char *passed_p = passed_fileno;
                sprintf(passed_fileno, "%d", elf_exec_fileno);
@@ -777,7 +782,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        if (elf_read_implies_exec(loc->elf_ex, executable_stack))
                current->personality |= READ_IMPLIES_EXEC;
-        if ( !(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
+        if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
                current->flags |= PF_RANDOMIZE;
        arch_pick_mmap_layout(current->mm);
@@ -798,8 +803,8 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
           the correct location in memory.  At this point, we assume that
           the image should be loaded at fixed address, not at a variable
           address. */
+        for(i = 0, elf_ppnt = elf_phdata;
-        for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
+            i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
                int elf_prot = 0, elf_flags;
                unsigned long k, vaddr;
@@ -827,30 +832,35 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                                                        load_bias, nbyte)) {
                                        /*
                                         * This bss-zeroing can fail if the ELF
-                                         * file specifies odd protections.  So
+                                         * file specifies odd protections. So
                                         * we don't check the return value
                                         */
                                }
                        }
                }
-                if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
+                if (elf_ppnt->p_flags & PF_R)
-                if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
+                        elf_prot |= PROT_READ;
-                if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
+                if (elf_ppnt->p_flags & PF_W)
+                        elf_prot |= PROT_WRITE;
+                if (elf_ppnt->p_flags & PF_X)
+                        elf_prot |= PROT_EXEC;
-                elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
+                elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
                vaddr = elf_ppnt->p_vaddr;
                if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
                        elf_flags |= MAP_FIXED;
                } else if (loc->elf_ex.e_type == ET_DYN) {
-                        /* Try and get dynamic programs out of the way of the default mmap
+                        /* Try and get dynamic programs out of the way of the
-                           base, as well as whatever program they might try to exec.  This
+                         * default mmap base, as well as whatever program they
-                           is because the brk will follow the loader, and is not movable.  */
+                         * might try to exec.  This is because the brk will
+                         * follow the loader, and is not movable.  */
                        load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
                }
-                error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);
+                error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
+                                elf_prot, elf_flags);
                if (BAD_ADDR(error)) {
                        send_sig(SIGKILL, current, 0);
                        goto out_free_dentry;
@@ -867,8 +877,10 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                        }
                }
                k = elf_ppnt->p_vaddr;
-                if (k < start_code) start_code = k;
+                if (k < start_code)
-                if (start_data < k) start_data = k;
+                        start_code = k;
+                if (start_data < k)
+                        start_data = k;
                /*
                 * Check to see if the section's size will overflow the
@@ -878,7 +890,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
                    elf_ppnt->p_memsz > TASK_SIZE ||
                    TASK_SIZE - elf_ppnt->p_memsz < k) {
-                        /* set_brk can never work.  Avoid overflows.  */
+                        /* set_brk can never work. Avoid overflows. */
                        send_sig(SIGKILL, current, 0);
                        goto out_free_dentry;
                }
@@ -966,8 +978,9 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        compute_creds(bprm);
        current->flags &= ~PF_FORKNOEXEC;
-        create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),
+        create_elf_tables(bprm, &loc->elf_ex,
-                        load_addr, interp_load_addr);
+                          (interpreter_type == INTERPRETER_AOUT),
+                          load_addr, interp_load_addr);
        /* N.B. passed_fileno might not be initialized? */
        if (interpreter_type == INTERPRETER_AOUT)
                current->mm->arg_start += strlen(passed_fileno) + 1;
@@ -981,7 +994,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
                   and some applications "depend" upon this behavior.
                   Since we do not have the power to recompile these, we
-                   emulate the SVr4 behavior.  Sigh.  */
+                   emulate the SVr4 behavior. Sigh. */
                down_write(&current->mm->mmap_sem);
                error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
                                MAP_FIXED | MAP_PRIVATE, 0);
@@ -1036,7 +1049,6 @@ out_free_ph:
 /* This is really simpleminded and specialized - we are loading an
   a.out library that is given an ELF header. */
 static int load_elf_library(struct file *file)
 {
        struct elf_phdr *elf_phdata;
@@ -1046,7 +1058,7 @@ static int load_elf_library(struct file *file)
        struct elfhdr elf_ex;
        error = -ENOEXEC;
-        retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
+        retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
        if (retval != sizeof(elf_ex))
                goto out;
@@ -1055,7 +1067,7 @@ static int load_elf_library(struct file *file)
        /* First of all, some simple consistency checks */
        if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
-           !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
+            !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
                goto out;
        /* Now read in all of the header information */
@@ -1103,7 +1115,8 @@ static int load_elf_library(struct file *file)
                goto out_free_ph;
        }
-        len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);
+        len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
+                            ELF_MIN_ALIGN - 1);
        bss = eppnt->p_memsz + eppnt->p_vaddr;
        if (bss > len) {
                down_write(&current->mm->mmap_sem);
@@ -1162,7 +1175,7 @@ static int maydump(struct vm_area_struct *vma)
        if (vma->vm_flags & (VM_IO | VM_RESERVED))
                return 0;
-        /* Dump shared memory only if mapped from an anonymous file.  */
+        /* 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;
@@ -1173,7 +1186,7 @@ static int maydump(struct vm_area_struct *vma)
        return 1;
 }
-#define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
+#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 /* An ELF note in memory */
 struct memelfnote
@@ -1276,11 +1289,11 @@ static void fill_note(struct memelfnote *note, const char *name, int type,
 }
 /*
- * fill up all the fields in prstatus from the given task struct, except registers
+ * fill up all the fields in prstatus from the given task struct, except
- * which need to be filled up separately.
+ * registers which need to be filled up separately.
 */
 static void fill_prstatus(struct elf_prstatus *prstatus,
-                        struct task_struct *p, long signr) 
+                struct task_struct *p, long signr)
 {
        prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
        prstatus->pr_sigpend = p->pending.signal.sig[0];
@@ -1365,8 +1378,8 @@ struct elf_thread_status
 /*
 * In order to add the specific thread information for the elf file format,
- * we need to keep a linked list of every threads pr_status and then
+ * we need to keep a linked list of every threads pr_status and then create
- * create a single section for them in the final core file.
+ * a single section for them in the final core file.
 */
 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
 {
@@ -1377,19 +1390,23 @@ static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
        fill_prstatus(&t->prstatus, p, signr);
        elf_core_copy_task_regs(p, &t->prstatus.pr_reg);        
        
-        fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));
+        fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
+                  &(t->prstatus));
        t->num_notes++;
        sz += notesize(&t->notes[0]);
-        if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {
+        if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
-                fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));
+                                                                &t->fpu))) {
+                fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
+                          &(t->fpu));
                t->num_notes++;
                sz += notesize(&t->notes[1]);
        }
 #ifdef ELF_CORE_COPY_XFPREGS
        if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
-                fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);
+                fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu),
+                          &t->xfpu);
                t->num_notes++;
                sz += notesize(&t->notes[2]);
        }
@@ -1404,7 +1421,7 @@ static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
 * and then they are actually written out.  If we run out of core limit
 * we just truncate.
 */
-static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
+static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
 {
 #define NUM_NOTES       6
        int has_dumped = 0;
@@ -1433,12 +1450,12 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
        /*
         * We no longer stop all VM operations.
         * 
-         * This is because those proceses that could possibly change map_count or
+         * This is because those proceses that could possibly change map_count
-         * the mmap / vma pages are now blocked in do_exit on current finishing
+         * or the mmap / vma pages are now blocked in do_exit on current
-         * this core dump.
+         * finishing this core dump.
         *
         * Only ptrace can touch these memory addresses, but it doesn't change
-         * the map_count or the pages allocated.  So no possibility of crashing
+         * the map_count or the pages allocated. So no possibility of crashing
         * exists while dumping the mm->vm_next areas to the core file.
         */
  
@@ -1500,7 +1517,7 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
 #endif
        /* Set up header */
-        fill_elf_header(elf, segs+1);   /* including notes section */
+        fill_elf_header(elf, segs + 1); /* including notes section */
        has_dumped = 1;
        current->flags |= PF_DUMPCORE;
@@ -1510,24 +1527,24 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
         * with info from their /proc.
         */
-        fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
+        fill_note(notes + 0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
-        
        fill_psinfo(psinfo, current->group_leader, current->mm);
-        fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
+        fill_note(notes + 1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
        
        numnote = 2;
-        auxv = (elf_addr_t *) current->mm->saved_auxv;
+        auxv = (elf_addr_t *)current->mm->saved_auxv;
        i = 0;
        do
                i += 2;
        while (auxv[i - 2] != AT_NULL);
        fill_note(&notes[numnote++], "CORE", NT_AUXV,
-                  i * sizeof (elf_addr_t), auxv);
+                  i * sizeof(elf_addr_t), auxv);
        /* Try to dump the FPU. */
-        if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))
+        if ((prstatus->pr_fpvalid =
+             elf_core_copy_task_fpregs(current, regs, fpu)))
                fill_note(notes + numnote++,
                          "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
 #ifdef ELF_CORE_COPY_XFPREGS
@@ -1576,8 +1593,10 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
                phdr.p_memsz = sz;
                offset += phdr.p_filesz;
                phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
-                if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
+                if (vma->vm_flags & VM_WRITE)
-                if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
+                        phdr.p_flags |= PF_W;
+                if (vma->vm_flags & VM_EXEC)
+                        phdr.p_flags |= PF_X;
                phdr.p_align = ELF_EXEC_PAGESIZE;
                DUMP_WRITE(&phdr, sizeof(phdr));
@@ -1594,7 +1613,9 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
        /* write out the thread status notes section */
        list_for_each(t, &thread_list) {
-                struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);
+                struct elf_thread_status *tmp =
+                                list_entry(t, struct elf_thread_status, list);
                for (i = 0; i < tmp->num_notes; i++)
                        if (!writenote(&tmp->notes[i], file))
                                goto end_coredump;
@@ -1611,18 +1632,19 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
                for (addr = vma->vm_start;
                     addr < vma->vm_end;
                     addr += PAGE_SIZE) {
-                        struct page* page;
+                        struct page *page;
                        struct vm_area_struct *vma;
                        if (get_user_pages(current, current->mm, addr, 1, 0, 1,
                                                &page, &vma) <= 0) {
-                                DUMP_SEEK (file->f_pos + PAGE_SIZE);
+                                DUMP_SEEK(file->f_pos + PAGE_SIZE);
                        } else {
                                if (page == ZERO_PAGE(addr)) {
-                                        DUMP_SEEK (file->f_pos + PAGE_SIZE);
+                                        DUMP_SEEK(file->f_pos + PAGE_SIZE);
                                } else {
                                        void *kaddr;
-                                        flush_cache_page(vma, addr, page_to_pfn(page));
+                                        flush_cache_page(vma, addr,
+                                                         page_to_pfn(page));
                                        kaddr = kmap(page);
                                        if ((size += PAGE_SIZE) > limit ||
                                            !dump_write(file, kaddr,
@@ -1644,7 +1666,8 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
        if ((off_t)file->f_pos != offset) {
                /* Sanity check */
-                printk(KERN_WARNING "elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
+                printk(KERN_WARNING
+                       "elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
                       (off_t)file->f_pos, offset);
        }
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index a2e48c999c24..eba4e23b9ca0 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -435,9 +435,10 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
                                   struct elf_fdpic_params *interp_params)
 {
        unsigned long sp, csp, nitems;
-        elf_caddr_t *argv, *envp;
+        elf_caddr_t __user *argv, *envp;
        size_t platform_len = 0, len;
-        char *k_platform, *u_platform, *p;
+        char *k_platform;
+        char __user *u_platform, *p;
        long hwcap;
        int loop;
@@ -462,12 +463,11 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        if (k_platform) {
                platform_len = strlen(k_platform) + 1;
                sp -= platform_len;
+                u_platform = (char __user *) sp;
                if (__copy_to_user(u_platform, k_platform, platform_len) != 0)
                        return -EFAULT;
        }
-        u_platform = (char *) sp;
 #if defined(__i386__) && defined(CONFIG_SMP)
        /* in some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
         * by the processes running on the same package. One thing we can do
@@ -490,7 +490,7 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        sp = (sp - len) & ~7UL;
        exec_params->map_addr = sp;
-        if (copy_to_user((void *) sp, exec_params->loadmap, len) != 0)
+        if (copy_to_user((void __user *) sp, exec_params->loadmap, len) != 0)
                return -EFAULT;
        current->mm->context.exec_fdpic_loadmap = (unsigned long) sp;
@@ -501,7 +501,7 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
                sp = (sp - len) & ~7UL;
                interp_params->map_addr = sp;
-                if (copy_to_user((void *) sp, interp_params->loadmap, len) != 0)
+                if (copy_to_user((void __user *) sp, interp_params->loadmap, len) != 0)
                        return -EFAULT;
                current->mm->context.interp_fdpic_loadmap = (unsigned long) sp;
@@ -527,7 +527,7 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        /* put the ELF interpreter info on the stack */
 #define NEW_AUX_ENT(nr, id, val)                                                \
        do {                                                                    \
-                struct { unsigned long _id, _val; } *ent = (void *) csp;        \
+                struct { unsigned long _id, _val; } __user *ent = (void __user *) csp;  \
                __put_user((id), &ent[nr]._id);                                 \
                __put_user((val), &ent[nr]._val);                               \
        } while (0)
@@ -564,13 +564,13 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        /* allocate room for argv[] and envv[] */
        csp -= (bprm->envc + 1) * sizeof(elf_caddr_t);
-        envp = (elf_caddr_t *) csp;
+        envp = (elf_caddr_t __user *) csp;
        csp -= (bprm->argc + 1) * sizeof(elf_caddr_t);
-        argv = (elf_caddr_t *) csp;
+        argv = (elf_caddr_t __user *) csp;
        /* stack argc */
        csp -= sizeof(unsigned long);
-        __put_user(bprm->argc, (unsigned long *) csp);
+        __put_user(bprm->argc, (unsigned long __user *) csp);
        BUG_ON(csp != sp);
@@ -581,7 +581,7 @@ static int create_elf_fdpic_tables(struct linux_binprm *bprm,
        current->mm->arg_start = current->mm->start_stack - (MAX_ARG_PAGES * PAGE_SIZE - bprm->p);
 #endif
-        p = (char *) current->mm->arg_start;
+        p = (char __user *) current->mm->arg_start;
        for (loop = bprm->argc; loop > 0; loop--) {
                __put_user((elf_caddr_t) p, argv++);
                len = strnlen_user(p, PAGE_SIZE * MAX_ARG_PAGES);
@@ -1025,7 +1025,7 @@ static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params *params,
                /* clear the bit between beginning of mapping and beginning of PT_LOAD */
                if (prot & PROT_WRITE && disp > 0) {
                        kdebug("clear[%d] ad=%lx sz=%lx", loop, maddr, disp);
-                        clear_user((void *) maddr, disp);
+                        clear_user((void __user *) maddr, disp);
                        maddr += disp;
                }
@@ -1059,7 +1059,7 @@ static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params *params,
                if (prot & PROT_WRITE && excess1 > 0) {
                        kdebug("clear[%d] ad=%lx sz=%lx",
                               loop, maddr + phdr->p_filesz, excess1);
-                        clear_user((void *) maddr + phdr->p_filesz, excess1);
+                        clear_user((void __user *) maddr + phdr->p_filesz, excess1);
                }
 #else
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 599f36fd0f67..07a4996cca3f 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -739,10 +739,10 @@ static int bm_fill_super(struct super_block * sb, void * data, int silent)
        return err;
 }
-static struct super_block *bm_get_sb(struct file_system_type *fs_type,
+static int bm_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, bm_fill_super);
+        return get_sb_single(fs_type, flags, data, bm_fill_super, mnt);
 }
 static struct linux_binfmt misc_format = {
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 44aaba202f78..028d9fb9c2d5 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -300,10 +300,10 @@ static struct super_operations bdev_sops = {
        .clear_inode = bdev_clear_inode,
 };
-static struct super_block *bd_get_sb(struct file_system_type *fs_type,
+static int bd_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576);
+        return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
 }
 static struct file_system_type bd_type = {
diff --git a/fs/buffer.c b/fs/buffer.c
index 23f1f3a68077..373bb6292bdc 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -331,7 +331,6 @@ long do_fsync(struct file *file, int datasync)
                goto out;
        }
-        current->flags |= PF_SYNCWRITE;
        ret = filemap_fdatawrite(mapping);
        /*
@@ -346,7 +345,6 @@ long do_fsync(struct file *file, int datasync)
        err = filemap_fdatawait(mapping);
        if (!ret)
                ret = err;
-        current->flags &= ~PF_SYNCWRITE;
 out:
        return ret;
 }
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index c262d8874ce9..7520f4687158 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -166,8 +166,9 @@ cifs_put_super(struct super_block *sb)
 }
 static int
-cifs_statfs(struct super_block *sb, struct kstatfs *buf)
+cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        int xid; 
        int rc = -EOPNOTSUPP;
        struct cifs_sb_info *cifs_sb;
@@ -460,9 +461,9 @@ struct super_operations cifs_super_ops = {
        .remount_fs = cifs_remount,
 };
-static struct super_block *
+static int
 cifs_get_sb(struct file_system_type *fs_type,
-            int flags, const char *dev_name, void *data)
+            int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
        int rc;
        struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
@@ -470,7 +471,7 @@ cifs_get_sb(struct file_system_type *fs_type,
        cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
        if (IS_ERR(sb))
-                return sb;
+                return PTR_ERR(sb);
        sb->s_flags = flags;
@@ -478,10 +479,10 @@ cifs_get_sb(struct file_system_type *fs_type,
        if (rc) {
                up_write(&sb->s_umount);
                deactivate_super(sb);
-                return ERR_PTR(rc);
+                return rc;
        }
        sb->s_flags |= MS_ACTIVE;
-        return sb;
+        return simple_set_mnt(mnt, sb);
 }
 static ssize_t cifs_file_writev(struct file *file, const struct iovec *iov,
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index c98755dca868..d56c0577c710 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -74,7 +74,7 @@ extern ssize_t cifs_user_write(struct file *file, const char __user *write_data,
                         size_t write_size, loff_t * poffset);
 extern int cifs_lock(struct file *, int, struct file_lock *);
 extern int cifs_fsync(struct file *, struct dentry *, int);
-extern int cifs_flush(struct file *);
+extern int cifs_flush(struct file *, fl_owner_t id);
 extern int cifs_file_mmap(struct file * , struct vm_area_struct *);
 extern const struct file_operations cifs_dir_ops;
 extern int cifs_dir_open(struct inode *inode, struct file *file);
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index e2b4ce1dad66..b4a18c1cab0a 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1079,9 +1079,9 @@ static int cifs_writepages(struct address_space *mapping,
        unsigned int bytes_written;
        struct cifs_sb_info *cifs_sb;
        int done = 0;
-        pgoff_t end = -1;
+        pgoff_t end;
        pgoff_t index;
-        int is_range = 0;
+        int range_whole = 0;
        struct kvec iov[32];
        int len;
        int n_iov = 0;
@@ -1122,16 +1122,14 @@ static int cifs_writepages(struct address_space *mapping,
        xid = GetXid();
        pagevec_init(&pvec, 0);
-        if (wbc->sync_mode == WB_SYNC_NONE)
+        if (wbc->range_cyclic) {
                index = mapping->writeback_index; /* Start from prev offset */
-        else {
+                end = -1;
-                index = 0;
+        } else {
-                scanned = 1;
+                index = wbc->range_start >> PAGE_CACHE_SHIFT;
-        }
+                end = wbc->range_end >> PAGE_CACHE_SHIFT;
-        if (wbc->start || wbc->end) {
+                if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
-                index = wbc->start >> PAGE_CACHE_SHIFT;
+                        range_whole = 1;
-                end = wbc->end >> PAGE_CACHE_SHIFT;
-                is_range = 1;
                scanned = 1;
        }
 retry:
@@ -1167,7 +1165,7 @@ retry:
                                break;
                        }
-                        if (unlikely(is_range) && (page->index > end)) {
+                        if (!wbc->range_cyclic && page->index > end) {
                                done = 1;
                                unlock_page(page);
                                break;
@@ -1271,7 +1269,7 @@ retry:
                index = 0;
                goto retry;
        }
-        if (!is_range)
+        if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
                mapping->writeback_index = index;
        FreeXid(xid);
@@ -1419,7 +1417,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
 * As file closes, flush all cached write data for this inode checking
 * for write behind errors.
 */
-int cifs_flush(struct file *file)
+int cifs_flush(struct file *file, fl_owner_t id)
 {
        struct inode * inode = file->f_dentry->d_inode;
        int rc = 0;
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 7c2642431fa5..cc66c681bd11 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -164,7 +164,7 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
        return 0;
 }
-int coda_flush(struct file *coda_file)
+int coda_flush(struct file *coda_file, fl_owner_t id)
 {
        unsigned short flags = coda_file->f_flags & ~O_EXCL;
        unsigned short coda_flags = coda_flags_to_cflags(flags);
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index ada1a81df6bd..87f1dc8aa24b 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -36,7 +36,7 @@
 /* VFS super_block ops */
 static void coda_clear_inode(struct inode *);
 static void coda_put_super(struct super_block *);
-static int coda_statfs(struct super_block *sb, struct kstatfs *buf);
+static int coda_statfs(struct dentry *dentry, struct kstatfs *buf);
 static kmem_cache_t * coda_inode_cachep;
@@ -278,13 +278,13 @@ struct inode_operations coda_file_inode_operations = {
        .setattr        = coda_setattr,
 };
-static int coda_statfs(struct super_block *sb, struct kstatfs *buf)
+static int coda_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        int error;
        
        lock_kernel();
-        error = venus_statfs(sb, buf);
+        error = venus_statfs(dentry, buf);
        unlock_kernel();
@@ -307,10 +307,10 @@ static int coda_statfs(struct super_block *sb, struct kstatfs *buf)
 /* init_coda: used by filesystems.c to register coda */
-static struct super_block *coda_get_sb(struct file_system_type *fs_type,
+static int coda_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, coda_fill_super);
+        return get_sb_nodev(fs_type, flags, data, coda_fill_super, mnt);
 }
 struct file_system_type coda_fs_type = {
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 1bae99650a91..b040eba13a7d 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -611,7 +611,7 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
        return error;
 }
-int venus_statfs(struct super_block *sb, struct kstatfs *sfs) 
+int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
 { 
        union inputArgs *inp;
        union outputArgs *outp;
@@ -620,7 +620,7 @@ int venus_statfs(struct super_block *sb, struct kstatfs *sfs)
        insize = max_t(unsigned int, INSIZE(statfs), OUTSIZE(statfs));
        UPARG(CODA_STATFS);
-        error = coda_upcall(coda_sbp(sb), insize, &outsize, inp);
+        error = coda_upcall(coda_sbp(dentry->d_sb), insize, &outsize, inp);
        
        if (!error) {
                sfs->f_blocks = outp->coda_statfs.stat.f_blocks;
diff --git a/fs/compat.c b/fs/compat.c
index b1f64786a613..7e7e5bc4f3cf 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -197,7 +197,7 @@ asmlinkage long compat_sys_statfs(const char __user *path, struct compat_statfs
        error = user_path_walk(path, &nd);
        if (!error) {
                struct kstatfs tmp;
-                error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
+                error = vfs_statfs(nd.dentry, &tmp);
                if (!error)
                        error = put_compat_statfs(buf, &tmp);
                path_release(&nd);
@@ -215,7 +215,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->d_inode->i_sb, &tmp);
+        error = vfs_statfs(file->f_dentry, &tmp);
        if (!error)
                error = put_compat_statfs(buf, &tmp);
        fput(file);
@@ -265,7 +265,7 @@ asmlinkage long compat_sys_statfs64(const char __user *path, compat_size_t sz, s
        error = user_path_walk(path, &nd);
        if (!error) {
                struct kstatfs tmp;
-                error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
+                error = vfs_statfs(nd.dentry, &tmp);
                if (!error)
                        error = put_compat_statfs64(buf, &tmp);
                path_release(&nd);
@@ -286,7 +286,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->d_inode->i_sb, &tmp);
+        error = vfs_statfs(file->f_dentry, &tmp);
        if (!error)
                error = put_compat_statfs64(buf, &tmp);
        fput(file);
diff --git a/fs/configfs/mount.c b/fs/configfs/mount.c
index f920d30478e5..94dab7bdd851 100644
--- a/fs/configfs/mount.c
+++ b/fs/configfs/mount.c
@@ -103,10 +103,10 @@ static int configfs_fill_super(struct super_block *sb, void *data, int silent)
        return 0;
 }
-static struct super_block *configfs_get_sb(struct file_system_type *fs_type,
+static int configfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, configfs_fill_super);
+        return get_sb_single(fs_type, flags, data, configfs_fill_super, mnt);
 }
 static struct file_system_type configfs_fs_type = {
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 9efcc3a164e8..c45d73860803 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -181,9 +181,7 @@ static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned i
                struct page *page = NULL;
                if (blocknr + i < devsize) {
-                        page = read_cache_page(mapping, blocknr + i,
+                        page = read_mapping_page(mapping, blocknr + i, NULL);
-                                (filler_t *)mapping->a_ops->readpage,
-                                NULL);
                        /* synchronous error? */
                        if (IS_ERR(page))
                                page = NULL;
@@ -322,8 +320,10 @@ out:
        return -EINVAL;
 }
-static int cramfs_statfs(struct super_block *sb, struct kstatfs *buf)
+static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        buf->f_type = CRAMFS_MAGIC;
        buf->f_bsize = PAGE_CACHE_SIZE;
        buf->f_blocks = CRAMFS_SB(sb)->blocks;
@@ -528,10 +528,11 @@ static struct super_operations cramfs_ops = {
        .statfs         = cramfs_statfs,
 };
-static struct super_block *cramfs_get_sb(struct file_system_type *fs_type,
+static int cramfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, cramfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, cramfs_fill_super,
+                           mnt);
 }
 static struct file_system_type cramfs_fs_type = {
diff --git a/fs/dcache.c b/fs/dcache.c
index 59dbc92c2079..313b54b2b8f2 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -687,46 +687,6 @@ void shrink_dcache_parent(struct dentry * parent)
                prune_dcache(found, parent->d_sb);
 }
-/**
- * shrink_dcache_anon - further prune the cache
- * @head: head of d_hash list of dentries to prune
- *
- * Prune the dentries that are anonymous
- *
- * parsing d_hash list does not hlist_for_each_entry_rcu() as it
- * done under dcache_lock.
- *
- */
-void shrink_dcache_anon(struct super_block *sb)
-{
-        struct hlist_node *lp;
-        struct hlist_head *head = &sb->s_anon;
-        int found;
-        do {
-                found = 0;
-                spin_lock(&dcache_lock);
-                hlist_for_each(lp, head) {
-                        struct dentry *this = hlist_entry(lp, struct dentry, d_hash);
-                        if (!list_empty(&this->d_lru)) {
-                                dentry_stat.nr_unused--;
-                                list_del_init(&this->d_lru);
-                        }
-                        /* 
-                         * move only zero ref count dentries to the end 
-                         * of the unused list for prune_dcache
-                         */
-                        if (!atomic_read(&this->d_count)) {
-                                list_add_tail(&this->d_lru, &dentry_unused);
-                                dentry_stat.nr_unused++;
-                                found++;
-                        }
-                }
-                spin_unlock(&dcache_lock);
-                prune_dcache(found, sb);
-        } while(found);
-}
 /*
 * Scan `nr' dentries and return the number which remain.
 *
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index b55b4ea9a676..440128ebef3b 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -111,11 +111,11 @@ static int debug_fill_super(struct super_block *sb, void *data, int silent)
        return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
 }
-static struct super_block *debug_get_sb(struct file_system_type *fs_type,
+static int debug_get_sb(struct file_system_type *fs_type,
-                                        int flags, const char *dev_name,
+                        int flags, const char *dev_name,
-                                        void *data)
+                        void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, debug_fill_super);
+        return get_sb_single(fs_type, flags, data, debug_fill_super, mnt);
 }
 static struct file_system_type debug_fs_type = {
diff --git a/fs/devfs/base.c b/fs/devfs/base.c
index 52f5059c4f31..51a97f132745 100644
--- a/fs/devfs/base.c
+++ b/fs/devfs/base.c
@@ -2549,11 +2549,11 @@ static int devfs_fill_super(struct super_block *sb, void *data, int silent)
        return -EINVAL;
 }                               /*  End Function devfs_fill_super  */
-static struct super_block *devfs_get_sb(struct file_system_type *fs_type,
+static int devfs_get_sb(struct file_system_type *fs_type,
-                                        int flags, const char *dev_name,
+                        int flags, const char *dev_name,
-                                        void *data)
+                        void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, devfs_fill_super);
+        return get_sb_single(fs_type, flags, data, devfs_fill_super, mnt);
 }
 static struct file_system_type devfs_fs_type = {
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 14c5620b5cab..f7aef5bb584a 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -130,10 +130,10 @@ fail:
        return -ENOMEM;
 }
-static struct super_block *devpts_get_sb(struct file_system_type *fs_type,
+static int devpts_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, devpts_fill_super);
+        return get_sb_single(fs_type, flags, data, devpts_fill_super, mnt);
 }
 static struct file_system_type devpts_fs_type = {
diff --git a/fs/direct-io.c b/fs/direct-io.c
index b05d1b218776..538fb0418fba 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -162,7 +162,7 @@ static int dio_refill_pages(struct dio *dio)
                NULL);                          /* vmas */
        up_read(&current->mm->mmap_sem);
-        if (ret < 0 && dio->blocks_available && (dio->rw == WRITE)) {
+        if (ret < 0 && dio->blocks_available && (dio->rw & WRITE)) {
                struct page *page = ZERO_PAGE(dio->curr_user_address);
                /*
                 * A memory fault, but the filesystem has some outstanding
@@ -535,7 +535,7 @@ static int get_more_blocks(struct dio *dio)
                map_bh->b_state = 0;
                map_bh->b_size = fs_count << dio->inode->i_blkbits;
-                create = dio->rw == WRITE;
+                create = dio->rw & WRITE;
                if (dio->lock_type == DIO_LOCKING) {
                        if (dio->block_in_file < (i_size_read(dio->inode) >>
                                                        dio->blkbits))
@@ -867,7 +867,7 @@ do_holes:
                                loff_t i_size_aligned;
                                /* AKPM: eargh, -ENOTBLK is a hack */
-                                if (dio->rw == WRITE) {
+                                if (dio->rw & WRITE) {
                                        page_cache_release(page);
                                        return -ENOTBLK;
                                }
@@ -1045,7 +1045,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
                }
        } /* end iovec loop */
-        if (ret == -ENOTBLK && rw == WRITE) {
+        if (ret == -ENOTBLK && (rw & WRITE)) {
                /*
                 * The remaining part of the request will be
                 * be handled by buffered I/O when we return
@@ -1089,7 +1089,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        if (dio->is_async) {
                int should_wait = 0;
-                if (dio->result < dio->size && rw == WRITE) {
+                if (dio->result < dio->size && (rw & WRITE)) {
                        dio->waiter = current;
                        should_wait = 1;
                }
@@ -1142,7 +1142,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
                        ret = transferred;
                /* We could have also come here on an AIO file extend */
-                if (!is_sync_kiocb(iocb) && rw == WRITE &&
+                if (!is_sync_kiocb(iocb) && (rw & WRITE) &&
                    ret >= 0 && dio->result == dio->size)
                        /*
                         * For AIO writes where we have completed the
@@ -1194,7 +1194,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
        int acquire_i_mutex = 0;
        if (rw & WRITE)
-                current->flags |= PF_SYNCWRITE;
+                rw = WRITE_SYNC;
        if (bdev)
                bdev_blkbits = blksize_bits(bdev_hardsect_size(bdev));
@@ -1270,7 +1270,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         * even for AIO, we need to wait for i/o to complete before
         * returning in this case.
         */
-        dio->is_async = !is_sync_kiocb(iocb) && !((rw == WRITE) &&
+        dio->is_async = !is_sync_kiocb(iocb) && !((rw & WRITE) &&
                (end > i_size_read(inode)));
        retval = direct_io_worker(rw, iocb, inode, iov, offset,
@@ -1284,8 +1284,6 @@ out:
                mutex_unlock(&inode->i_mutex);
        else if (acquire_i_mutex)
                mutex_lock(&inode->i_mutex);
-        if (rw & WRITE)
-                current->flags &= ~PF_SYNCWRITE;
        return retval;
 }
 EXPORT_SYMBOL(__blockdev_direct_IO);
diff --git a/fs/efs/super.c b/fs/efs/super.c
index dff623e3ddbf..8ac2462ae5dd 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -15,13 +15,13 @@
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
-static int efs_statfs(struct super_block *s, struct kstatfs *buf);
+static int efs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int efs_fill_super(struct super_block *s, void *d, int silent);
-static struct super_block *efs_get_sb(struct file_system_type *fs_type,
+static int efs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, efs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, efs_fill_super, mnt);
 }
 static struct file_system_type efs_fs_type = {
@@ -322,8 +322,8 @@ out_no_fs:
        return -EINVAL;
 }
-static int efs_statfs(struct super_block *s, struct kstatfs *buf) {
+static int efs_statfs(struct dentry *dentry, struct kstatfs *buf) {
-        struct efs_sb_info *sb = SUPER_INFO(s);
+        struct efs_sb_info *sb = SUPER_INFO(dentry->d_sb);
        buf->f_type    = EFS_SUPER_MAGIC;       /* efs magic number */
        buf->f_bsize   = EFS_BLOCKSIZE;         /* blocksize */
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 2695337d4d64..08e7e6a555ca 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -268,9 +268,9 @@ static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
                   int maxevents, long timeout);
 static int eventpollfs_delete_dentry(struct dentry *dentry);
 static struct inode *ep_eventpoll_inode(void);
-static struct super_block *eventpollfs_get_sb(struct file_system_type *fs_type,
+static int eventpollfs_get_sb(struct file_system_type *fs_type,
-                                              int flags, const char *dev_name,
+                              int flags, const char *dev_name,
-                                              void *data);
+                              void *data, struct vfsmount *mnt);
 /*
 * This semaphore is used to serialize ep_free() and eventpoll_release_file().
@@ -1595,11 +1595,12 @@ eexit_1:
 }
-static struct super_block *
+static int
 eventpollfs_get_sb(struct file_system_type *fs_type, int flags,
-                   const char *dev_name, void *data)
+                   const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_pseudo(fs_type, "eventpoll:", NULL, EVENTPOLLFS_MAGIC);
+        return get_sb_pseudo(fs_type, "eventpoll:", NULL, EVENTPOLLFS_MAGIC,
+                             mnt);
 }
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index d672aa9f4061..3c1c9aaaca6b 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -159,8 +159,7 @@ fail:
 static struct page * ext2_get_page(struct inode *dir, unsigned long n)
 {
        struct address_space *mapping = dir->i_mapping;
-        struct page *page = read_cache_page(mapping, n,
+        struct page *page = read_mapping_page(mapping, n, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                kmap(page);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 7e30bae174ed..ee4ba759581e 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -39,7 +39,7 @@
 static void ext2_sync_super(struct super_block *sb,
                            struct ext2_super_block *es);
 static int ext2_remount (struct super_block * sb, int * flags, char * data);
-static int ext2_statfs (struct super_block * sb, struct kstatfs * buf);
+static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
 void ext2_error (struct super_block * sb, const char * function,
                 const char * fmt, ...)
@@ -834,9 +834,6 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
                printk ("EXT2-fs: not enough memory\n");
                goto failed_mount;
        }
-        percpu_counter_init(&sbi->s_freeblocks_counter);
-        percpu_counter_init(&sbi->s_freeinodes_counter);
-        percpu_counter_init(&sbi->s_dirs_counter);
        bgl_lock_init(&sbi->s_blockgroup_lock);
        sbi->s_debts = kmalloc(sbi->s_groups_count * sizeof(*sbi->s_debts),
                               GFP_KERNEL);
@@ -863,6 +860,13 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_gdb_count = db_count;
        get_random_bytes(&sbi->s_next_generation, sizeof(u32));
        spin_lock_init(&sbi->s_next_gen_lock);
+        percpu_counter_init(&sbi->s_freeblocks_counter,
+                                ext2_count_free_blocks(sb));
+        percpu_counter_init(&sbi->s_freeinodes_counter,
+                                ext2_count_free_inodes(sb));
+        percpu_counter_init(&sbi->s_dirs_counter,
+                                ext2_count_dirs(sb));
        /*
         * set up enough so that it can read an inode
         */
@@ -874,24 +878,18 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        if (!sb->s_root) {
                iput(root);
                printk(KERN_ERR "EXT2-fs: get root inode failed\n");
-                goto failed_mount2;
+                goto failed_mount3;
        }
        if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
                dput(sb->s_root);
                sb->s_root = NULL;
                printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
-                goto failed_mount2;
+                goto failed_mount3;
        }
        if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
                ext2_warning(sb, __FUNCTION__,
                        "mounting ext3 filesystem as ext2");
        ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
-        percpu_counter_mod(&sbi->s_freeblocks_counter,
-                                ext2_count_free_blocks(sb));
-        percpu_counter_mod(&sbi->s_freeinodes_counter,
-                                ext2_count_free_inodes(sb));
-        percpu_counter_mod(&sbi->s_dirs_counter,
-                                ext2_count_dirs(sb));
        return 0;
 cantfind_ext2:
@@ -899,7 +897,10 @@ cantfind_ext2:
                printk("VFS: Can't find an ext2 filesystem on dev %s.\n",
                       sb->s_id);
        goto failed_mount;
+failed_mount3:
+        percpu_counter_destroy(&sbi->s_freeblocks_counter);
+        percpu_counter_destroy(&sbi->s_freeinodes_counter);
+        percpu_counter_destroy(&sbi->s_dirs_counter);
 failed_mount2:
        for (i = 0; i < db_count; i++)
                brelse(sbi->s_group_desc[i]);
@@ -1038,8 +1039,9 @@ restore_opts:
        return err;
 }
-static int ext2_statfs (struct super_block * sb, struct kstatfs * buf)
+static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct ext2_sb_info *sbi = EXT2_SB(sb);
        unsigned long overhead;
        int i;
@@ -1087,10 +1089,10 @@ static int ext2_statfs (struct super_block * sb, struct kstatfs * buf)
        return 0;
 }
-static struct super_block *ext2_get_sb(struct file_system_type *fs_type,
+static int ext2_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
 }
 #ifdef CONFIG_QUOTA
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index f8a5266ea1ff..a60cc6ec130f 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -58,7 +58,7 @@ static int ext3_sync_fs(struct super_block *sb, int wait);
 static const char *ext3_decode_error(struct super_block * sb, int errno,
                                     char nbuf[16]);
 static int ext3_remount (struct super_block * sb, int * flags, char * data);
-static int ext3_statfs (struct super_block * sb, struct kstatfs * buf);
+static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf);
 static void ext3_unlockfs(struct super_block *sb);
 static void ext3_write_super (struct super_block * sb);
 static void ext3_write_super_lockfs(struct super_block *sb);
@@ -499,20 +499,21 @@ static void ext3_clear_inode(struct inode *inode)
 {
        struct ext3_block_alloc_info *rsv = EXT3_I(inode)->i_block_alloc_info;
 #ifdef CONFIG_EXT3_FS_POSIX_ACL
-       if (EXT3_I(inode)->i_acl &&
+        if (EXT3_I(inode)->i_acl &&
-           EXT3_I(inode)->i_acl != EXT3_ACL_NOT_CACHED) {
+                        EXT3_I(inode)->i_acl != EXT3_ACL_NOT_CACHED) {
-               posix_acl_release(EXT3_I(inode)->i_acl);
+                posix_acl_release(EXT3_I(inode)->i_acl);
-               EXT3_I(inode)->i_acl = EXT3_ACL_NOT_CACHED;
+                EXT3_I(inode)->i_acl = EXT3_ACL_NOT_CACHED;
-       }
+        }
-       if (EXT3_I(inode)->i_default_acl &&
+        if (EXT3_I(inode)->i_default_acl &&
-           EXT3_I(inode)->i_default_acl != EXT3_ACL_NOT_CACHED) {
+                        EXT3_I(inode)->i_default_acl != EXT3_ACL_NOT_CACHED) {
-               posix_acl_release(EXT3_I(inode)->i_default_acl);
+                posix_acl_release(EXT3_I(inode)->i_default_acl);
-               EXT3_I(inode)->i_default_acl = EXT3_ACL_NOT_CACHED;
+                EXT3_I(inode)->i_default_acl = EXT3_ACL_NOT_CACHED;
-       }
+        }
 #endif
        ext3_discard_reservation(inode);
        EXT3_I(inode)->i_block_alloc_info = NULL;
-        kfree(rsv);
+        if (unlikely(rsv))
+                kfree(rsv);
 }
 static inline void ext3_show_quota_options(struct seq_file *seq, struct super_block *sb)
@@ -1579,9 +1580,6 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                goto failed_mount;
        }
-        percpu_counter_init(&sbi->s_freeblocks_counter);
-        percpu_counter_init(&sbi->s_freeinodes_counter);
-        percpu_counter_init(&sbi->s_dirs_counter);
        bgl_lock_init(&sbi->s_blockgroup_lock);
        for (i = 0; i < db_count; i++) {
@@ -1601,6 +1599,14 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        sbi->s_gdb_count = db_count;
        get_random_bytes(&sbi->s_next_generation, sizeof(u32));
        spin_lock_init(&sbi->s_next_gen_lock);
+        percpu_counter_init(&sbi->s_freeblocks_counter,
+                ext3_count_free_blocks(sb));
+        percpu_counter_init(&sbi->s_freeinodes_counter,
+                ext3_count_free_inodes(sb));
+        percpu_counter_init(&sbi->s_dirs_counter,
+                ext3_count_dirs(sb));
        /* per fileystem reservation list head & lock */
        spin_lock_init(&sbi->s_rsv_window_lock);
        sbi->s_rsv_window_root = RB_ROOT;
@@ -1639,16 +1645,16 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        if (!test_opt(sb, NOLOAD) &&
            EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
                if (ext3_load_journal(sb, es, journal_devnum))
-                        goto failed_mount2;
+                        goto failed_mount3;
        } else if (journal_inum) {
                if (ext3_create_journal(sb, es, journal_inum))
-                        goto failed_mount2;
+                        goto failed_mount3;
        } else {
                if (!silent)
                        printk (KERN_ERR
                                "ext3: No journal on filesystem on %s\n",
                                sb->s_id);
-                goto failed_mount2;
+                goto failed_mount3;
        }
        /* We have now updated the journal if required, so we can
@@ -1671,7 +1677,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                    (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
                        printk(KERN_ERR "EXT3-fs: Journal does not support "
                               "requested data journaling mode\n");
-                        goto failed_mount3;
+                        goto failed_mount4;
                }
        default:
                break;
@@ -1694,13 +1700,13 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        if (!sb->s_root) {
                printk(KERN_ERR "EXT3-fs: get root inode failed\n");
                iput(root);
-                goto failed_mount3;
+                goto failed_mount4;
        }
        if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
                dput(sb->s_root);
                sb->s_root = NULL;
                printk(KERN_ERR "EXT3-fs: corrupt root inode, run e2fsck\n");
-                goto failed_mount3;
+                goto failed_mount4;
        }
        ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
@@ -1723,13 +1729,6 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
                "writeback");
-        percpu_counter_mod(&sbi->s_freeblocks_counter,
-                ext3_count_free_blocks(sb));
-        percpu_counter_mod(&sbi->s_freeinodes_counter,
-                ext3_count_free_inodes(sb));
-        percpu_counter_mod(&sbi->s_dirs_counter,
-                ext3_count_dirs(sb));
        lock_kernel();
        return 0;
@@ -1739,8 +1738,12 @@ cantfind_ext3:
                       sb->s_id);
        goto failed_mount;
-failed_mount3:
+failed_mount4:
        journal_destroy(sbi->s_journal);
+failed_mount3:
+        percpu_counter_destroy(&sbi->s_freeblocks_counter);
+        percpu_counter_destroy(&sbi->s_freeinodes_counter);
+        percpu_counter_destroy(&sbi->s_dirs_counter);
 failed_mount2:
        for (i = 0; i < db_count; i++)
                brelse(sbi->s_group_desc[i]);
@@ -2318,8 +2321,9 @@ restore_opts:
        return err;
 }
-static int ext3_statfs (struct super_block * sb, struct kstatfs * buf)
+static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct ext3_sb_info *sbi = EXT3_SB(sb);
        struct ext3_super_block *es = sbi->s_es;
        unsigned long overhead;
@@ -2646,10 +2650,10 @@ out:
 #endif
-static struct super_block *ext3_get_sb(struct file_system_type *fs_type,
+static int ext3_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ext3_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ext3_fill_super, mnt);
 }
 static struct file_system_type ext3_fs_type = {
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index c1ce284f8a94..7c35d582ec10 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -539,18 +539,18 @@ static int fat_remount(struct super_block *sb, int *flags, char *data)
        return 0;
 }
-static int fat_statfs(struct super_block *sb, struct kstatfs *buf)
+static int fat_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct msdos_sb_info *sbi = MSDOS_SB(sb);
+        struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
        /* If the count of free cluster is still unknown, counts it here. */
        if (sbi->free_clusters == -1) {
-                int err = fat_count_free_clusters(sb);
+                int err = fat_count_free_clusters(dentry->d_sb);
                if (err)
                        return err;
        }
-        buf->f_type = sb->s_magic;
+        buf->f_type = dentry->d_sb->s_magic;
        buf->f_bsize = sbi->cluster_size;
        buf->f_blocks = sbi->max_cluster - FAT_START_ENT;
        buf->f_bfree = sbi->free_clusters;
diff --git a/fs/fat/misc.c b/fs/fat/misc.c
index 944652e9dde1..308f2b6b5026 100644
--- a/fs/fat/misc.c
+++ b/fs/fat/misc.c
@@ -210,4 +210,3 @@ int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs)
        return err;
 }
-EXPORT_SYMBOL_GPL(fat_sync_bhs);
diff --git a/fs/file_table.c b/fs/file_table.c
index bcea1998b4de..506d5307108d 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -300,5 +300,5 @@ void __init files_init(unsigned long mempages)
        if (files_stat.max_files < NR_FILE)
                files_stat.max_files = NR_FILE;
        files_defer_init();
-        percpu_counter_init(&nr_files);
+        percpu_counter_init(&nr_files, 0);
 } 
diff --git a/fs/freevxfs/vxfs_subr.c b/fs/freevxfs/vxfs_subr.c
index 50aae77651b2..c1be118fc067 100644
--- a/fs/freevxfs/vxfs_subr.c
+++ b/fs/freevxfs/vxfs_subr.c
@@ -71,8 +71,7 @@ vxfs_get_page(struct address_space *mapping, u_long n)
 {
        struct page *                   pp;
-        pp = read_cache_page(mapping, n,
+        pp = read_mapping_page(mapping, n, NULL);
-                        (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(pp)) {
                wait_on_page_locked(pp);
diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index b44c916d24a1..b74b791fc23b 100644
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -40,6 +40,7 @@
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/vfs.h>
+#include <linux/mount.h>
 #include "vxfs.h"
 #include "vxfs_extern.h"
@@ -55,7 +56,7 @@ MODULE_ALIAS("vxfs"); /* makes mount -t vxfs autoload the module */
 static void             vxfs_put_super(struct super_block *);
-static int              vxfs_statfs(struct super_block *, struct kstatfs *);
+static int              vxfs_statfs(struct dentry *, struct kstatfs *);
 static int              vxfs_remount(struct super_block *, int *, char *);
 static struct super_operations vxfs_super_ops = {
@@ -90,12 +91,12 @@ vxfs_put_super(struct super_block *sbp)
 /**
 * vxfs_statfs - get filesystem information
- * @sbp:        VFS superblock
+ * @dentry:     VFS dentry to locate superblock
 * @bufp:       output buffer
 *
 * Description:
 *   vxfs_statfs fills the statfs buffer @bufp with information
- *   about the filesystem described by @sbp.
+ *   about the filesystem described by @dentry.
 *
 * Returns:
 *   Zero.
@@ -107,12 +108,12 @@ vxfs_put_super(struct super_block *sbp)
 *   This is everything but complete...
 */
 static int
-vxfs_statfs(struct super_block *sbp, struct kstatfs *bufp)
+vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp)
 {
-        struct vxfs_sb_info             *infp = VXFS_SBI(sbp);
+        struct vxfs_sb_info             *infp = VXFS_SBI(dentry->d_sb);
        bufp->f_type = VXFS_SUPER_MAGIC;
-        bufp->f_bsize = sbp->s_blocksize;
+        bufp->f_bsize = dentry->d_sb->s_blocksize;
        bufp->f_blocks = infp->vsi_raw->vs_dsize;
        bufp->f_bfree = infp->vsi_raw->vs_free;
        bufp->f_bavail = 0;
@@ -241,10 +242,11 @@ out:
 /*
 * The usual module blurb.
 */
-static struct super_block *vxfs_get_sb(struct file_system_type *fs_type,
+static int vxfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, vxfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, vxfs_fill_super,
+                           mnt);
 }
 static struct file_system_type vxfs_fs_type = {
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index f3fbe2d030f4..031b27a4bc9a 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -461,6 +461,8 @@ void sync_inodes_sb(struct super_block *sb, int wait)
 {
        struct writeback_control wbc = {
                .sync_mode      = wait ? WB_SYNC_ALL : WB_SYNC_HOLD,
+                .range_start    = 0,
+                .range_end      = LLONG_MAX,
        };
        unsigned long nr_dirty = read_page_state(nr_dirty);
        unsigned long nr_unstable = read_page_state(nr_unstable);
@@ -559,6 +561,8 @@ int write_inode_now(struct inode *inode, int sync)
        struct writeback_control wbc = {
                .nr_to_write = LONG_MAX,
                .sync_mode = WB_SYNC_ALL,
+                .range_start = 0,
+                .range_end = LLONG_MAX,
        };
        if (!mapping_cap_writeback_dirty(inode->i_mapping))
@@ -619,7 +623,6 @@ int generic_osync_inode(struct inode *inode, struct address_space *mapping, int
        int need_write_inode_now = 0;
        int err2;
-        current->flags |= PF_SYNCWRITE;
        if (what & OSYNC_DATA)
                err = filemap_fdatawrite(mapping);
        if (what & (OSYNC_METADATA|OSYNC_DATA)) {
@@ -632,7 +635,6 @@ int generic_osync_inode(struct inode *inode, struct address_space *mapping, int
                if (!err)
                        err = err2;
        }
-        current->flags &= ~PF_SYNCWRITE;
        spin_lock(&inode_lock);
        if ((inode->i_state & I_DIRTY) &&
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index fc342cf7c2cc..087f3b734f40 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -169,7 +169,7 @@ static int fuse_release(struct inode *inode, struct file *file)
        return fuse_release_common(inode, file, 0);
 }
-static int fuse_flush(struct file *file)
+static int fuse_flush(struct file *file, fl_owner_t id)
 {
        struct inode *inode = file->f_dentry->d_inode;
        struct fuse_conn *fc = get_fuse_conn(inode);
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 7627022446b2..a13c0f529058 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -236,8 +236,9 @@ static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr
        /* fsid is left zero */
 }
-static int fuse_statfs(struct super_block *sb, struct kstatfs *buf)
+static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct fuse_conn *fc = get_fuse_conn_super(sb);
        struct fuse_req *req;
        struct fuse_statfs_out outarg;
@@ -569,11 +570,11 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
        return err;
 }
-static struct super_block *fuse_get_sb(struct file_system_type *fs_type,
+static int fuse_get_sb(struct file_system_type *fs_type,
-                                       int flags, const char *dev_name,
+                       int flags, const char *dev_name,
-                                       void *raw_data)
+                       void *raw_data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super);
+        return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
 }
 static struct file_system_type fuse_fs_type = {
diff --git a/fs/hfs/bnode.c b/fs/hfs/bnode.c
index 1e44dcfe49c4..13231dd5ce66 100644
--- a/fs/hfs/bnode.c
+++ b/fs/hfs/bnode.c
@@ -280,7 +280,7 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
        block = off >> PAGE_CACHE_SHIFT;
        node->page_offset = off & ~PAGE_CACHE_MASK;
        for (i = 0; i < tree->pages_per_bnode; i++) {
-                page = read_cache_page(mapping, block++, (filler_t *)mapping->a_ops->readpage, NULL);
+                page = read_mapping_page(mapping, block++, NULL);
                if (IS_ERR(page))
                        goto fail;
                if (PageError(page)) {
diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
index d20131ce4b95..400357994319 100644
--- a/fs/hfs/btree.c
+++ b/fs/hfs/btree.c
@@ -59,7 +59,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id, btree_keycmp ke
        unlock_new_inode(tree->inode);
        mapping = tree->inode->i_mapping;
-        page = read_cache_page(mapping, 0, (filler_t *)mapping->a_ops->readpage, NULL);
+        page = read_mapping_page(mapping, 0, NULL);
        if (IS_ERR(page))
                goto free_tree;
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 1181d116117d..d9227bf14e86 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -80,8 +80,10 @@ static void hfs_put_super(struct super_block *sb)
 *
 * changed f_files/f_ffree to reflect the fs_ablock/free_ablocks.
 */
-static int hfs_statfs(struct super_block *sb, struct kstatfs *buf)
+static int hfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        buf->f_type = HFS_SUPER_MAGIC;
        buf->f_bsize = sb->s_blocksize;
        buf->f_blocks = (u32)HFS_SB(sb)->fs_ablocks * HFS_SB(sb)->fs_div;
@@ -413,10 +415,11 @@ bail:
        return res;
 }
-static struct super_block *hfs_get_sb(struct file_system_type *fs_type,
+static int hfs_get_sb(struct file_system_type *fs_type,
-                                      int flags, const char *dev_name, void *data)
+                      int flags, const char *dev_name, void *data,
+                      struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, hfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, hfs_fill_super, mnt);
 }
 static struct file_system_type hfs_fs_type = {
diff --git a/fs/hfsplus/bitmap.c b/fs/hfsplus/bitmap.c
index 9fb51632303c..d128a25b74d2 100644
--- a/fs/hfsplus/bitmap.c
+++ b/fs/hfsplus/bitmap.c
@@ -31,8 +31,7 @@ int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset, u32 *ma
        dprint(DBG_BITMAP, "block_allocate: %u,%u,%u\n", size, offset, len);
        mutex_lock(&HFSPLUS_SB(sb).alloc_file->i_mutex);
        mapping = HFSPLUS_SB(sb).alloc_file->i_mapping;
-        page = read_cache_page(mapping, offset / PAGE_CACHE_BITS,
+        page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS, NULL);
-                               (filler_t *)mapping->a_ops->readpage, NULL);
        pptr = kmap(page);
        curr = pptr + (offset & (PAGE_CACHE_BITS - 1)) / 32;
        i = offset % 32;
@@ -72,8 +71,8 @@ int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset, u32 *ma
                offset += PAGE_CACHE_BITS;
                if (offset >= size)
                        break;
-                page = read_cache_page(mapping, offset / PAGE_CACHE_BITS,
+                page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS,
-                                       (filler_t *)mapping->a_ops->readpage, NULL);
+                                         NULL);
                curr = pptr = kmap(page);
                if ((size ^ offset) / PAGE_CACHE_BITS)
                        end = pptr + PAGE_CACHE_BITS / 32;
@@ -119,8 +118,8 @@ found:
                set_page_dirty(page);
                kunmap(page);
                offset += PAGE_CACHE_BITS;
-                page = read_cache_page(mapping, offset / PAGE_CACHE_BITS,
+                page = read_mapping_page(mapping, offset / PAGE_CACHE_BITS,
-                                       (filler_t *)mapping->a_ops->readpage, NULL);
+                                         NULL);
                pptr = kmap(page);
                curr = pptr;
                end = pptr + PAGE_CACHE_BITS / 32;
@@ -167,7 +166,7 @@ int hfsplus_block_free(struct super_block *sb, u32 offset, u32 count)
        mutex_lock(&HFSPLUS_SB(sb).alloc_file->i_mutex);
        mapping = HFSPLUS_SB(sb).alloc_file->i_mapping;
        pnr = offset / PAGE_CACHE_BITS;
-        page = read_cache_page(mapping, pnr, (filler_t *)mapping->a_ops->readpage, NULL);
+        page = read_mapping_page(mapping, pnr, NULL);
        pptr = kmap(page);
        curr = pptr + (offset & (PAGE_CACHE_BITS - 1)) / 32;
        end = pptr + PAGE_CACHE_BITS / 32;
@@ -199,7 +198,7 @@ int hfsplus_block_free(struct super_block *sb, u32 offset, u32 count)
                        break;
                set_page_dirty(page);
                kunmap(page);
-                page = read_cache_page(mapping, ++pnr, (filler_t *)mapping->a_ops->readpage, NULL);
+                page = read_mapping_page(mapping, ++pnr, NULL);
                pptr = kmap(page);
                curr = pptr;
                end = pptr + PAGE_CACHE_BITS / 32;
diff --git a/fs/hfsplus/bnode.c b/fs/hfsplus/bnode.c
index 746abc9ecf70..77bf434da679 100644
--- a/fs/hfsplus/bnode.c
+++ b/fs/hfsplus/bnode.c
@@ -440,7 +440,7 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
        block = off >> PAGE_CACHE_SHIFT;
        node->page_offset = off & ~PAGE_CACHE_MASK;
        for (i = 0; i < tree->pages_per_bnode; block++, i++) {
-                page = read_cache_page(mapping, block, (filler_t *)mapping->a_ops->readpage, NULL);
+                page = read_mapping_page(mapping, block, NULL);
                if (IS_ERR(page))
                        goto fail;
                if (PageError(page)) {
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index effa8991999c..cfc852fdd1b5 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -38,7 +38,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
                goto free_tree;
        mapping = tree->inode->i_mapping;
-        page = read_cache_page(mapping, 0, (filler_t *)mapping->a_ops->readpage, NULL);
+        page = read_mapping_page(mapping, 0, NULL);
        if (IS_ERR(page))
                goto free_tree;
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index 7843f792a4b7..0a92fa2336a2 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -212,8 +212,10 @@ static void hfsplus_put_super(struct super_block *sb)
        sb->s_fs_info = NULL;
 }
-static int hfsplus_statfs(struct super_block *sb, struct kstatfs *buf)
+static int hfsplus_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        buf->f_type = HFSPLUS_SUPER_MAGIC;
        buf->f_bsize = sb->s_blocksize;
        buf->f_blocks = HFSPLUS_SB(sb).total_blocks << HFSPLUS_SB(sb).fs_shift;
@@ -450,10 +452,12 @@ static void hfsplus_destroy_inode(struct inode *inode)
 #define HFSPLUS_INODE_SIZE      sizeof(struct hfsplus_inode_info)
-static struct super_block *hfsplus_get_sb(struct file_system_type *fs_type,
+static int hfsplus_get_sb(struct file_system_type *fs_type,
-                                          int flags, const char *dev_name, void *data)
+                          int flags, const char *dev_name, void *data,
+                          struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, hfsplus_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, hfsplus_fill_super,
+                           mnt);
 }
 static struct file_system_type hfsplus_fs_type = {
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index bf0f8e16e433..8e0d37743e7c 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -239,7 +239,7 @@ static int read_inode(struct inode *ino)
        return(err);
 }
-int hostfs_statfs(struct super_block *sb, struct kstatfs *sf)
+int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
 {
        /* do_statfs uses struct statfs64 internally, but the linux kernel
         * struct statfs still has 32-bit versions for most of these fields,
@@ -252,7 +252,7 @@ int hostfs_statfs(struct super_block *sb, struct kstatfs *sf)
        long long f_files;
        long long f_ffree;
-        err = do_statfs(HOSTFS_I(sb->s_root->d_inode)->host_filename,
+        err = do_statfs(HOSTFS_I(dentry->d_sb->s_root->d_inode)->host_filename,
                        &sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
                        &f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
                        &sf->f_namelen, sf->f_spare);
@@ -993,11 +993,11 @@ static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
        return(err);
 }
-static struct super_block *hostfs_read_sb(struct file_system_type *type,
+static int hostfs_read_sb(struct file_system_type *type,
-                                             int flags, const char *dev_name,
+                          int flags, const char *dev_name,
-                                             void *data)
+                          void *data, struct vfsmount *mnt)
 {
-        return(get_sb_nodev(type, flags, data, hostfs_fill_sb_common));
+        return get_sb_nodev(type, flags, data, hostfs_fill_sb_common, mnt);
 }
 static struct file_system_type hostfs_type = {
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index d72d8c87c996..f798480a363f 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -135,8 +135,9 @@ static unsigned count_bitmaps(struct super_block *s)
        return count;
 }
-static int hpfs_statfs(struct super_block *s, struct kstatfs *buf)
+static int hpfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *s = dentry->d_sb;
        struct hpfs_sb_info *sbi = hpfs_sb(s);
        lock_kernel();
@@ -662,10 +663,11 @@ bail0:
        return -EINVAL;
 }
-static struct super_block *hpfs_get_sb(struct file_system_type *fs_type,
+static int hpfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, hpfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, hpfs_fill_super,
+                           mnt);
 }
 static struct file_system_type hpfs_fs_type = {
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs_kern.c
index 5e6363be246f..3a9bdf58166f 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs_kern.c
@@ -616,7 +616,7 @@ static const struct file_operations hppfs_dir_fops = {
        .fsync          = hppfs_fsync,
 };
-static int hppfs_statfs(struct super_block *sb, struct kstatfs *sf)
+static int hppfs_statfs(struct dentry *dentry, struct kstatfs *sf)
 {
        sf->f_blocks = 0;
        sf->f_bfree = 0;
@@ -769,11 +769,11 @@ static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
        return(err);
 }
-static struct super_block *hppfs_read_super(struct file_system_type *type,
+static int hppfs_read_super(struct file_system_type *type,
-                                             int flags, const char *dev_name,
+                            int flags, const char *dev_name,
-                                             void *data)
+                            void *data, struct vfsmount *mnt)
 {
-        return(get_sb_nodev(type, flags, data, hppfs_fill_super));
+        return get_sb_nodev(type, flags, data, hppfs_fill_super, mnt);
 }
 static struct file_system_type hppfs_type = {
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 3a5b4e923455..e6410d8edd0e 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -59,7 +59,6 @@ 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 hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
        loff_t len, vma_len;
        int ret;
@@ -87,9 +86,10 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
        if (!(vma->vm_flags & VM_WRITE) && len > inode->i_size)
                goto out;
-        if (vma->vm_flags & VM_MAYSHARE)
+        if (vma->vm_flags & VM_MAYSHARE &&
-                if (hugetlb_extend_reservation(info, len >> HPAGE_SHIFT) != 0)
+            hugetlb_reserve_pages(inode, vma->vm_pgoff >> (HPAGE_SHIFT-PAGE_SHIFT),
-                        goto out;
+                                  len >> HPAGE_SHIFT))
+                goto out;
        ret = 0;
        hugetlb_prefault_arch_hook(vma->vm_mm);
@@ -195,12 +195,8 @@ static void truncate_hugepages(struct inode *inode, loff_t lstart)
        const pgoff_t start = lstart >> HPAGE_SHIFT;
        struct pagevec pvec;
        pgoff_t next;
-        int i;
+        int i, freed = 0;
-        hugetlb_truncate_reservation(HUGETLBFS_I(inode),
-                                     lstart >> HPAGE_SHIFT);
-        if (!mapping->nrpages)
-                return;
        pagevec_init(&pvec, 0);
        next = start;
        while (1) {
@@ -221,10 +217,12 @@ static void truncate_hugepages(struct inode *inode, loff_t lstart)
                        truncate_huge_page(page);
                        unlock_page(page);
                        hugetlb_put_quota(mapping);
+                        freed++;
                }
                huge_pagevec_release(&pvec);
        }
        BUG_ON(!lstart && mapping->nrpages);
+        hugetlb_unreserve_pages(inode, start, freed);
 }
 static void hugetlbfs_delete_inode(struct inode *inode)
@@ -366,6 +364,7 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid,
                inode->i_mapping->a_ops = &hugetlbfs_aops;
                inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                INIT_LIST_HEAD(&inode->i_mapping->private_list);
                info = HUGETLBFS_I(inode);
                mpol_shared_policy_init(&info->policy, MPOL_DEFAULT, NULL);
                switch (mode & S_IFMT) {
@@ -467,9 +466,9 @@ static int hugetlbfs_set_page_dirty(struct page *page)
        return 0;
 }
-static int hugetlbfs_statfs(struct super_block *sb, struct kstatfs *buf)
+static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(sb);
+        struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb);
        buf->f_type = HUGETLBFS_MAGIC;
        buf->f_bsize = HPAGE_SIZE;
@@ -538,7 +537,6 @@ static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
                hugetlbfs_inc_free_inodes(sbinfo);
                return NULL;
        }
-        p->prereserved_hpages = 0;
        return &p->vfs_inode;
 }
@@ -723,10 +721,10 @@ void hugetlb_put_quota(struct address_space *mapping)
        }
 }
-static struct super_block *hugetlbfs_get_sb(struct file_system_type *fs_type,
+static int hugetlbfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, hugetlbfs_fill_super);
+        return get_sb_nodev(fs_type, flags, data, hugetlbfs_fill_super, mnt);
 }
 static struct file_system_type hugetlbfs_fs_type = {
@@ -781,8 +779,7 @@ struct file *hugetlb_zero_setup(size_t size)
                goto out_file;
        error = -ENOMEM;
-        if (hugetlb_extend_reservation(HUGETLBFS_I(inode),
+        if (hugetlb_reserve_pages(inode, 0, size >> HPAGE_SHIFT))
-                                       size >> HPAGE_SHIFT) != 0)
                goto out_inode;
        d_instantiate(dentry, inode);
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index 9e9931e2badd..f2386442adee 100644
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -672,11 +672,11 @@ out:
        return ret;
 }
-static struct super_block *
+static int
 inotify_get_sb(struct file_system_type *fs_type, int flags,
-               const char *dev_name, void *data)
+               const char *dev_name, void *data, struct vfsmount *mnt)
 {
-    return get_sb_pseudo(fs_type, "inotify", NULL, 0xBAD1DEA);
+        return get_sb_pseudo(fs_type, "inotify", NULL, 0xBAD1DEA, mnt);
 }
 static struct file_system_type inotify_fs_type = {
diff --git a/fs/ioprio.c b/fs/ioprio.c
index ca77008146c0..7fa76ed53c10 100644
--- a/fs/ioprio.c
+++ b/fs/ioprio.c
@@ -24,15 +24,21 @@
 #include <linux/blkdev.h>
 #include <linux/capability.h>
 #include <linux/syscalls.h>
+#include <linux/security.h>
 static int set_task_ioprio(struct task_struct *task, int ioprio)
 {
+        int err;
        struct io_context *ioc;
        if (task->uid != current->euid &&
            task->uid != current->uid && !capable(CAP_SYS_NICE))
                return -EPERM;
+        err = security_task_setioprio(task, ioprio);
+        if (err)
+                return err;
        task_lock(task);
        task->ioprio = ioprio;
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 70adbb98bad1..3f9c8ba1fa1f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -56,7 +56,7 @@ static void isofs_put_super(struct super_block *sb)
 }
 static void isofs_read_inode(struct inode *);
-static int isofs_statfs (struct super_block *, struct kstatfs *);
+static int isofs_statfs (struct dentry *, struct kstatfs *);
 static kmem_cache_t *isofs_inode_cachep;
@@ -901,8 +901,10 @@ out_freesbi:
        return -EINVAL;
 }
-static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
+static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        buf->f_type = ISOFS_SUPER_MAGIC;
        buf->f_bsize = sb->s_blocksize;
        buf->f_blocks = (ISOFS_SB(sb)->s_nzones
@@ -1399,10 +1401,11 @@ struct inode *isofs_iget(struct super_block *sb,
        return inode;
 }
-static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
+static int isofs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super,
+                           mnt);
 }
 static struct file_system_type iso9660_fs_type = {
diff --git a/fs/jbd/checkpoint.c b/fs/jbd/checkpoint.c
index 3f5102b069db..47678a26c13b 100644
--- a/fs/jbd/checkpoint.c
+++ b/fs/jbd/checkpoint.c
@@ -24,29 +24,67 @@
 #include <linux/slab.h>
 /*
- * Unlink a buffer from a transaction.
+ * Unlink a buffer from a transaction checkpoint list.
 *
 * Called with j_list_lock held.
 */
+static inline void __buffer_unlink_first(struct journal_head *jh)
-static inline void __buffer_unlink(struct journal_head *jh)
 {
-        transaction_t *transaction;
+        transaction_t *transaction = jh->b_cp_transaction;
-        transaction = jh->b_cp_transaction;
-        jh->b_cp_transaction = NULL;
        jh->b_cpnext->b_cpprev = jh->b_cpprev;
        jh->b_cpprev->b_cpnext = jh->b_cpnext;
-        if (transaction->t_checkpoint_list == jh)
+        if (transaction->t_checkpoint_list == jh) {
                transaction->t_checkpoint_list = jh->b_cpnext;
-        if (transaction->t_checkpoint_list == jh)
+                if (transaction->t_checkpoint_list == jh)
-                transaction->t_checkpoint_list = NULL;
+                        transaction->t_checkpoint_list = NULL;
+        }
+}
+/*
+ * Unlink a buffer from a transaction checkpoint(io) list.
+ *
+ * Called with j_list_lock held.
+ */
+static inline void __buffer_unlink(struct journal_head *jh)
+{
+        transaction_t *transaction = jh->b_cp_transaction;
+        __buffer_unlink_first(jh);
+        if (transaction->t_checkpoint_io_list == jh) {
+                transaction->t_checkpoint_io_list = jh->b_cpnext;
+                if (transaction->t_checkpoint_io_list == jh)
+                        transaction->t_checkpoint_io_list = NULL;
+        }
+}
+/*
+ * Move a buffer from the checkpoint list to the checkpoint io list
+ *
+ * Called with j_list_lock held
+ */
+static inline void __buffer_relink_io(struct journal_head *jh)
+{
+        transaction_t *transaction = jh->b_cp_transaction;
+        __buffer_unlink_first(jh);
+        if (!transaction->t_checkpoint_io_list) {
+                jh->b_cpnext = jh->b_cpprev = jh;
+        } else {
+                jh->b_cpnext = transaction->t_checkpoint_io_list;
+                jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
+                jh->b_cpprev->b_cpnext = jh;
+                jh->b_cpnext->b_cpprev = jh;
+        }
+        transaction->t_checkpoint_io_list = jh;
 }
 /*
 * Try to release a checkpointed buffer from its transaction.
- * Returns 1 if we released it.
+ * Returns 1 if we released it and 2 if we also released the
+ * whole transaction.
+ *
 * Requires j_list_lock
 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
 */
@@ -57,12 +95,11 @@ static int __try_to_free_cp_buf(struct journal_head *jh)
        if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {
                JBUFFER_TRACE(jh, "remove from checkpoint list");
-                __journal_remove_checkpoint(jh);
+                ret = __journal_remove_checkpoint(jh) + 1;
                jbd_unlock_bh_state(bh);
                journal_remove_journal_head(bh);
                BUFFER_TRACE(bh, "release");
                __brelse(bh);
-                ret = 1;
        } else {
                jbd_unlock_bh_state(bh);
        }
@@ -117,83 +154,54 @@ static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
 }
 /*
- * Clean up a transaction's checkpoint list.
+ * Clean up transaction's list of buffers submitted for io.
- *
+ * We wait for any pending IO to complete and remove any clean
- * We wait for any pending IO to complete and make sure any clean
+ * buffers. Note that we take the buffers in the opposite ordering
- * buffers are removed from the transaction.
+ * from the one in which they were submitted for IO.
- *
- * Return 1 if we performed any actions which might have destroyed the
- * checkpoint.  (journal_remove_checkpoint() deletes the transaction when
- * the last checkpoint buffer is cleansed)
 *
 * Called with j_list_lock held.
 */
-static int __cleanup_transaction(journal_t *journal, transaction_t *transaction)
+static void __wait_cp_io(journal_t *journal, transaction_t *transaction)
 {
-        struct journal_head *jh, *next_jh, *last_jh;
+        struct journal_head *jh;
        struct buffer_head *bh;
-        int ret = 0;
+        tid_t this_tid;
+        int released = 0;
-        assert_spin_locked(&journal->j_list_lock);
-        jh = transaction->t_checkpoint_list;
+        this_tid = transaction->t_tid;
-        if (!jh)
+restart:
-                return 0;
+        /* Did somebody clean up the transaction in the meanwhile? */
+        if (journal->j_checkpoint_transactions != transaction ||
-        last_jh = jh->b_cpprev;
+                        transaction->t_tid != this_tid)
-        next_jh = jh;
+                return;
-        do {
+        while (!released && transaction->t_checkpoint_io_list) {
-                jh = next_jh;
+                jh = transaction->t_checkpoint_io_list;
                bh = jh2bh(jh);
+                if (!jbd_trylock_bh_state(bh)) {
+                        jbd_sync_bh(journal, bh);
+                        spin_lock(&journal->j_list_lock);
+                        goto restart;
+                }
                if (buffer_locked(bh)) {
                        atomic_inc(&bh->b_count);
                        spin_unlock(&journal->j_list_lock);
+                        jbd_unlock_bh_state(bh);
                        wait_on_buffer(bh);
                        /* the journal_head may have gone by now */
                        BUFFER_TRACE(bh, "brelse");
                        __brelse(bh);
-                        goto out_return_1;
+                        spin_lock(&journal->j_list_lock);
+                        goto restart;
                }
                /*
-                 * This is foul
+                 * Now in whatever state the buffer currently is, we know that
+                 * it has been written out and so we can drop it from the list
                 */
-                if (!jbd_trylock_bh_state(bh)) {
+                released = __journal_remove_checkpoint(jh);
-                        jbd_sync_bh(journal, bh);
+                jbd_unlock_bh_state(bh);
-                        goto out_return_1;
+                journal_remove_journal_head(bh);
-                }
+                __brelse(bh);
+        }
-                if (jh->b_transaction != NULL) {
-                        transaction_t *t = jh->b_transaction;
-                        tid_t tid = t->t_tid;
-                        spin_unlock(&journal->j_list_lock);
-                        jbd_unlock_bh_state(bh);
-                        log_start_commit(journal, tid);
-                        log_wait_commit(journal, tid);
-                        goto out_return_1;
-                }
-                /*
-                 * AKPM: I think the buffer_jbddirty test is redundant - it
-                 * shouldn't have NULL b_transaction?
-                 */
-                next_jh = jh->b_cpnext;
-                if (!buffer_dirty(bh) && !buffer_jbddirty(bh)) {
-                        BUFFER_TRACE(bh, "remove from checkpoint");
-                        __journal_remove_checkpoint(jh);
-                        jbd_unlock_bh_state(bh);
-                        journal_remove_journal_head(bh);
-                        __brelse(bh);
-                        ret = 1;
-                } else {
-                        jbd_unlock_bh_state(bh);
-                }
-        } while (jh != last_jh);
-        return ret;
-out_return_1:
-        spin_lock(&journal->j_list_lock);
-        return 1;
 }
 #define NR_BATCH        64
@@ -203,9 +211,7 @@ __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
 {
        int i;
-        spin_unlock(&journal->j_list_lock);
        ll_rw_block(SWRITE, *batch_count, bhs);
-        spin_lock(&journal->j_list_lock);
        for (i = 0; i < *batch_count; i++) {
                struct buffer_head *bh = bhs[i];
                clear_buffer_jwrite(bh);
@@ -221,19 +227,43 @@ __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
 * Return 1 if something happened which requires us to abort the current
 * scan of the checkpoint list.  
 *
- * Called with j_list_lock held.
+ * Called with j_list_lock held and drops it if 1 is returned
 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
 */
-static int __flush_buffer(journal_t *journal, struct journal_head *jh,
+static int __process_buffer(journal_t *journal, struct journal_head *jh,
-                        struct buffer_head **bhs, int *batch_count,
+                        struct buffer_head **bhs, int *batch_count)
-                        int *drop_count)
 {
        struct buffer_head *bh = jh2bh(jh);
        int ret = 0;
-        if (buffer_dirty(bh) && !buffer_locked(bh) && jh->b_jlist == BJ_None) {
+        if (buffer_locked(bh)) {
-                J_ASSERT_JH(jh, jh->b_transaction == NULL);
+                atomic_inc(&bh->b_count);
+                spin_unlock(&journal->j_list_lock);
+                jbd_unlock_bh_state(bh);
+                wait_on_buffer(bh);
+                /* the journal_head may have gone by now */
+                BUFFER_TRACE(bh, "brelse");
+                __brelse(bh);
+                ret = 1;
+        } else if (jh->b_transaction != NULL) {
+                transaction_t *t = jh->b_transaction;
+                tid_t tid = t->t_tid;
+                spin_unlock(&journal->j_list_lock);
+                jbd_unlock_bh_state(bh);
+                log_start_commit(journal, tid);
+                log_wait_commit(journal, tid);
+                ret = 1;
+        } else if (!buffer_dirty(bh)) {
+                J_ASSERT_JH(jh, !buffer_jbddirty(bh));
+                BUFFER_TRACE(bh, "remove from checkpoint");
+                __journal_remove_checkpoint(jh);
+                spin_unlock(&journal->j_list_lock);
+                jbd_unlock_bh_state(bh);
+                journal_remove_journal_head(bh);
+                __brelse(bh);
+                ret = 1;
+        } else {
                /*
                 * Important: we are about to write the buffer, and
                 * possibly block, while still holding the journal lock.
@@ -246,45 +276,30 @@ static int __flush_buffer(journal_t *journal, struct journal_head *jh,
                J_ASSERT_BH(bh, !buffer_jwrite(bh));
                set_buffer_jwrite(bh);
                bhs[*batch_count] = bh;
+                __buffer_relink_io(jh);
                jbd_unlock_bh_state(bh);
                (*batch_count)++;
                if (*batch_count == NR_BATCH) {
+                        spin_unlock(&journal->j_list_lock);
                        __flush_batch(journal, bhs, batch_count);
                        ret = 1;
                }
-        } else {
-                int last_buffer = 0;
-                if (jh->b_cpnext == jh) {
-                        /* We may be about to drop the transaction.  Tell the
-                         * caller that the lists have changed.
-                         */
-                        last_buffer = 1;
-                }
-                if (__try_to_free_cp_buf(jh)) {
-                        (*drop_count)++;
-                        ret = last_buffer;
-                }
        }
        return ret;
 }
 /*
- * Perform an actual checkpoint.  We don't write out only enough to
+ * Perform an actual checkpoint. We take the first transaction on the
- * satisfy the current blocked requests: rather we submit a reasonably
+ * list of transactions to be checkpointed and send all its buffers
- * sized chunk of the outstanding data to disk at once for
+ * to disk. We submit larger chunks of data at once.
- * efficiency.  __log_wait_for_space() will retry if we didn't free enough.
 * 
- * However, we _do_ take into account the amount requested so that once
- * the IO has been queued, we can return as soon as enough of it has
- * completed to disk.
- *
 * The journal should be locked before calling this function.
 */
 int log_do_checkpoint(journal_t *journal)
 {
+        transaction_t *transaction;
+        tid_t this_tid;
        int result;
-        int batch_count = 0;
-        struct buffer_head *bhs[NR_BATCH];
        jbd_debug(1, "Start checkpoint\n");
@@ -299,79 +314,68 @@ int log_do_checkpoint(journal_t *journal)
                return result;
        /*
-         * OK, we need to start writing disk blocks.  Try to free up a
+         * OK, we need to start writing disk blocks.  Take one transaction
-         * quarter of the log in a single checkpoint if we can.
+         * and write it.
         */
+        spin_lock(&journal->j_list_lock);
+        if (!journal->j_checkpoint_transactions)
+                goto out;
+        transaction = journal->j_checkpoint_transactions;
+        this_tid = transaction->t_tid;
+restart:
        /*
-         * AKPM: check this code.  I had a feeling a while back that it
+         * If someone cleaned up this transaction while we slept, we're
-         * degenerates into a busy loop at unmount time.
+         * done (maybe it's a new transaction, but it fell at the same
+         * address).
         */
-        spin_lock(&journal->j_list_lock);
+        if (journal->j_checkpoint_transactions == transaction &&
-        while (journal->j_checkpoint_transactions) {
+                        transaction->t_tid == this_tid) {
-                transaction_t *transaction;
+                int batch_count = 0;
-                struct journal_head *jh, *last_jh, *next_jh;
+                struct buffer_head *bhs[NR_BATCH];
-                int drop_count = 0;
+                struct journal_head *jh;
-                int cleanup_ret, retry = 0;
+                int retry = 0;
-                tid_t this_tid;
+                while (!retry && transaction->t_checkpoint_list) {
-                transaction = journal->j_checkpoint_transactions;
-                this_tid = transaction->t_tid;
-                jh = transaction->t_checkpoint_list;
-                last_jh = jh->b_cpprev;
-                next_jh = jh;
-                do {
                        struct buffer_head *bh;
-                        jh = next_jh;
+                        jh = transaction->t_checkpoint_list;
-                        next_jh = jh->b_cpnext;
                        bh = jh2bh(jh);
                        if (!jbd_trylock_bh_state(bh)) {
                                jbd_sync_bh(journal, bh);
-                                spin_lock(&journal->j_list_lock);
                                retry = 1;
                                break;
                        }
-                        retry = __flush_buffer(journal, jh, bhs, &batch_count, &drop_count);
+                        retry = __process_buffer(journal, jh, bhs,&batch_count);
-                        if (cond_resched_lock(&journal->j_list_lock)) {
+                        if (!retry && lock_need_resched(&journal->j_list_lock)){
+                                spin_unlock(&journal->j_list_lock);
                                retry = 1;
                                break;
                        }
-                } while (jh != last_jh && !retry);
+                }
                if (batch_count) {
+                        if (!retry) {
+                                spin_unlock(&journal->j_list_lock);
+                                retry = 1;
+                        }
                        __flush_batch(journal, bhs, &batch_count);
-                        retry = 1;
                }
+                if (retry) {
+                        spin_lock(&journal->j_list_lock);
+                        goto restart;
+                }
                /*
-                 * If someone cleaned up this transaction while we slept, we're
+                 * Now we have cleaned up the first transaction's checkpoint
-                 * done
+                 * list. Let's clean up the second one
-                 */
-                if (journal->j_checkpoint_transactions != transaction)
-                        break;
-                if (retry)
-                        continue;
-                /*
-                 * Maybe it's a new transaction, but it fell at the same
-                 * address
-                 */
-                if (transaction->t_tid != this_tid)
-                        continue;
-                /*
-                 * We have walked the whole transaction list without
-                 * finding anything to write to disk.  We had better be
-                 * able to make some progress or we are in trouble.
                 */
-                cleanup_ret = __cleanup_transaction(journal, transaction);
+                __wait_cp_io(journal, transaction);
-                J_ASSERT(drop_count != 0 || cleanup_ret != 0);
-                if (journal->j_checkpoint_transactions != transaction)
-                        break;
        }
+out:
        spin_unlock(&journal->j_list_lock);
        result = cleanup_journal_tail(journal);
        if (result < 0)
                return result;
        return 0;
 }
@@ -456,52 +460,98 @@ int cleanup_journal_tail(journal_t *journal)
 /* Checkpoint list management */
 /*
+ * journal_clean_one_cp_list
+ *
+ * Find all the written-back checkpoint buffers in the given list and release them.
+ *
+ * Called with the journal locked.
+ * Called with j_list_lock held.
+ * Returns number of bufers reaped (for debug)
+ */
+static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
+{
+        struct journal_head *last_jh;
+        struct journal_head *next_jh = jh;
+        int ret, freed = 0;
+        *released = 0;
+        if (!jh)
+                return 0;
+        last_jh = jh->b_cpprev;
+        do {
+                jh = next_jh;
+                next_jh = jh->b_cpnext;
+                /* Use trylock because of the ranking */
+                if (jbd_trylock_bh_state(jh2bh(jh))) {
+                        ret = __try_to_free_cp_buf(jh);
+                        if (ret) {
+                                freed++;
+                                if (ret == 2) {
+                                        *released = 1;
+                                        return freed;
+                                }
+                        }
+                }
+                /*
+                 * This function only frees up some memory
+                 * if possible so we dont have an obligation
+                 * to finish processing. Bail out if preemption
+                 * requested:
+                 */
+                if (need_resched())
+                        return freed;
+        } while (jh != last_jh);
+        return freed;
+}
+/*
 * journal_clean_checkpoint_list
 *
 * Find all the written-back checkpoint buffers in the journal and release them.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
- * Returns number of bufers reaped (for debug)
+ * Returns number of buffers reaped (for debug)
 */
 int __journal_clean_checkpoint_list(journal_t *journal)
 {
        transaction_t *transaction, *last_transaction, *next_transaction;
        int ret = 0;
+        int released;
        transaction = journal->j_checkpoint_transactions;
-        if (transaction == 0)
+        if (!transaction)
                goto out;
        last_transaction = transaction->t_cpprev;
        next_transaction = transaction;
        do {
-                struct journal_head *jh;
                transaction = next_transaction;
                next_transaction = transaction->t_cpnext;
-                jh = transaction->t_checkpoint_list;
+                ret += journal_clean_one_cp_list(transaction->
-                if (jh) {
+                                t_checkpoint_list, &released);
-                        struct journal_head *last_jh = jh->b_cpprev;
+                /*
-                        struct journal_head *next_jh = jh;
+                 * This function only frees up some memory if possible so we
+                 * dont have an obligation to finish processing. Bail out if
-                        do {
+                 * preemption requested:
-                                jh = next_jh;
+                 */
-                                next_jh = jh->b_cpnext;
+                if (need_resched())
-                                /* Use trylock because of the ranknig */
+                        goto out;
-                                if (jbd_trylock_bh_state(jh2bh(jh)))
+                if (released)
-                                        ret += __try_to_free_cp_buf(jh);
+                        continue;
-                                /*
+                /*
-                                 * This function only frees up some memory
+                 * It is essential that we are as careful as in the case of
-                                 * if possible so we dont have an obligation
+                 * t_checkpoint_list with removing the buffer from the list as
-                                 * to finish processing. Bail out if preemption
+                 * we can possibly see not yet submitted buffers on io_list
-                                 * requested:
+                 */
-                                 */
+                ret += journal_clean_one_cp_list(transaction->
-                                if (need_resched())
+                                t_checkpoint_io_list, &released);
-                                        goto out;
+                if (need_resched())
-                        } while (jh != last_jh);
+                        goto out;
-                }
        } while (transaction != last_transaction);
 out:
        return ret;
@@ -516,18 +566,22 @@ out:
 * buffer updates committed in that transaction have safely been stored
 * elsewhere on disk.  To achieve this, all of the buffers in a
 * transaction need to be maintained on the transaction's checkpoint
- * list until they have been rewritten, at which point this function is
+ * lists until they have been rewritten, at which point this function is
 * called to remove the buffer from the existing transaction's
- * checkpoint list.
+ * checkpoint lists.
+ *
+ * The function returns 1 if it frees the transaction, 0 otherwise.
 *
 * This function is called with the journal locked.
 * This function is called with j_list_lock held.
+ * This function is called with jbd_lock_bh_state(jh2bh(jh))
 */
-void __journal_remove_checkpoint(struct journal_head *jh)
+int __journal_remove_checkpoint(struct journal_head *jh)
 {
        transaction_t *transaction;
        journal_t *journal;
+        int ret = 0;
        JBUFFER_TRACE(jh, "entry");
@@ -538,8 +592,10 @@ void __journal_remove_checkpoint(struct journal_head *jh)
        journal = transaction->t_journal;
        __buffer_unlink(jh);
+        jh->b_cp_transaction = NULL;
-        if (transaction->t_checkpoint_list != NULL)
+        if (transaction->t_checkpoint_list != NULL ||
+            transaction->t_checkpoint_io_list != NULL)
                goto out;
        JBUFFER_TRACE(jh, "transaction has no more buffers");
@@ -565,8 +621,10 @@ void __journal_remove_checkpoint(struct journal_head *jh)
        /* Just in case anybody was waiting for more transactions to be
           checkpointed... */
        wake_up(&journal->j_wait_logspace);
+        ret = 1;
 out:
        JBUFFER_TRACE(jh, "exit");
+        return ret;
 }
 /*
@@ -628,6 +686,7 @@ void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
        J_ASSERT(transaction->t_shadow_list == NULL);
        J_ASSERT(transaction->t_log_list == NULL);
        J_ASSERT(transaction->t_checkpoint_list == NULL);
+        J_ASSERT(transaction->t_checkpoint_io_list == NULL);
        J_ASSERT(transaction->t_updates == 0);
        J_ASSERT(journal->j_committing_transaction != transaction);
        J_ASSERT(journal->j_running_transaction != transaction);
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 002ad2bbc769..0971814c38b8 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -790,11 +790,22 @@ restart_loop:
                        jbd_unlock_bh_state(bh);
                } else {
                        J_ASSERT_BH(bh, !buffer_dirty(bh));
-                        J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
+                        /* The buffer on BJ_Forget list and not jbddirty means
-                        __journal_unfile_buffer(jh);
+                         * it has been freed by this transaction and hence it
-                        jbd_unlock_bh_state(bh);
+                         * could not have been reallocated until this
-                        journal_remove_journal_head(bh);  /* needs a brelse */
+                         * transaction has committed. *BUT* it could be
-                        release_buffer_page(bh);
+                         * reallocated once we have written all the data to
+                         * disk and before we process the buffer on BJ_Forget
+                         * list. */
+                        JBUFFER_TRACE(jh, "refile or unfile freed buffer");
+                        __journal_refile_buffer(jh);
+                        if (!jh->b_transaction) {
+                                jbd_unlock_bh_state(bh);
+                                 /* needs a brelse */
+                                journal_remove_journal_head(bh);
+                                release_buffer_page(bh);
+                        } else
+                                jbd_unlock_bh_state(bh);
                }
                cond_resched_lock(&journal->j_list_lock);
        }
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index c609f5034fcd..508b2ea91f43 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -227,7 +227,8 @@ repeat_locked:
        spin_unlock(&transaction->t_handle_lock);
        spin_unlock(&journal->j_state_lock);
 out:
-        kfree(new_transaction);
+        if (unlikely(new_transaction))          /* It's usually NULL */
+                kfree(new_transaction);
        return ret;
 }
@@ -724,7 +725,8 @@ done:
        journal_cancel_revoke(handle, jh);
 out:
-        kfree(frozen_buffer);
+        if (unlikely(frozen_buffer))    /* It's usually NULL */
+                kfree(frozen_buffer);
        JBUFFER_TRACE(jh, "exit");
        return error;
@@ -903,7 +905,8 @@ repeat:
        jbd_unlock_bh_state(bh);
 out:
        journal_put_journal_head(jh);
-        kfree(committed_data);
+        if (unlikely(committed_data))
+                kfree(committed_data);
        return err;
 }
@@ -2038,7 +2041,8 @@ void __journal_refile_buffer(struct journal_head *jh)
        __journal_temp_unlink_buffer(jh);
        jh->b_transaction = jh->b_next_transaction;
        jh->b_next_transaction = NULL;
-        __journal_file_buffer(jh, jh->b_transaction, BJ_Metadata);
+        __journal_file_buffer(jh, jh->b_transaction,
+                                was_dirty ? BJ_Metadata : BJ_Reserved);
        J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
        if (was_dirty)
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 020cc097c539..9e46ea6da752 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -377,9 +377,9 @@ jffs_new_inode(const struct inode * dir, struct jffs_raw_inode *raw_inode,
 /* Get statistics of the file system.  */
 static int
-jffs_statfs(struct super_block *sb, struct kstatfs *buf)
+jffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct jffs_control *c = (struct jffs_control *) sb->s_fs_info;
+        struct jffs_control *c = (struct jffs_control *) dentry->d_sb->s_fs_info;
        struct jffs_fmcontrol *fmc;
        lock_kernel();
@@ -1785,10 +1785,11 @@ static struct super_operations jffs_ops =
        .remount_fs     = jffs_remount,
 };
-static struct super_block *jffs_get_sb(struct file_system_type *fs_type,
+static int jffs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, jffs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, jffs_fill_super,
+                           mnt);
 }
 static struct file_system_type jffs_fs_type = {
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 7b6c24b14f85..2900ec3ec3af 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -192,9 +192,9 @@ int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
        return rc;
 }
-int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
+int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
        unsigned long avail;
        buf->f_type = JFFS2_SUPER_MAGIC;
diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index cd4021bcb944..6b5223565405 100644
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -175,7 +175,7 @@ void jffs2_clear_inode (struct inode *);
 void jffs2_dirty_inode(struct inode *inode);
 struct inode *jffs2_new_inode (struct inode *dir_i, int mode,
                               struct jffs2_raw_inode *ri);
-int jffs2_statfs (struct super_block *, struct kstatfs *);
+int jffs2_statfs (struct dentry *, struct kstatfs *);
 void jffs2_write_super (struct super_block *);
 int jffs2_remount_fs (struct super_block *, int *, char *);
 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent);
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 9d0521451f59..2378a662c256 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -111,9 +111,10 @@ static int jffs2_sb_set(struct super_block *sb, void *data)
        return 0;
 }
-static struct super_block *jffs2_get_sb_mtd(struct file_system_type *fs_type,
+static int jffs2_get_sb_mtd(struct file_system_type *fs_type,
-                                              int flags, const char *dev_name,
+                            int flags, const char *dev_name,
-                                              void *data, struct mtd_info *mtd)
+                            void *data, struct mtd_info *mtd,
+                            struct vfsmount *mnt)
 {
        struct super_block *sb;
        struct jffs2_sb_info *c;
@@ -121,19 +122,20 @@ static struct super_block *jffs2_get_sb_mtd(struct file_system_type *fs_type,
        c = kmalloc(sizeof(*c), GFP_KERNEL);
        if (!c)
-                return ERR_PTR(-ENOMEM);
+                return -ENOMEM;
        memset(c, 0, sizeof(*c));
        c->mtd = mtd;
        sb = sget(fs_type, jffs2_sb_compare, jffs2_sb_set, c);
        if (IS_ERR(sb))
-                goto out_put;
+                goto out_error;
        if (sb->s_root) {
                /* New mountpoint for JFFS2 which is already mounted */
                D1(printk(KERN_DEBUG "jffs2_get_sb_mtd(): Device %d (\"%s\") is already mounted\n",
                          mtd->index, mtd->name));
+                ret = simple_set_mnt(mnt, sb);
                goto out_put;
        }
@@ -161,44 +163,47 @@ static struct super_block *jffs2_get_sb_mtd(struct file_system_type *fs_type,
                /* Failure case... */
                up_write(&sb->s_umount);
                deactivate_super(sb);
-                return ERR_PTR(ret);
+                return ret;
        }
        sb->s_flags |= MS_ACTIVE;
-        return sb;
+        return simple_set_mnt(mnt, sb);
+out_error:
+        ret = PTR_ERR(sb);
 out_put:
        kfree(c);
        put_mtd_device(mtd);
-        return sb;
+        return ret;
 }
-static struct super_block *jffs2_get_sb_mtdnr(struct file_system_type *fs_type,
+static int jffs2_get_sb_mtdnr(struct file_system_type *fs_type,
-                                              int flags, const char *dev_name,
+                              int flags, const char *dev_name,
-                                              void *data, int mtdnr)
+                              void *data, int mtdnr,
+                              struct vfsmount *mnt)
 {
        struct mtd_info *mtd;
        mtd = get_mtd_device(NULL, mtdnr);
        if (!mtd) {
                D1(printk(KERN_DEBUG "jffs2: MTD device #%u doesn't appear to exist\n", mtdnr));
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
        }
-        return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd);
+        return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
 }
-static struct super_block *jffs2_get_sb(struct file_system_type *fs_type,
+static int jffs2_get_sb(struct file_system_type *fs_type,
-                                        int flags, const char *dev_name,
+                        int flags, const char *dev_name,
-                                        void *data)
+                        void *data, struct vfsmount *mnt)
 {
        int err;
        struct nameidata nd;
        int mtdnr;
        if (!dev_name)
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
        D1(printk(KERN_DEBUG "jffs2_get_sb(): dev_name \"%s\"\n", dev_name));
@@ -220,7 +225,7 @@ static struct super_block *jffs2_get_sb(struct file_system_type *fs_type,
                                mtd = get_mtd_device(NULL, mtdnr);
                                if (mtd) {
                                        if (!strcmp(mtd->name, dev_name+4))
-                                                return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd);
+                                                return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
                                        put_mtd_device(mtd);
                                }
                        }
@@ -233,7 +238,7 @@ static struct super_block *jffs2_get_sb(struct file_system_type *fs_type,
                        if (!*endptr) {
                                /* It was a valid number */
                                D1(printk(KERN_DEBUG "jffs2_get_sb(): mtd%%d, mtdnr %d\n", mtdnr));
-                                return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr);
+                                return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr, mnt);
                        }
                }
        }
@@ -247,7 +252,7 @@ static struct super_block *jffs2_get_sb(struct file_system_type *fs_type,
                  err, nd.dentry->d_inode));
        if (err)
-                return ERR_PTR(err);
+                return err;
        err = -EINVAL;
@@ -269,11 +274,11 @@ static struct super_block *jffs2_get_sb(struct file_system_type *fs_type,
        mtdnr = iminor(nd.dentry->d_inode);
        path_release(&nd);
-        return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr);
+        return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr, mnt);
 out:
        path_release(&nd);
-        return ERR_PTR(err);
+        return err;
 }
 static void jffs2_put_super (struct super_block *sb)
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 2b220dd6b4e7..7f6e88039700 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -632,10 +632,9 @@ struct metapage *__get_metapage(struct inode *inode, unsigned long lblock,
                }
                SetPageUptodate(page);
        } else {
-                page = read_cache_page(mapping, page_index,
+                page = read_mapping_page(mapping, page_index, NULL);
-                            (filler_t *)mapping->a_ops->readpage, NULL);
                if (IS_ERR(page) || !PageUptodate(page)) {
-                        jfs_err("read_cache_page failed!");
+                        jfs_err("read_mapping_page failed!");
                        return NULL;
                }
                lock_page(page);
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index db6f41d6dd60..73d2aba084c6 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -139,9 +139,9 @@ static void jfs_destroy_inode(struct inode *inode)
        kmem_cache_free(jfs_inode_cachep, ji);
 }
-static int jfs_statfs(struct super_block *sb, struct kstatfs *buf)
+static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct jfs_sb_info *sbi = JFS_SBI(sb);
+        struct jfs_sb_info *sbi = JFS_SBI(dentry->d_sb);
        s64 maxinodes;
        struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
@@ -565,10 +565,11 @@ static void jfs_unlockfs(struct super_block *sb)
        }
 }
-static struct super_block *jfs_get_sb(struct file_system_type *fs_type, 
+static int jfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super,
+                           mnt);
 }
 static int jfs_sync_fs(struct super_block *sb, int wait)
diff --git a/fs/libfs.c b/fs/libfs.c
index 7145ba7a48d0..1b1156381787 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -20,9 +20,9 @@ int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
        return 0;
 }
-int simple_statfs(struct super_block *sb, struct kstatfs *buf)
+int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        buf->f_type = sb->s_magic;
+        buf->f_type = dentry->d_sb->s_magic;
        buf->f_bsize = PAGE_CACHE_SIZE;
        buf->f_namelen = NAME_MAX;
        return 0;
@@ -196,9 +196,9 @@ struct inode_operations simple_dir_inode_operations = {
 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
 * will never be mountable)
 */
-struct super_block *
+int get_sb_pseudo(struct file_system_type *fs_type, char *name,
-get_sb_pseudo(struct file_system_type *fs_type, char *name,
+        struct super_operations *ops, unsigned long magic,
-        struct super_operations *ops, unsigned long magic)
+        struct vfsmount *mnt)
 {
        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
        static struct super_operations default_ops = {.statfs = simple_statfs};
@@ -207,7 +207,7 @@ get_sb_pseudo(struct file_system_type *fs_type, char *name,
        struct qstr d_name = {.name = name, .len = strlen(name)};
        if (IS_ERR(s))
-                return s;
+                return PTR_ERR(s);
        s->s_flags = MS_NOUSER;
        s->s_maxbytes = ~0ULL;
@@ -232,12 +232,12 @@ get_sb_pseudo(struct file_system_type *fs_type, char *name,
        d_instantiate(dentry, root);
        s->s_root = dentry;
        s->s_flags |= MS_ACTIVE;
-        return s;
+        return simple_set_mnt(mnt, s);
 Enomem:
        up_write(&s->s_umount);
        deactivate_super(s);
-        return ERR_PTR(-ENOMEM);
+        return -ENOMEM;
 }
 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
diff --git a/fs/locks.c b/fs/locks.c
index 69435c68c1ed..1ad29c9b6252 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -703,7 +703,7 @@ EXPORT_SYMBOL(posix_test_lock);
 * from a broken NFS client. But broken NFS clients have a lot more to
 * worry about than proper deadlock detection anyway... --okir
 */
-int posix_locks_deadlock(struct file_lock *caller_fl,
+static int posix_locks_deadlock(struct file_lock *caller_fl,
                                struct file_lock *block_fl)
 {
        struct list_head *tmp;
@@ -722,8 +722,6 @@ next_task:
        return 0;
 }
-EXPORT_SYMBOL(posix_locks_deadlock);
 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
 * at the head of the list, but that's secret knowledge known only to
 * flock_lock_file and posix_lock_file.
@@ -794,7 +792,8 @@ out:
 static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
 {
        struct file_lock *fl;
-        struct file_lock *new_fl, *new_fl2;
+        struct file_lock *new_fl = NULL;
+        struct file_lock *new_fl2 = NULL;
        struct file_lock *left = NULL;
        struct file_lock *right = NULL;
        struct file_lock **before;
@@ -803,9 +802,15 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
        /*
         * We may need two file_lock structures for this operation,
         * so we get them in advance to avoid races.
+         *
+         * In some cases we can be sure, that no new locks will be needed
         */
-        new_fl = locks_alloc_lock();
+        if (!(request->fl_flags & FL_ACCESS) &&
-        new_fl2 = locks_alloc_lock();
+            (request->fl_type != F_UNLCK ||
+             request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
+                new_fl = locks_alloc_lock();
+                new_fl2 = locks_alloc_lock();
+        }
        lock_kernel();
        if (request->fl_type != F_UNLCK) {
@@ -834,14 +839,7 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
        if (request->fl_flags & FL_ACCESS)
                goto out;
-        error = -ENOLCK; /* "no luck" */
-        if (!(new_fl && new_fl2))
-                goto out;
        /*
-         * We've allocated the new locks in advance, so there are no
-         * errors possible (and no blocking operations) from here on.
-         * 
         * Find the first old lock with the same owner as the new lock.
         */
        
@@ -938,10 +936,25 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
                before = &fl->fl_next;
        }
+        /*
+         * The above code only modifies existing locks in case of
+         * merging or replacing.  If new lock(s) need to be inserted
+         * all modifications are done bellow this, so it's safe yet to
+         * bail out.
+         */
+        error = -ENOLCK; /* "no luck" */
+        if (right && left == right && !new_fl2)
+                goto out;
        error = 0;
        if (!added) {
                if (request->fl_type == F_UNLCK)
                        goto out;
+                if (!new_fl) {
+                        error = -ENOLCK;
+                        goto out;
+                }
                locks_copy_lock(new_fl, request);
                locks_insert_lock(before, new_fl);
                new_fl = NULL;
@@ -1881,19 +1894,18 @@ out:
 */
 void locks_remove_posix(struct file *filp, fl_owner_t owner)
 {
-        struct file_lock lock, **before;
+        struct file_lock lock;
        /*
         * If there are no locks held on this file, we don't need to call
         * 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.
         */
-        before = &filp->f_dentry->d_inode->i_flock;
+        if (!filp->f_dentry->d_inode->i_flock)
-        if (*before == NULL)
                return;
        lock.fl_type = F_UNLCK;
-        lock.fl_flags = FL_POSIX;
+        lock.fl_flags = FL_POSIX | FL_CLOSE;
        lock.fl_start = 0;
        lock.fl_end = OFFSET_MAX;
        lock.fl_owner = owner;
@@ -1902,25 +1914,11 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner)
        lock.fl_ops = NULL;
        lock.fl_lmops = NULL;
-        if (filp->f_op && filp->f_op->lock != NULL) {
+        if (filp->f_op && filp->f_op->lock != NULL)
                filp->f_op->lock(filp, F_SETLK, &lock);
-                goto out;
+        else
-        }
+                posix_lock_file(filp, &lock);
-        /* Can't use posix_lock_file here; we need to remove it no matter
-         * which pid we have.
-         */
-        lock_kernel();
-        while (*before != NULL) {
-                struct file_lock *fl = *before;
-                if (IS_POSIX(fl) && posix_same_owner(fl, &lock)) {
-                        locks_delete_lock(before);
-                        continue;
-                }
-                before = &fl->fl_next;
-        }
-        unlock_kernel();
-out:
        if (lock.fl_ops && lock.fl_ops->fl_release_private)
                lock.fl_ops->fl_release_private(&lock);
 }
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index 69224d1fe043..2b0a389d1987 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -60,8 +60,7 @@ static int dir_commit_chunk(struct page *page, unsigned from, unsigned to)
 static struct page * dir_get_page(struct inode *dir, unsigned long n)
 {
        struct address_space *mapping = dir->i_mapping;
-        struct page *page = read_cache_page(mapping, n,
+        struct page *page = read_mapping_page(mapping, n, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                kmap(page);
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 2dcccf1d1b7f..a6fb509b7341 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -19,7 +19,7 @@
 static void minix_read_inode(struct inode * inode);
 static int minix_write_inode(struct inode * inode, int wait);
-static int minix_statfs(struct super_block *sb, struct kstatfs *buf);
+static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int minix_remount (struct super_block * sb, int * flags, char * data);
 static void minix_delete_inode(struct inode *inode)
@@ -296,11 +296,11 @@ out_bad_sb:
        return -EINVAL;
 }
-static int minix_statfs(struct super_block *sb, struct kstatfs *buf)
+static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct minix_sb_info *sbi = minix_sb(sb);
+        struct minix_sb_info *sbi = minix_sb(dentry->d_sb);
-        buf->f_type = sb->s_magic;
+        buf->f_type = dentry->d_sb->s_magic;
-        buf->f_bsize = sb->s_blocksize;
+        buf->f_bsize = dentry->d_sb->s_blocksize;
        buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
        buf->f_bfree = minix_count_free_blocks(sbi);
        buf->f_bavail = buf->f_bfree;
@@ -559,10 +559,11 @@ void minix_truncate(struct inode * inode)
                V2_minix_truncate(inode);
 }
-static struct super_block *minix_get_sb(struct file_system_type *fs_type,
+static int minix_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super,
+                           mnt);
 }
 static struct file_system_type minix_fs_type = {
diff --git a/fs/mpage.c b/fs/mpage.c
index 9bf2eb30e6f4..1e4598247d0b 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -707,9 +707,9 @@ mpage_writepages(struct address_space *mapping,
        struct pagevec pvec;
        int nr_pages;
        pgoff_t index;
-        pgoff_t end = -1;               /* Inclusive */
+        pgoff_t end;            /* Inclusive */
        int scanned = 0;
-        int is_range = 0;
+        int range_whole = 0;
        if (wbc->nonblocking && bdi_write_congested(bdi)) {
                wbc->encountered_congestion = 1;
@@ -721,16 +721,14 @@ mpage_writepages(struct address_space *mapping,
                writepage = mapping->a_ops->writepage;
        pagevec_init(&pvec, 0);
-        if (wbc->sync_mode == WB_SYNC_NONE) {
+        if (wbc->range_cyclic) {
                index = mapping->writeback_index; /* Start from prev offset */
+                end = -1;
        } else {
-                index = 0;                        /* whole-file sweep */
+                index = wbc->range_start >> PAGE_CACHE_SHIFT;
-                scanned = 1;
+                end = wbc->range_end >> PAGE_CACHE_SHIFT;
-        }
+                if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
-        if (wbc->start || wbc->end) {
+                        range_whole = 1;
-                index = wbc->start >> PAGE_CACHE_SHIFT;
-                end = wbc->end >> PAGE_CACHE_SHIFT;
-                is_range = 1;
                scanned = 1;
        }
 retry:
@@ -759,7 +757,7 @@ retry:
                                continue;
                        }
-                        if (unlikely(is_range) && page->index > end) {
+                        if (!wbc->range_cyclic && page->index > end) {
                                done = 1;
                                unlock_page(page);
                                continue;
@@ -810,7 +808,7 @@ retry:
                index = 0;
                goto retry;
        }
-        if (!is_range)
+        if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
                mapping->writeback_index = index;
        if (bio)
                mpage_bio_submit(WRITE, bio);
diff --git a/fs/msdos/namei.c b/fs/msdos/namei.c
index 5b76ccd19e3f..9e44158a7540 100644
--- a/fs/msdos/namei.c
+++ b/fs/msdos/namei.c
@@ -661,11 +661,12 @@ static int msdos_fill_super(struct super_block *sb, void *data, int silent)
        return 0;
 }
-static struct super_block *msdos_get_sb(struct file_system_type *fs_type,
+static int msdos_get_sb(struct file_system_type *fs_type,
-                                        int flags, const char *dev_name,
+                        int flags, const char *dev_name,
-                                        void *data)
+                        void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, msdos_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, msdos_fill_super,
+                           mnt);
 }
 static struct file_system_type msdos_fs_type = {
diff --git a/fs/namei.c b/fs/namei.c
index 184fe4acf824..bb4a3e40e432 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2577,8 +2577,7 @@ static char *page_getlink(struct dentry * dentry, struct page **ppage)
 {
        struct page * page;
        struct address_space *mapping = dentry->d_inode->i_mapping;
-        page = read_cache_page(mapping, 0, (filler_t *)mapping->a_ops->readpage,
+        page = read_mapping_page(mapping, 0, NULL);
-                                NULL);
        if (IS_ERR(page))
                goto sync_fail;
        wait_on_page_locked(page);
diff --git a/fs/namespace.c b/fs/namespace.c
index bf478addb852..c13072a5f1ee 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -86,6 +86,15 @@ struct vfsmount *alloc_vfsmnt(const char *name)
        return mnt;
 }
+int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb)
+{
+        mnt->mnt_sb = sb;
+        mnt->mnt_root = dget(sb->s_root);
+        return 0;
+}
+EXPORT_SYMBOL(simple_set_mnt);
 void free_vfsmnt(struct vfsmount *mnt)
 {
        kfree(mnt->mnt_devname);
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index a1f3e972c6ef..90d2ea28f333 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -39,7 +39,7 @@
 static void ncp_delete_inode(struct inode *);
 static void ncp_put_super(struct super_block *);
-static int  ncp_statfs(struct super_block *, struct kstatfs *);
+static int  ncp_statfs(struct dentry *, struct kstatfs *);
 static kmem_cache_t * ncp_inode_cachep;
@@ -724,13 +724,14 @@ static void ncp_put_super(struct super_block *sb)
        kfree(server);
 }
-static int ncp_statfs(struct super_block *sb, struct kstatfs *buf)
+static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct dentry* d;
        struct inode* i;
        struct ncp_inode_info* ni;
        struct ncp_server* s;
        struct ncp_volume_info vi;
+        struct super_block *sb = dentry->d_sb;
        int err;
        __u8 dh;
        
@@ -957,10 +958,10 @@ out:
        return result;
 }
-static struct super_block *ncp_get_sb(struct file_system_type *fs_type,
+static int ncp_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, ncp_fill_super);
+        return get_sb_nodev(fs_type, flags, data, ncp_fill_super, mnt);
 }
 static struct file_system_type ncp_fs_type = {
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index fade02c15e6e..fa05c027ea11 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -43,7 +43,7 @@ static int  nfs_file_mmap(struct file *, struct vm_area_struct *);
 static ssize_t nfs_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
 static ssize_t nfs_file_read(struct kiocb *, char __user *, size_t, loff_t);
 static ssize_t nfs_file_write(struct kiocb *, const char __user *, size_t, loff_t);
-static int  nfs_file_flush(struct file *);
+static int  nfs_file_flush(struct file *, fl_owner_t id);
 static int  nfs_fsync(struct file *, struct dentry *dentry, int datasync);
 static int nfs_check_flags(int flags);
 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
@@ -188,7 +188,7 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
 *
 */
 static int
-nfs_file_flush(struct file *file)
+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;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index d0b991a92327..937fbfc381bb 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -65,7 +65,7 @@ static int nfs_write_inode(struct inode *,int);
 static void nfs_delete_inode(struct inode *);
 static void nfs_clear_inode(struct inode *);
 static void nfs_umount_begin(struct super_block *);
-static int  nfs_statfs(struct super_block *, struct kstatfs *);
+static int  nfs_statfs(struct dentry *, struct kstatfs *);
 static int  nfs_show_options(struct seq_file *, struct vfsmount *);
 static int  nfs_show_stats(struct seq_file *, struct vfsmount *);
 static void nfs_zap_acl_cache(struct inode *);
@@ -534,8 +534,9 @@ nfs_fill_super(struct super_block *sb, struct nfs_mount_data *data, int silent)
 }
 static int
-nfs_statfs(struct super_block *sb, struct kstatfs *buf)
+nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct nfs_server *server = NFS_SB(sb);
        unsigned char blockbits;
        unsigned long blockres;
@@ -1690,8 +1691,8 @@ static int nfs_compare_super(struct super_block *sb, void *data)
        return !nfs_compare_fh(&old->fh, &server->fh);
 }
-static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
+static int nfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *raw_data)
+        int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
 {
        int error;
        struct nfs_server *server = NULL;
@@ -1699,14 +1700,14 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
        struct nfs_fh *root;
        struct nfs_mount_data *data = raw_data;
-        s = ERR_PTR(-EINVAL);
+        error = -EINVAL;
        if (data == NULL) {
                dprintk("%s: missing data argument\n", __FUNCTION__);
-                goto out_err;
+                goto out_err_noserver;
        }
        if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) {
                dprintk("%s: bad mount version\n", __FUNCTION__);
-                goto out_err;
+                goto out_err_noserver;
        }
        switch (data->version) {
                case 1:
@@ -1718,7 +1719,7 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
                                dprintk("%s: mount structure version %d does not support NFSv3\n",
                                                __FUNCTION__,
                                                data->version);
-                                goto out_err;
+                                goto out_err_noserver;
                        }
                        data->root.size = NFS2_FHSIZE;
                        memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
@@ -1727,24 +1728,24 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
                                dprintk("%s: mount structure version %d does not support strong security\n",
                                                __FUNCTION__,
                                                data->version);
-                                goto out_err;
+                                goto out_err_noserver;
                        }
                case 5:
                        memset(data->context, 0, sizeof(data->context));
        }
 #ifndef CONFIG_NFS_V3
        /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
-        s = ERR_PTR(-EPROTONOSUPPORT);
+        error = -EPROTONOSUPPORT;
        if (data->flags & NFS_MOUNT_VER3) {
                dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__);
-                goto out_err;
+                goto out_err_noserver;
        }
 #endif /* CONFIG_NFS_V3 */
-        s = ERR_PTR(-ENOMEM);
+        error = -ENOMEM;
        server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
        if (!server)
-                goto out_err;
+                goto out_err_noserver;
        /* Zero out the NFS state stuff */
        init_nfsv4_state(server);
        server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
@@ -1754,7 +1755,7 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
                root->size = data->root.size;
        else
                root->size = NFS2_FHSIZE;
-        s = ERR_PTR(-EINVAL);
+        error = -EINVAL;
        if (root->size > sizeof(root->data)) {
                dprintk("%s: invalid root filehandle\n", __FUNCTION__);
                goto out_err;
@@ -1770,15 +1771,20 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
        }
        /* Fire up rpciod if not yet running */
-        s = ERR_PTR(rpciod_up());
+        error = rpciod_up();
-        if (IS_ERR(s)) {
+        if (error < 0) {
-                dprintk("%s: couldn't start rpciod! Error = %ld\n",
+                dprintk("%s: couldn't start rpciod! Error = %d\n",
-                                __FUNCTION__, PTR_ERR(s));
+                                __FUNCTION__, error);
                goto out_err;
        }
        s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
-        if (IS_ERR(s) || s->s_root)
+        if (IS_ERR(s)) {
+                error = PTR_ERR(s);
+                goto out_err_rpciod;
+        }
+        if (s->s_root)
                goto out_rpciod_down;
        s->s_flags = flags;
@@ -1787,15 +1793,22 @@ static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
        if (error) {
                up_write(&s->s_umount);
                deactivate_super(s);
-                return ERR_PTR(error);
+                return error;
        }
        s->s_flags |= MS_ACTIVE;
-        return s;
+        return simple_set_mnt(mnt, s);
 out_rpciod_down:
        rpciod_down();
+        kfree(server);
+        return simple_set_mnt(mnt, s);
+out_err_rpciod:
+        rpciod_down();
 out_err:
        kfree(server);
-        return s;
+out_err_noserver:
+        return error;
 }
 static void nfs_kill_super(struct super_block *s)
@@ -2032,8 +2045,8 @@ nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen)
        return dst;
 }
-static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
+static int nfs4_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *raw_data)
+        int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
 {
        int error;
        struct nfs_server *server;
@@ -2043,16 +2056,16 @@ static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
        if (data == NULL) {
                dprintk("%s: missing data argument\n", __FUNCTION__);
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
        }
        if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
                dprintk("%s: bad mount version\n", __FUNCTION__);
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
        }
        server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
        if (!server)
-                return ERR_PTR(-ENOMEM);
+                return -ENOMEM;
        /* Zero out the NFS state stuff */
        init_nfsv4_state(server);
        server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
@@ -2074,33 +2087,41 @@ static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
        /* We now require that the mount process passes the remote address */
        if (data->host_addrlen != sizeof(server->addr)) {
-                s = ERR_PTR(-EINVAL);
+                error = -EINVAL;
                goto out_free;
        }
        if (copy_from_user(&server->addr, data->host_addr, sizeof(server->addr))) {
-                s = ERR_PTR(-EFAULT);
+                error = -EFAULT;
                goto out_free;
        }
        if (server->addr.sin_family != AF_INET ||
            server->addr.sin_addr.s_addr == INADDR_ANY) {
                dprintk("%s: mount program didn't pass remote IP address!\n",
                                __FUNCTION__);
-                s = ERR_PTR(-EINVAL);
+                error = -EINVAL;
                goto out_free;
        }
        /* Fire up rpciod if not yet running */
-        s = ERR_PTR(rpciod_up());
+        error = rpciod_up();
-        if (IS_ERR(s)) {
+        if (error < 0) {
-                dprintk("%s: couldn't start rpciod! Error = %ld\n",
+                dprintk("%s: couldn't start rpciod! Error = %d\n",
-                                __FUNCTION__, PTR_ERR(s));
+                                __FUNCTION__, error);
                goto out_free;
        }
        s = sget(fs_type, nfs4_compare_super, nfs_set_super, server);
+        if (IS_ERR(s)) {
-        if (IS_ERR(s) || s->s_root)
+                error = PTR_ERR(s);
                goto out_free;
+        }
+        if (s->s_root) {
+                kfree(server->mnt_path);
+                kfree(server->hostname);
+                kfree(server);
+                return simple_set_mnt(mnt, s);
+        }
        s->s_flags = flags;
@@ -2108,17 +2129,17 @@ static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
        if (error) {
                up_write(&s->s_umount);
                deactivate_super(s);
-                return ERR_PTR(error);
+                return error;
        }
        s->s_flags |= MS_ACTIVE;
-        return s;
+        return simple_set_mnt(mnt, s);
 out_err:
-        s = (struct super_block *)p;
+        error = PTR_ERR(p);
 out_free:
        kfree(server->mnt_path);
        kfree(server->hostname);
        kfree(server);
-        return s;
+        return error;
 }
 static void nfs4_kill_super(struct super_block *sb)
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index de3998f15f10..5446a0861d1d 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -1310,7 +1310,7 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
        if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL)) ||
            (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
                       FATTR4_WORD1_SPACE_TOTAL))) {
-                status = vfs_statfs(dentry->d_inode->i_sb, &statfs);
+                status = vfs_statfs(dentry, &statfs);
                if (status)
                        goto out_nfserr;
        }
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 3ef017b3b5bd..a1810e6a93e5 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -494,10 +494,10 @@ static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
        return simple_fill_super(sb, 0x6e667364, nfsd_files);
 }
-static struct super_block *nfsd_get_sb(struct file_system_type *fs_type,
+static int nfsd_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, nfsd_fill_super);
+        return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
 }
 static struct file_system_type nfsd_fs_type = {
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 1d65f13f458c..245eaa1fb59b 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -1737,7 +1737,7 @@ int
 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat)
 {
        int err = fh_verify(rqstp, fhp, 0, MAY_NOP);
-        if (!err && vfs_statfs(fhp->fh_dentry->d_inode->i_sb,stat))
+        if (!err && vfs_statfs(fhp->fh_dentry,stat))
                err = nfserr_io;
        return err;
 }
diff --git a/fs/ntfs/aops.h b/fs/ntfs/aops.h
index 3b74e66ca2ff..325ce261a107 100644
--- a/fs/ntfs/aops.h
+++ b/fs/ntfs/aops.h
@@ -86,8 +86,7 @@ static inline void ntfs_unmap_page(struct page *page)
 static inline struct page *ntfs_map_page(struct address_space *mapping,
                unsigned long index)
 {
-        struct page *page = read_cache_page(mapping, index,
+        struct page *page = read_mapping_page(mapping, index, NULL);
-                        (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 1663f5c3c6aa..6708e1d68a9e 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -2529,8 +2529,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
        end >>= PAGE_CACHE_SHIFT;
        /* If there is a first partial page, need to do it the slow way. */
        if (start_ofs) {
-                page = read_cache_page(mapping, idx,
+                page = read_mapping_page(mapping, idx, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
                if (IS_ERR(page)) {
                        ntfs_error(vol->sb, "Failed to read first partial "
                                        "page (sync error, index 0x%lx).", idx);
@@ -2600,8 +2599,7 @@ int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
        }
        /* If there is a last partial page, need to do it the slow way. */
        if (end_ofs) {
-                page = read_cache_page(mapping, idx,
+                page = read_mapping_page(mapping, idx, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
                if (IS_ERR(page)) {
                        ntfs_error(vol->sb, "Failed to read last partial page "
                                        "(sync error, index 0x%lx).", idx);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 36e1e136bb0c..88292f9e4b9b 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -231,8 +231,7 @@ do_non_resident_extend:
                 * Read the page.  If the page is not present, this will zero
                 * the uninitialized regions for us.
                 */
-                page = read_cache_page(mapping, index,
+                page = read_mapping_page(mapping, index, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
                if (IS_ERR(page)) {
                        err = PTR_ERR(page);
                        goto init_err_out;
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 27833f6df49f..0e14acea3f8b 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2601,10 +2601,10 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
 /**
 * ntfs_statfs - return information about mounted NTFS volume
- * @sb:         super block of mounted volume
+ * @dentry:     dentry from mounted volume
 * @sfs:        statfs structure in which to return the information
 *
- * Return information about the mounted NTFS volume @sb in the statfs structure
+ * Return information about the mounted NTFS volume @dentry in the statfs structure
 * pointed to by @sfs (this is initialized with zeros before ntfs_statfs is
 * called). We interpret the values to be correct of the moment in time at
 * which we are called. Most values are variable otherwise and this isn't just
@@ -2617,8 +2617,9 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
 *
 * Return 0 on success or -errno on error.
 */
-static int ntfs_statfs(struct super_block *sb, struct kstatfs *sfs)
+static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
 {
+        struct super_block *sb = dentry->d_sb;
        s64 size;
        ntfs_volume *vol = NTFS_SB(sb);
        ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
@@ -3093,10 +3094,11 @@ struct kmem_cache *ntfs_index_ctx_cache;
 /* Driver wide mutex. */
 DEFINE_MUTEX(ntfs_lock);
-static struct super_block *ntfs_get_sb(struct file_system_type *fs_type,
+static int ntfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ntfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ntfs_fill_super,
+                           mnt);
 }
 static struct file_system_type ntfs_fs_type = {
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 7e88e24b3471..7273d9fa6bab 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -574,10 +574,10 @@ static struct inode_operations dlmfs_file_inode_operations = {
        .getattr        = simple_getattr,
 };
-static struct super_block *dlmfs_get_sb(struct file_system_type *fs_type,
+static int dlmfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, dlmfs_fill_super);
+        return get_sb_nodev(fs_type, flags, data, dlmfs_fill_super, mnt);
 }
 static struct file_system_type dlmfs_fs_type = {
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 949b3dac30f1..cdf73393f094 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -100,7 +100,7 @@ static int ocfs2_initialize_mem_caches(void);
 static void ocfs2_free_mem_caches(void);
 static void ocfs2_delete_osb(struct ocfs2_super *osb);
-static int ocfs2_statfs(struct super_block *sb, struct kstatfs *buf);
+static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int ocfs2_sync_fs(struct super_block *sb, int wait);
@@ -672,12 +672,14 @@ read_super_error:
        return status;
 }
-static struct super_block *ocfs2_get_sb(struct file_system_type *fs_type,
+static int ocfs2_get_sb(struct file_system_type *fs_type,
-                                        int flags,
+                        int flags,
-                                        const char *dev_name,
+                        const char *dev_name,
-                                        void *data)
+                        void *data,
+                        struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super,
+                           mnt);
 }
 static struct file_system_type ocfs2_fs_type = {
@@ -855,7 +857,7 @@ static void ocfs2_put_super(struct super_block *sb)
        mlog_exit_void();
 }
-static int ocfs2_statfs(struct super_block *sb, struct kstatfs *buf)
+static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        struct ocfs2_super *osb;
        u32 numbits, freebits;
@@ -864,9 +866,9 @@ static int ocfs2_statfs(struct super_block *sb, struct kstatfs *buf)
        struct buffer_head *bh = NULL;
        struct inode *inode = NULL;
-        mlog_entry("(%p, %p)\n", sb, buf);
+        mlog_entry("(%p, %p)\n", dentry->d_sb, buf);
-        osb = OCFS2_SB(sb);
+        osb = OCFS2_SB(dentry->d_sb);
        inode = ocfs2_get_system_file_inode(osb,
                                            GLOBAL_BITMAP_SYSTEM_INODE,
@@ -889,7 +891,7 @@ static int ocfs2_statfs(struct super_block *sb, struct kstatfs *buf)
        freebits = numbits - le32_to_cpu(bm_lock->id1.bitmap1.i_used);
        buf->f_type = OCFS2_SUPER_MAGIC;
-        buf->f_bsize = sb->s_blocksize;
+        buf->f_bsize = dentry->d_sb->s_blocksize;
        buf->f_namelen = OCFS2_MAX_FILENAME_LEN;
        buf->f_blocks = ((sector_t) numbits) *
                        (osb->s_clustersize >> osb->sb->s_blocksize_bits);
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c
index f6986bd79e75..0c8a1294ec96 100644
--- a/fs/ocfs2/symlink.c
+++ b/fs/ocfs2/symlink.c
@@ -64,8 +64,7 @@ static char *ocfs2_page_getlink(struct dentry * dentry,
 {
        struct page * page;
        struct address_space *mapping = dentry->d_inode->i_mapping;
-        page = read_cache_page(mapping, 0,
+        page = read_mapping_page(mapping, 0, NULL);
-                               (filler_t *)mapping->a_ops->readpage, NULL);
        if (IS_ERR(page))
                goto sync_fail;
        wait_on_page_locked(page);
diff --git a/fs/open.c b/fs/open.c
index 4f178acd4c09..5fb16e5267dc 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -31,18 +31,18 @@
 #include <asm/unistd.h>
-int vfs_statfs(struct super_block *sb, struct kstatfs *buf)
+int vfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        int retval = -ENODEV;
-        if (sb) {
+        if (dentry) {
                retval = -ENOSYS;
-                if (sb->s_op->statfs) {
+                if (dentry->d_sb->s_op->statfs) {
                        memset(buf, 0, sizeof(*buf));
-                        retval = security_sb_statfs(sb);
+                        retval = security_sb_statfs(dentry);
                        if (retval)
                                return retval;
-                        retval = sb->s_op->statfs(sb, buf);
+                        retval = dentry->d_sb->s_op->statfs(dentry, buf);
                        if (retval == 0 && buf->f_frsize == 0)
                                buf->f_frsize = buf->f_bsize;
                }
@@ -52,12 +52,12 @@ int vfs_statfs(struct super_block *sb, struct kstatfs *buf)
 EXPORT_SYMBOL(vfs_statfs);
-static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
+static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf)
 {
        struct kstatfs st;
        int retval;
-        retval = vfs_statfs(sb, &st);
+        retval = vfs_statfs(dentry, &st);
        if (retval)
                return retval;
@@ -95,12 +95,12 @@ static int vfs_statfs_native(struct super_block *sb, struct statfs *buf)
        return 0;
 }
-static int vfs_statfs64(struct super_block *sb, struct statfs64 *buf)
+static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf)
 {
        struct kstatfs st;
        int retval;
-        retval = vfs_statfs(sb, &st);
+        retval = vfs_statfs(dentry, &st);
        if (retval)
                return retval;
@@ -130,7 +130,7 @@ asmlinkage long sys_statfs(const char __user * path, struct statfs __user * buf)
        error = user_path_walk(path, &nd);
        if (!error) {
                struct statfs tmp;
-                error = vfs_statfs_native(nd.dentry->d_inode->i_sb, &tmp);
+                error = vfs_statfs_native(nd.dentry, &tmp);
                if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                        error = -EFAULT;
                path_release(&nd);
@@ -149,7 +149,7 @@ asmlinkage long sys_statfs64(const char __user *path, size_t sz, struct statfs64
        error = user_path_walk(path, &nd);
        if (!error) {
                struct statfs64 tmp;
-                error = vfs_statfs64(nd.dentry->d_inode->i_sb, &tmp);
+                error = vfs_statfs64(nd.dentry, &tmp);
                if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                        error = -EFAULT;
                path_release(&nd);
@@ -168,7 +168,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->d_inode->i_sb, &tmp);
+        error = vfs_statfs_native(file->f_dentry, &tmp);
        if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                error = -EFAULT;
        fput(file);
@@ -189,7 +189,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->d_inode->i_sb, &tmp);
+        error = vfs_statfs64(file->f_dentry, &tmp);
        if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
                error = -EFAULT;
        fput(file);
@@ -1152,7 +1152,7 @@ int filp_close(struct file *filp, fl_owner_t id)
        }
        if (filp->f_op && filp->f_op->flush)
-                retval = filp->f_op->flush(filp);
+                retval = filp->f_op->flush(filp, id);
        dnotify_flush(filp, id);
        locks_remove_posix(filp, id);
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 0f14276a2e51..464e2bce0203 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -1054,10 +1054,10 @@ out_no_root:
        return -ENOMEM;
 }
-static struct super_block *openprom_get_sb(struct file_system_type *fs_type,
+static int openprom_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, openprom_fill_super);
+        return get_sb_single(fs_type, flags, data, openprom_fill_super, mnt);
 }
 static struct file_system_type openprom_fs_type = {
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 8851b81e7c5a..2ef313a96b66 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -484,6 +484,10 @@ int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
                sector_t from = state->parts[p].from;
                if (!size)
                        continue;
+                if (from + size > get_capacity(disk)) {
+                        printk(" %s: p%d exceeds device capacity\n",
+                                disk->disk_name, p);
+                }
                add_partition(disk, p, from, size);
 #ifdef CONFIG_BLK_DEV_MD
                if (state->parts[p].flags)
@@ -499,8 +503,8 @@ unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
        struct address_space *mapping = bdev->bd_inode->i_mapping;
        struct page *page;
-        page = read_cache_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
+        page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
-                        (filler_t *)mapping->a_ops->readpage, NULL);
+                                 NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                if (!PageUptodate(page))
diff --git a/fs/pipe.c b/fs/pipe.c
index 5acd8954aaa0..20352573e025 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -979,12 +979,11 @@ no_files:
 * any operations on the root directory. However, we need a non-trivial
 * d_name - pipe: will go nicely and kill the special-casing in procfs.
 */
+static int pipefs_get_sb(struct file_system_type *fs_type,
-static struct super_block *
+                         int flags, const char *dev_name, void *data,
-pipefs_get_sb(struct file_system_type *fs_type, int flags,
+                         struct vfsmount *mnt)
-              const char *dev_name, void *data)
 {
-        return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
+        return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC, mnt);
 }
 static struct file_system_type pipe_fs_type = {
diff --git a/fs/proc/root.c b/fs/proc/root.c
index c3fd3611112f..9995356ce73e 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -26,10 +26,10 @@ struct proc_dir_entry *proc_net, *proc_net_stat, *proc_bus, *proc_root_fs, *proc
 struct proc_dir_entry *proc_sys_root;
 #endif
-static struct super_block *proc_get_sb(struct file_system_type *fs_type,
+static int proc_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, proc_fill_super);
+        return get_sb_single(fs_type, flags, data, proc_fill_super, mnt);
 }
 static struct file_system_type proc_fs_type = {
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 2ecd46f85e9f..2f24c46f72a1 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -128,7 +128,7 @@ static struct inode *qnx4_alloc_inode(struct super_block *sb);
 static void qnx4_destroy_inode(struct inode *inode);
 static void qnx4_read_inode(struct inode *);
 static int qnx4_remount(struct super_block *sb, int *flags, char *data);
-static int qnx4_statfs(struct super_block *, struct kstatfs *);
+static int qnx4_statfs(struct dentry *, struct kstatfs *);
 static struct super_operations qnx4_sops =
 {
@@ -282,8 +282,10 @@ unsigned long qnx4_block_map( struct inode *inode, long iblock )
        return block;
 }
-static int qnx4_statfs(struct super_block *sb, struct kstatfs *buf)
+static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        lock_kernel();
        buf->f_type    = sb->s_magic;
@@ -561,10 +563,11 @@ static void destroy_inodecache(void)
                       "qnx4_inode_cache: not all structures were freed\n");
 }
-static struct super_block *qnx4_get_sb(struct file_system_type *fs_type,
+static int qnx4_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, qnx4_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, qnx4_fill_super,
+                           mnt);
 }
 static struct file_system_type qnx4_fs_type = {
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index 14bd2246fb6d..b9677335cc8d 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -185,16 +185,17 @@ static int ramfs_fill_super(struct super_block * sb, void * data, int silent)
        return 0;
 }
-struct super_block *ramfs_get_sb(struct file_system_type *fs_type,
+int ramfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, ramfs_fill_super);
+        return get_sb_nodev(fs_type, flags, data, ramfs_fill_super, mnt);
 }
-static struct super_block *rootfs_get_sb(struct file_system_type *fs_type,
+static int rootfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super);
+        return get_sb_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super,
+                            mnt);
 }
 static struct file_system_type ramfs_fs_type = {
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index cae2abbc0c71..00f1321e9209 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -60,7 +60,7 @@ static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
 }
 static int reiserfs_remount(struct super_block *s, int *flags, char *data);
-static int reiserfs_statfs(struct super_block *s, struct kstatfs *buf);
+static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int reiserfs_sync_fs(struct super_block *s, int wait)
 {
@@ -1938,15 +1938,15 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        return errval;
 }
-static int reiserfs_statfs(struct super_block *s, struct kstatfs *buf)
+static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
+        struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
        buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
        buf->f_bfree = sb_free_blocks(rs);
        buf->f_bavail = buf->f_bfree;
        buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
-        buf->f_bsize = s->s_blocksize;
+        buf->f_bsize = dentry->d_sb->s_blocksize;
        /* changed to accommodate gcc folks. */
        buf->f_type = REISERFS_SUPER_MAGIC;
        return 0;
@@ -2249,11 +2249,12 @@ static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
 #endif
-static struct super_block *get_super_block(struct file_system_type *fs_type,
+static int get_super_block(struct file_system_type *fs_type,
-                                           int flags, const char *dev_name,
+                           int flags, const char *dev_name,
-                                           void *data)
+                           void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
+                           mnt);
 }
 static int __init init_reiserfs_fs(void)
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index ffb79c48c5bf..39fedaa88a0c 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -452,8 +452,7 @@ static struct page *reiserfs_get_page(struct inode *dir, unsigned long n)
        /* We can deadlock if we try to free dentries,
           and an unlink/rmdir has just occured - GFP_NOFS avoids this */
        mapping_set_gfp_mask(mapping, GFP_NOFS);
-        page = read_cache_page(mapping, n,
+        page = read_mapping_page(mapping, n, NULL);
-                               (filler_t *) mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                kmap(page);
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index 9b9eda7b335c..283fbc6b8eea 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -179,12 +179,12 @@ outnobh:
 /* That's simple too. */
 static int
-romfs_statfs(struct super_block *sb, struct kstatfs *buf)
+romfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        buf->f_type = ROMFS_MAGIC;
        buf->f_bsize = ROMBSIZE;
        buf->f_bfree = buf->f_bavail = buf->f_ffree;
-        buf->f_blocks = (romfs_maxsize(sb)+ROMBSIZE-1)>>ROMBSBITS;
+        buf->f_blocks = (romfs_maxsize(dentry->d_sb)+ROMBSIZE-1)>>ROMBSBITS;
        buf->f_namelen = ROMFS_MAXFN;
        return 0;
 }
@@ -607,10 +607,11 @@ static struct super_operations romfs_ops = {
        .remount_fs     = romfs_remount,
 };
-static struct super_block *romfs_get_sb(struct file_system_type *fs_type,
+static int romfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, romfs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, romfs_fill_super,
+                           mnt);
 }
 static struct file_system_type romfs_fs_type = {
diff --git a/fs/select.c b/fs/select.c
index a8109baa5e46..9c4f0f2604f1 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -546,37 +546,38 @@ struct poll_list {
 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
-static void do_pollfd(unsigned int num, struct pollfd * fdpage,
+/*
-        poll_table ** pwait, int *count)
+ * Fish for pollable events on the pollfd->fd file descriptor. We're only
+ * interested in events matching the pollfd->events mask, and the result
+ * matching that mask is both recorded in pollfd->revents and returned. The
+ * pwait poll_table will be used by the fd-provided poll handler for waiting,
+ * if non-NULL.
+ */
+static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
 {
-        int i;
+        unsigned int mask;
+        int fd;
-        for (i = 0; i < num; i++) {
-                int fd;
+        mask = 0;
-                unsigned int mask;
+        fd = pollfd->fd;
-                struct pollfd *fdp;
+        if (fd >= 0) {
+                int fput_needed;
-                mask = 0;
+                struct file * file;
-                fdp = fdpage+i;
-                fd = fdp->fd;
+                file = fget_light(fd, &fput_needed);
-                if (fd >= 0) {
+                mask = POLLNVAL;
-                        int fput_needed;
+                if (file != NULL) {
-                        struct file * file = fget_light(fd, &fput_needed);
+                        mask = DEFAULT_POLLMASK;
-                        mask = POLLNVAL;
+                        if (file->f_op && file->f_op->poll)
-                        if (file != NULL) {
+                                mask = file->f_op->poll(file, pwait);
-                                mask = DEFAULT_POLLMASK;
+                        /* Mask out unneeded events. */
-                                if (file->f_op && file->f_op->poll)
+                        mask &= pollfd->events | POLLERR | POLLHUP;
-                                        mask = file->f_op->poll(file, *pwait);
+                        fput_light(file, fput_needed);
-                                mask &= fdp->events | POLLERR | POLLHUP;
-                                fput_light(file, fput_needed);
-                        }
-                        if (mask) {
-                                *pwait = NULL;
-                                (*count)++;
-                        }
                }
-                fdp->revents = mask;
        }
+        pollfd->revents = mask;
+        return mask;
 }
 static int do_poll(unsigned int nfds,  struct poll_list *list,
@@ -594,11 +595,29 @@ static int do_poll(unsigned int nfds,  struct poll_list *list,
                long __timeout;
                set_current_state(TASK_INTERRUPTIBLE);
-                walk = list;
+                for (walk = list; walk != NULL; walk = walk->next) {
-                while(walk != NULL) {
+                        struct pollfd * pfd, * pfd_end;
-                        do_pollfd( walk->len, walk->entries, &pt, &count);
-                        walk = walk->next;
+                        pfd = walk->entries;
+                        pfd_end = pfd + walk->len;
+                        for (; pfd != pfd_end; pfd++) {
+                                /*
+                                 * Fish for events. If we found one, record it
+                                 * and kill the poll_table, so we don't
+                                 * needlessly register any other waiters after
+                                 * this. They'll get immediately deregistered
+                                 * when we break out and return.
+                                 */
+                                if (do_pollfd(pfd, pt)) {
+                                        count++;
+                                        pt = NULL;
+                                }
+                        }
                }
+                /*
+                 * All waiters have already been registered, so don't provide
+                 * a poll_table to them on the next loop iteration.
+                 */
                pt = NULL;
                if (count || !*timeout || signal_pending(current))
                        break;
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index fdeabc0a34f7..506ff87c1d4b 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -48,7 +48,7 @@
 static void smb_delete_inode(struct inode *);
 static void smb_put_super(struct super_block *);
-static int  smb_statfs(struct super_block *, struct kstatfs *);
+static int  smb_statfs(struct dentry *, struct kstatfs *);
 static int  smb_show_options(struct seq_file *, struct vfsmount *);
 static kmem_cache_t *smb_inode_cachep;
@@ -641,13 +641,13 @@ out_no_server:
 }
 static int
-smb_statfs(struct super_block *sb, struct kstatfs *buf)
+smb_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
        int result;
        
        lock_kernel();
-        result = smb_proc_dskattr(sb, buf);
+        result = smb_proc_dskattr(dentry, buf);
        unlock_kernel();
@@ -782,10 +782,10 @@ out:
        return error;
 }
-static struct super_block *smb_get_sb(struct file_system_type *fs_type,
+static int smb_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_nodev(fs_type, flags, data, smb_fill_super);
+        return get_sb_nodev(fs_type, flags, data, smb_fill_super, mnt);
 }
 static struct file_system_type smb_fs_type = {
diff --git a/fs/smbfs/proc.c b/fs/smbfs/proc.c
index b1b878b81730..c3495059889d 100644
--- a/fs/smbfs/proc.c
+++ b/fs/smbfs/proc.c
@@ -3226,9 +3226,9 @@ smb_proc_settime(struct dentry *dentry, struct smb_fattr *fattr)
 }
 int
-smb_proc_dskattr(struct super_block *sb, struct kstatfs *attr)
+smb_proc_dskattr(struct dentry *dentry, struct kstatfs *attr)
 {
-        struct smb_sb_info *server = SMB_SB(sb);
+        struct smb_sb_info *server = SMB_SB(dentry->d_sb);
        int result;
        char *p;
        long unit;
diff --git a/fs/smbfs/proto.h b/fs/smbfs/proto.h
index 47664597e6b1..972ed7dad388 100644
--- a/fs/smbfs/proto.h
+++ b/fs/smbfs/proto.h
@@ -29,7 +29,7 @@ extern int smb_proc_getattr(struct dentry *dir, struct smb_fattr *fattr);
 extern int smb_proc_setattr(struct dentry *dir, struct smb_fattr *fattr);
 extern int smb_proc_setattr_unix(struct dentry *d, struct iattr *attr, unsigned int major, unsigned int minor);
 extern int smb_proc_settime(struct dentry *dentry, struct smb_fattr *fattr);
-extern int smb_proc_dskattr(struct super_block *sb, struct kstatfs *attr);
+extern int smb_proc_dskattr(struct dentry *dentry, struct kstatfs *attr);
 extern int smb_proc_read_link(struct smb_sb_info *server, struct dentry *d, char *buffer, int len);
 extern int smb_proc_symlink(struct smb_sb_info *server, struct dentry *d, const char *oldpath);
 extern int smb_proc_link(struct smb_sb_info *server, struct dentry *dentry, struct dentry *new_dentry);
diff --git a/fs/splice.c b/fs/splice.c
index a285fd746dc0..05fd2787be98 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -55,31 +55,43 @@ static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe,
                                     struct pipe_buffer *buf)
 {
        struct page *page = buf->page;
-        struct address_space *mapping = page_mapping(page);
+        struct address_space *mapping;
        lock_page(page);
-        WARN_ON(!PageUptodate(page));
+        mapping = page_mapping(page);
+        if (mapping) {
+                WARN_ON(!PageUptodate(page));
-        /*
+                /*
-         * At least for ext2 with nobh option, we need to wait on writeback
+                 * At least for ext2 with nobh option, we need to wait on
-         * completing on this page, since we'll remove it from the pagecache.
+                 * writeback completing on this page, since we'll remove it
-         * Otherwise truncate wont wait on the page, allowing the disk
+                 * from the pagecache.  Otherwise truncate wont wait on the
-         * blocks to be reused by someone else before we actually wrote our
+                 * page, allowing the disk blocks to be reused by someone else
-         * data to them. fs corruption ensues.
+                 * before we actually wrote our data to them. fs corruption
-         */
+                 * ensues.
-        wait_on_page_writeback(page);
+                 */
+                wait_on_page_writeback(page);
-        if (PagePrivate(page))
+                if (PagePrivate(page))
-                try_to_release_page(page, mapping_gfp_mask(mapping));
+                        try_to_release_page(page, mapping_gfp_mask(mapping));
-        if (!remove_mapping(mapping, page)) {
+                /*
-                unlock_page(page);
+                 * If we succeeded in removing the mapping, set LRU flag
-                return 1;
+                 * and return good.
+                 */
+                if (remove_mapping(mapping, page)) {
+                        buf->flags |= PIPE_BUF_FLAG_LRU;
+                        return 0;
+                }
        }
-        buf->flags |= PIPE_BUF_FLAG_LRU;
+        /*
-        return 0;
+         * Raced with truncate or failed to remove page from current
+         * address space, unlock and return failure.
+         */
+        unlock_page(page);
+        return 1;
 }
 static void page_cache_pipe_buf_release(struct pipe_inode_info *pipe,
diff --git a/fs/super.c b/fs/super.c
index 9d5c2add7228..057b5325b7ef 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -231,7 +231,7 @@ void generic_shutdown_super(struct super_block *sb)
        if (root) {
                sb->s_root = NULL;
                shrink_dcache_parent(root);
-                shrink_dcache_anon(sb);
+                shrink_dcache_sb(sb);
                dput(root);
                fsync_super(sb);
                lock_super(sb);
@@ -486,7 +486,7 @@ asmlinkage long sys_ustat(unsigned dev, struct ustat __user * ubuf)
        s = user_get_super(new_decode_dev(dev));
        if (s == NULL)
                goto out;
-        err = vfs_statfs(s, &sbuf);
+        err = vfs_statfs(s->s_root, &sbuf);
        drop_super(s);
        if (err)
                goto out;
@@ -676,9 +676,10 @@ static void bdev_uevent(struct block_device *bdev, enum kobject_action action)
        }
 }
-struct super_block *get_sb_bdev(struct file_system_type *fs_type,
+int get_sb_bdev(struct file_system_type *fs_type,
        int flags, const char *dev_name, void *data,
-        int (*fill_super)(struct super_block *, void *, int))
+        int (*fill_super)(struct super_block *, void *, int),
+        struct vfsmount *mnt)
 {
        struct block_device *bdev;
        struct super_block *s;
@@ -686,7 +687,7 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type,
        bdev = open_bdev_excl(dev_name, flags, fs_type);
        if (IS_ERR(bdev))
-                return (struct super_block *)bdev;
+                return PTR_ERR(bdev);
        /*
         * once the super is inserted into the list by sget, s_umount
@@ -697,15 +698,17 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type,
        s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
        mutex_unlock(&bdev->bd_mount_mutex);
        if (IS_ERR(s))
-                goto out;
+                goto error_s;
        if (s->s_root) {
                if ((flags ^ s->s_flags) & MS_RDONLY) {
                        up_write(&s->s_umount);
                        deactivate_super(s);
-                        s = ERR_PTR(-EBUSY);
+                        error = -EBUSY;
+                        goto error_bdev;
                }
-                goto out;
+                close_bdev_excl(bdev);
        } else {
                char b[BDEVNAME_SIZE];
@@ -716,18 +719,21 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type,
                if (error) {
                        up_write(&s->s_umount);
                        deactivate_super(s);
-                        s = ERR_PTR(error);
+                        goto error;
-                } else {
-                        s->s_flags |= MS_ACTIVE;
-                        bdev_uevent(bdev, KOBJ_MOUNT);
                }
+                s->s_flags |= MS_ACTIVE;
+                bdev_uevent(bdev, KOBJ_MOUNT);
        }
-        return s;
+        return simple_set_mnt(mnt, s);
-out:
+error_s:
+        error = PTR_ERR(s);
+error_bdev:
        close_bdev_excl(bdev);
-        return s;
+error:
+        return error;
 }
 EXPORT_SYMBOL(get_sb_bdev);
@@ -744,15 +750,16 @@ void kill_block_super(struct super_block *sb)
 EXPORT_SYMBOL(kill_block_super);
-struct super_block *get_sb_nodev(struct file_system_type *fs_type,
+int get_sb_nodev(struct file_system_type *fs_type,
        int flags, void *data,
-        int (*fill_super)(struct super_block *, void *, int))
+        int (*fill_super)(struct super_block *, void *, int),
+        struct vfsmount *mnt)
 {
        int error;
        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
        if (IS_ERR(s))
-                return s;
+                return PTR_ERR(s);
        s->s_flags = flags;
@@ -760,10 +767,10 @@ struct super_block *get_sb_nodev(struct file_system_type *fs_type,
        if (error) {
                up_write(&s->s_umount);
                deactivate_super(s);
-                return ERR_PTR(error);
+                return error;
        }
        s->s_flags |= MS_ACTIVE;
-        return s;
+        return simple_set_mnt(mnt, s);
 }
 EXPORT_SYMBOL(get_sb_nodev);
@@ -773,94 +780,102 @@ static int compare_single(struct super_block *s, void *p)
        return 1;
 }
-struct super_block *get_sb_single(struct file_system_type *fs_type,
+int get_sb_single(struct file_system_type *fs_type,
        int flags, void *data,
-        int (*fill_super)(struct super_block *, void *, int))
+        int (*fill_super)(struct super_block *, void *, int),
+        struct vfsmount *mnt)
 {
        struct super_block *s;
        int error;
        s = sget(fs_type, compare_single, set_anon_super, NULL);
        if (IS_ERR(s))
-                return s;
+                return PTR_ERR(s);
        if (!s->s_root) {
                s->s_flags = flags;
                error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
                if (error) {
                        up_write(&s->s_umount);
                        deactivate_super(s);
-                        return ERR_PTR(error);
+                        return error;
                }
                s->s_flags |= MS_ACTIVE;
        }
        do_remount_sb(s, flags, data, 0);
-        return s;
+        return simple_set_mnt(mnt, s);
 }
 EXPORT_SYMBOL(get_sb_single);
 struct vfsmount *
-do_kern_mount(const char *fstype, int flags, const char *name, void *data)
+vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
 {
-        struct file_system_type *type = get_fs_type(fstype);
-        struct super_block *sb = ERR_PTR(-ENOMEM);
        struct vfsmount *mnt;
-        int error;
        char *secdata = NULL;
+        int error;
        if (!type)
                return ERR_PTR(-ENODEV);
+        error = -ENOMEM;
        mnt = alloc_vfsmnt(name);
        if (!mnt)
                goto out;
        if (data) {
                secdata = alloc_secdata();
-                if (!secdata) {
+                if (!secdata)
-                        sb = ERR_PTR(-ENOMEM);
                        goto out_mnt;
-                }
                error = security_sb_copy_data(type, data, secdata);
-                if (error) {
+                if (error)
-                        sb = ERR_PTR(error);
                        goto out_free_secdata;
-                }
        }
-        sb = type->get_sb(type, flags, name, data);
+        error = type->get_sb(type, flags, name, data, mnt);
-        if (IS_ERR(sb))
+        if (error < 0)
                goto out_free_secdata;
-        error = security_sb_kern_mount(sb, secdata);
+        error = security_sb_kern_mount(mnt->mnt_sb, secdata);
        if (error)
                goto out_sb;
-        mnt->mnt_sb = sb;
-        mnt->mnt_root = dget(sb->s_root);
+        mnt->mnt_mountpoint = mnt->mnt_root;
-        mnt->mnt_mountpoint = sb->s_root;
        mnt->mnt_parent = mnt;
-        up_write(&sb->s_umount);
+        up_write(&mnt->mnt_sb->s_umount);
        free_secdata(secdata);
-        put_filesystem(type);
        return mnt;
 out_sb:
-        up_write(&sb->s_umount);
+        dput(mnt->mnt_root);
-        deactivate_super(sb);
+        up_write(&mnt->mnt_sb->s_umount);
-        sb = ERR_PTR(error);
+        deactivate_super(mnt->mnt_sb);
 out_free_secdata:
        free_secdata(secdata);
 out_mnt:
        free_vfsmnt(mnt);
 out:
+        return ERR_PTR(error);
+}
+EXPORT_SYMBOL_GPL(vfs_kern_mount);
+struct vfsmount *
+do_kern_mount(const char *fstype, int flags, const char *name, void *data)
+{
+        struct file_system_type *type = get_fs_type(fstype);
+        struct vfsmount *mnt;
+        if (!type)
+                return ERR_PTR(-ENODEV);
+        mnt = vfs_kern_mount(type, flags, name, data);
        put_filesystem(type);
-        return (struct vfsmount *)sb;
+        return mnt;
 }
 EXPORT_SYMBOL_GPL(do_kern_mount);
 struct vfsmount *kern_mount(struct file_system_type *type)
 {
-        return do_kern_mount(type->name, 0, type->name, NULL);
+        return vfs_kern_mount(type, 0, type->name, NULL);
 }
 EXPORT_SYMBOL(kern_mount);
diff --git a/fs/sync.c b/fs/sync.c
index aab5ffe77e9f..955aef04da28 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -100,7 +100,7 @@ asmlinkage long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
        }
        if (nbytes == 0)
-                endbyte = -1;
+                endbyte = LLONG_MAX;
        else
                endbyte--;              /* inclusive */
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index f1117e885bd6..40190c489271 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -66,10 +66,10 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
        return 0;
 }
-static struct super_block *sysfs_get_sb(struct file_system_type *fs_type,
+static int sysfs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_single(fs_type, flags, data, sysfs_fill_super);
+        return get_sb_single(fs_type, flags, data, sysfs_fill_super, mnt);
 }
 static struct file_system_type sysfs_fs_type = {
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index d7074341ee87..f2bef962d309 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -53,8 +53,7 @@ static int dir_commit_chunk(struct page *page, unsigned from, unsigned to)
 static struct page * dir_get_page(struct inode *dir, unsigned long n)
 {
        struct address_space *mapping = dir->i_mapping;
-        struct page *page = read_cache_page(mapping, n,
+        struct page *page = read_mapping_page(mapping, n, NULL);
-                                (filler_t*)mapping->a_ops->readpage, NULL);
        if (!IS_ERR(page)) {
                wait_on_page_locked(page);
                kmap(page);
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 3ff89cc5833a..58b2d22142ba 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -85,8 +85,9 @@ static void sysv_put_super(struct super_block *sb)
        kfree(sbi);
 }
-static int sysv_statfs(struct super_block *sb, struct kstatfs *buf)
+static int sysv_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct sysv_sb_info *sbi = SYSV_SB(sb);
        buf->f_type = sb->s_magic;
diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index e92b991e6dda..876639b93321 100644
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -506,16 +506,17 @@ failed:
 /* Every kernel module contains stuff like this. */
-static struct super_block *sysv_get_sb(struct file_system_type *fs_type,
+static int sysv_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, sysv_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, sysv_fill_super,
+                           mnt);
 }
-static struct super_block *v7_get_sb(struct file_system_type *fs_type,
+static int v7_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, v7_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, v7_fill_super, mnt);
 }
 static struct file_system_type sysv_fs_type = {
diff --git a/fs/udf/super.c b/fs/udf/super.c
index e45789fe38e8..44fe2cb0bbb2 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -91,13 +91,13 @@ static void udf_load_partdesc(struct super_block *, struct buffer_head *);
 static void udf_open_lvid(struct super_block *);
 static void udf_close_lvid(struct super_block *);
 static unsigned int udf_count_free(struct super_block *);
-static int udf_statfs(struct super_block *, struct kstatfs *);
+static int udf_statfs(struct dentry *, struct kstatfs *);
 /* UDF filesystem type */
-static struct super_block *udf_get_sb(struct file_system_type *fs_type,
+static int udf_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
 }
 static struct file_system_type udf_fstype = {
@@ -1779,8 +1779,10 @@ udf_put_super(struct super_block *sb)
 *      Written, tested, and released.
 */
 static int
-udf_statfs(struct super_block *sb, struct kstatfs *buf)
+udf_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        buf->f_type = UDF_SUPER_MAGIC;
        buf->f_bsize = sb->s_blocksize;
        buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index db98a4c71e63..fe5ab2aa2899 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1113,8 +1113,9 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
        return 0;
 }
-static int ufs_statfs (struct super_block *sb, struct kstatfs *buf)
+static int ufs_statfs (struct dentry *dentry, struct kstatfs *buf)
 {
+        struct super_block *sb = dentry->d_sb;
        struct ufs_sb_private_info * uspi;
        struct ufs_super_block_first * usb1;
        struct ufs_super_block * usb;
@@ -1311,10 +1312,10 @@ out:
 #endif
-static struct super_block *ufs_get_sb(struct file_system_type *fs_type,
+static int ufs_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
+        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ufs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ufs_fill_super, mnt);
 }
 static struct file_system_type ufs_fs_type = {
diff --git a/fs/vfat/namei.c b/fs/vfat/namei.c
index a56cec3be5f0..9a8f48bae956 100644
--- a/fs/vfat/namei.c
+++ b/fs/vfat/namei.c
@@ -1023,11 +1023,12 @@ static int vfat_fill_super(struct super_block *sb, void *data, int silent)
        return 0;
 }
-static struct super_block *vfat_get_sb(struct file_system_type *fs_type,
+static int vfat_get_sb(struct file_system_type *fs_type,
-                                       int flags, const char *dev_name,
+                       int flags, const char *dev_name,
-                                       void *data)
+                       void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, vfat_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, vfat_fill_super,
+                           mnt);
 }
 static struct file_system_type vfat_fs_type = {
diff --git a/fs/xfs/linux-2.6/xfs_stats.c b/fs/xfs/linux-2.6/xfs_stats.c
index 1f0589a05eca..e480b6102051 100644
--- a/fs/xfs/linux-2.6/xfs_stats.c
+++ b/fs/xfs/linux-2.6/xfs_stats.c
@@ -62,7 +62,7 @@ xfs_read_xfsstats(
                while (j < xstats[i].endpoint) {
                        val = 0;
                        /* sum over all cpus */
-                        for_each_cpu(c)
+                        for_each_possible_cpu(c)
                                val += *(((__u32*)&per_cpu(xfsstats, c) + j));
                        len += sprintf(buffer + len, " %u", val);
                        j++;
@@ -70,7 +70,7 @@ xfs_read_xfsstats(
                buffer[len++] = '\n';
        }
        /* extra precision counters */
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
                xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
                xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index f2a0778536f4..9bdef9d51900 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -684,10 +684,11 @@ xfs_fs_sync_super(
 STATIC int
 xfs_fs_statfs(
-        struct super_block      *sb,
+        struct dentry           *dentry,
        struct kstatfs          *statp)
 {
-        return -bhv_vfs_statvfs(vfs_from_sb(sb), statp, NULL);
+        return -bhv_vfs_statvfs(vfs_from_sb(dentry->d_sb), statp,
+                                vn_from_inode(dentry->d_inode));
 }
 STATIC int
@@ -853,14 +854,16 @@ fail_vfsop:
        return -error;
 }
-STATIC struct super_block *
+STATIC int
 xfs_fs_get_sb(
        struct file_system_type *fs_type,
        int                     flags,
        const char              *dev_name,
-        void                    *data)
+        void                    *data,
+        struct vfsmount         *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
+                           mnt);
 }
 STATIC struct super_operations xfs_super_operations = {
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index 4af97682bec8..af246532fbfb 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -38,7 +38,7 @@ xfs_stats_clear_proc_handler(
        if (!ret && write && *valp) {
                printk("XFS Clearing xfsstats\n");
-                for_each_cpu(c) {
+                for_each_possible_cpu(c) {
                        preempt_disable();
                        /* save vn_active, it's a universal truth! */
                        vn_active = per_cpu(xfsstats, c).vn_active;