73 files changed, 2170 insertions, 1126 deletions
diff --git a/fs/afs/file.c b/fs/afs/file.c
index 150b19227922..7bb716887e29 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -28,7 +28,7 @@ static int afs_file_release(struct inode *inode, struct file *file);
 #endif
 static int afs_file_readpage(struct file *file, struct page *page);
-static int afs_file_invalidatepage(struct page *page, unsigned long offset);
+static void afs_file_invalidatepage(struct page *page, unsigned long offset);
 static int afs_file_releasepage(struct page *page, gfp_t gfp_flags);
 struct inode_operations afs_file_inode_operations = {
@@ -212,7 +212,7 @@ int afs_cache_get_page_cookie(struct page *page,
 /*
 * invalidate part or all of a page
 */
-static int afs_file_invalidatepage(struct page *page, unsigned long offset)
+static void afs_file_invalidatepage(struct page *page, unsigned long offset)
 {
        int ret = 1;
@@ -238,11 +238,11 @@ static int afs_file_invalidatepage(struct page *page, unsigned long offset)
                        if (!PageWriteback(page))
                                ret = page->mapping->a_ops->releasepage(page,
                                                                        0);
+                        /* possibly should BUG_ON(!ret); - neilb */
                }
        }
        _leave(" = %d", ret);
-        return ret;
 } /* end afs_file_invalidatepage() */
 /*****************************************************************************/
diff --git a/fs/autofs/dirhash.c b/fs/autofs/dirhash.c
index 5ccfcf26310d..3fded389d06b 100644
--- a/fs/autofs/dirhash.c
+++ b/fs/autofs/dirhash.c
@@ -92,7 +92,7 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
                        ;
                dput(dentry);
-                if ( may_umount(mnt) == 0 ) {
+                if ( may_umount(mnt) ) {
                        mntput(mnt);
                        DPRINTK(("autofs: signaling expire on %s\n", ent->name));
                        return ent; /* Expirable! */
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index f54c5b21f876..617fd7b37447 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -3,6 +3,7 @@
 * linux/fs/autofs/autofs_i.h
 *
 *   Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
+ *   Copyright 2005-2006 Ian Kent <raven@themaw.net>
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
@@ -41,14 +42,6 @@
 #define AUTOFS_SUPER_MAGIC 0x0187
-/*
- * If the daemon returns a negative response (AUTOFS_IOC_FAIL) then the
- * kernel will keep the negative response cached for up to the time given
- * here, although the time can be shorter if the kernel throws the dcache
- * entry away.  This probably should be settable from user space.
- */
-#define AUTOFS_NEGATIVE_TIMEOUT (60*HZ) /* 1 minute */
 /* Unified info structure.  This is pointed to by both the dentry and
   inode structures.  Each file in the filesystem has an instance of this
   structure.  It holds a reference to the dentry, so dentries are never
@@ -63,6 +56,7 @@ struct autofs_info {
        struct autofs_sb_info *sbi;
        unsigned long last_used;
+        atomic_t count;
        mode_t  mode;
        size_t  size;
@@ -83,23 +77,37 @@ struct autofs_wait_queue {
        int hash;
        int len;
        char *name;
+        u32 dev;
+        u64 ino;
+        uid_t uid;
+        gid_t gid;
+        pid_t pid;
+        pid_t tgid;
        /* This is for status reporting upon return */
        int status;
-        atomic_t notified;
+        atomic_t notify;
        atomic_t wait_ctr;
 };
 #define AUTOFS_SBI_MAGIC 0x6d4a556d
+#define AUTOFS_TYPE_INDIRECT     0x0001
+#define AUTOFS_TYPE_DIRECT       0x0002
+#define AUTOFS_TYPE_OFFSET       0x0004
 struct autofs_sb_info {
        u32 magic;
        struct dentry *root;
+        int pipefd;
        struct file *pipe;
        pid_t oz_pgrp;
        int catatonic;
        int version;
        int sub_version;
+        int min_proto;
+        int max_proto;
        unsigned long exp_timeout;
+        unsigned int type;
        int reghost_enabled;
        int needs_reghost;
        struct super_block *sb;
@@ -166,6 +174,8 @@ int autofs4_expire_multi(struct super_block *, struct vfsmount *,
 extern struct inode_operations autofs4_symlink_inode_operations;
 extern struct inode_operations autofs4_dir_inode_operations;
 extern struct inode_operations autofs4_root_inode_operations;
+extern struct inode_operations autofs4_indirect_root_inode_operations;
+extern struct inode_operations autofs4_direct_root_inode_operations;
 extern struct file_operations autofs4_dir_operations;
 extern struct file_operations autofs4_root_operations;
@@ -176,13 +186,6 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *, struct autofs_sb_info
 /* Queue management functions */
-enum autofs_notify
-{
-        NFY_NONE,
-        NFY_MOUNT,
-        NFY_EXPIRE
-};
 int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
 int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
 void autofs4_catatonic_mode(struct autofs_sb_info *);
@@ -200,12 +203,22 @@ static inline int autofs4_follow_mount(struct vfsmount **mnt, struct dentry **de
        return res;
 }
+static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
+{
+        return new_encode_dev(sbi->sb->s_dev);
+}
+static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
+{
+        return sbi->sb->s_root->d_inode->i_ino;
+}
 static inline int simple_positive(struct dentry *dentry)
 {
        return dentry->d_inode && !d_unhashed(dentry);
 }
-static inline int simple_empty_nolock(struct dentry *dentry)
+static inline int __simple_empty(struct dentry *dentry)
 {
        struct dentry *child;
        int ret = 0;
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index dc39589df165..b8ce02607d66 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -4,7 +4,7 @@
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
@@ -16,7 +16,7 @@
 static unsigned long now;
-/* Check if a dentry can be expired return 1 if it can else return 0 */
+/* Check if a dentry can be expired */
 static inline int autofs4_can_expire(struct dentry *dentry,
                                        unsigned long timeout, int do_now)
 {
@@ -41,14 +41,14 @@ static inline int autofs4_can_expire(struct dentry *dentry,
                     attempts if expire fails the first time */
                ino->last_used = now;
        }
        return 1;
 }
-/* Check a mount point for busyness return 1 if not busy, otherwise */
+/* Check a mount point for busyness */
-static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
+static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
 {
-        int status = 0;
+        struct dentry *top = dentry;
+        int status = 1;
        DPRINTK("dentry %p %.*s",
                dentry, (int)dentry->d_name.len, dentry->d_name.name);
@@ -63,9 +63,14 @@ static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
        if (is_autofs4_dentry(dentry))
                goto done;
-        /* The big question */
+        /* Update the expiry counter if fs is busy */
-        if (may_umount_tree(mnt) == 0)
+        if (!may_umount_tree(mnt)) {
-                status = 1;
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                ino->last_used = jiffies;
+                goto done;
+        }
+        status = 0;
 done:
        DPRINTK("returning = %d", status);
        mntput(mnt);
@@ -73,78 +78,124 @@ done:
        return status;
 }
+/*
+ * Calculate next entry in top down tree traversal.
+ * From next_mnt in namespace.c - elegant.
+ */
+static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
+{
+        struct list_head *next = p->d_subdirs.next;
+        if (next == &p->d_subdirs) {
+                while (1) {
+                        if (p == root)
+                                return NULL;
+                        next = p->d_u.d_child.next;
+                        if (next != &p->d_parent->d_subdirs)
+                                break;
+                        p = p->d_parent;
+                }
+        }
+        return list_entry(next, struct dentry, d_u.d_child);
+}
+/*
+ * Check a direct mount point for busyness.
+ * Direct mounts have similar expiry semantics to tree mounts.
+ * The tree is not busy iff no mountpoints are busy and there are no
+ * autofs submounts.
+ */
+static int autofs4_direct_busy(struct vfsmount *mnt,
+                                struct dentry *top,
+                                unsigned long timeout,
+                                int do_now)
+{
+        DPRINTK("top %p %.*s",
+                top, (int) top->d_name.len, top->d_name.name);
+        /* If it's busy update the expiry counters */
+        if (!may_umount_tree(mnt)) {
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                if (ino)
+                        ino->last_used = jiffies;
+                return 1;
+        }
+        /* Timeout of a direct mount is determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+        return 0;
+}
 /* Check a directory tree of mount points for busyness
 * The tree is not busy iff no mountpoints are busy
- * Return 1 if the tree is busy or 0 otherwise
 */
-static int autofs4_check_tree(struct vfsmount *mnt,
+static int autofs4_tree_busy(struct vfsmount *mnt,
-                              struct dentry *top,
+                             struct dentry *top,
-                              unsigned long timeout,
+                             unsigned long timeout,
-                              int do_now)
+                             int do_now)
 {
-        struct dentry *this_parent = top;
+        struct autofs_info *top_ino = autofs4_dentry_ino(top);
-        struct list_head *next;
+        struct dentry *p;
-        DPRINTK("parent %p %.*s",
+        DPRINTK("top %p %.*s",
                top, (int)top->d_name.len, top->d_name.name);
        /* Negative dentry - give up */
        if (!simple_positive(top))
-                return 0;
+                return 1;
-        /* Timeout of a tree mount is determined by its top dentry */
-        if (!autofs4_can_expire(top, timeout, do_now))
-                return 0;
-        /* Is someone visiting anywhere in the tree ? */
-        if (may_umount_tree(mnt))
-                return 0;
        spin_lock(&dcache_lock);
-repeat:
+        for (p = top; p; p = next_dentry(p, top)) {
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
                /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
+                if (!simple_positive(p))
-                        next = next->next;
                        continue;
-                }
                DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+                        p, (int) p->d_name.len, p->d_name.name);
-                if (!simple_empty_nolock(dentry)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
-                dentry = dget(dentry);
+                p = dget(p);
                spin_unlock(&dcache_lock);
-                if (d_mountpoint(dentry)) {
+                /*
-                        /* First busy => tree busy */
+                 * Is someone visiting anywhere in the subtree ?
-                        if (!autofs4_check_mount(mnt, dentry)) {
+                 * If there's no mount we need to check the usage
-                                dput(dentry);
+                 * count for the autofs dentry.
-                                return 0;
+                 * If the fs is busy update the expiry counter.
+                 */
+                if (d_mountpoint(p)) {
+                        if (autofs4_mount_busy(mnt, p)) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
+                        }
+                } else {
+                        struct autofs_info *ino = autofs4_dentry_ino(p);
+                        unsigned int ino_count = atomic_read(&ino->count);
+                        /* allow for dget above and top is already dgot */
+                        if (p == top)
+                                ino_count += 2;
+                        else
+                                ino_count++;
+                        if (atomic_read(&p->d_count) > ino_count) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
                        }
                }
+                dput(p);
-                dput(dentry);
                spin_lock(&dcache_lock);
-                next = next->next;
-        }
-        if (this_parent != top) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
-                goto resume;
        }
        spin_unlock(&dcache_lock);
-        return 1;
+        /* Timeout of a tree mount is ultimately determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+        return 0;
 }
 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
@@ -152,58 +203,68 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
                                           unsigned long timeout,
                                           int do_now)
 {
-        struct dentry *this_parent = parent;
+        struct dentry *p;
-        struct list_head *next;
        DPRINTK("parent %p %.*s",
                parent, (int)parent->d_name.len, parent->d_name.name);
        spin_lock(&dcache_lock);
-repeat:
+        for (p = parent; p; p = next_dentry(p, parent)) {
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
                /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
+                if (!simple_positive(p))
-                        next = next->next;
                        continue;
-                }
                DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+                        p, (int) p->d_name.len, p->d_name.name);
-                if (!list_empty(&dentry->d_subdirs)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
-                dentry = dget(dentry);
+                p = dget(p);
                spin_unlock(&dcache_lock);
-                if (d_mountpoint(dentry)) {
+                if (d_mountpoint(p)) {
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
-                                goto cont;
                        /* Can we umount this guy */
-                        if (autofs4_check_mount(mnt, dentry))
+                        if (autofs4_mount_busy(mnt, p))
-                                return dentry;
+                                goto cont;
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(p, timeout, do_now))
+                                return p;
                }
 cont:
-                dput(dentry);
+                dput(p);
                spin_lock(&dcache_lock);
-                next = next->next;
        }
+        spin_unlock(&dcache_lock);
+        return NULL;
+}
+/* Check if we can expire a direct mount (possibly a tree) */
+static struct dentry *autofs4_expire_direct(struct super_block *sb,
+                                            struct vfsmount *mnt,
+                                            struct autofs_sb_info *sbi,
+                                            int how)
+{
+        unsigned long timeout;
+        struct dentry *root = dget(sb->s_root);
+        int do_now = how & AUTOFS_EXP_IMMEDIATE;
+        if (!sbi->exp_timeout || !root)
+                return NULL;
+        now = jiffies;
+        timeout = sbi->exp_timeout;
+        /* Lock the tree as we must expire as a whole */
+        spin_lock(&sbi->fs_lock);
+        if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
+                struct autofs_info *ino = autofs4_dentry_ino(root);
-        if (this_parent != parent) {
+                /* Set this flag early to catch sys_chdir and the like */
-                next = this_parent->d_u.d_child.next;
+                ino->flags |= AUTOFS_INF_EXPIRING;
-                this_parent = this_parent->d_parent;
+                spin_unlock(&sbi->fs_lock);
-                goto resume;
+                return root;
        }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&sbi->fs_lock);
+        dput(root);
        return NULL;
 }
@@ -214,10 +275,10 @@ cont:
 *  - it is unused by any user process
 *  - it has been unused for exp_timeout time
 */
-static struct dentry *autofs4_expire(struct super_block *sb,
+static struct dentry *autofs4_expire_indirect(struct super_block *sb,
-                                     struct vfsmount *mnt,
+                                              struct vfsmount *mnt,
-                                     struct autofs_sb_info *sbi,
+                                              struct autofs_sb_info *sbi,
-                                     int how)
+                                              int how)
 {
        unsigned long timeout;
        struct dentry *root = sb->s_root;
@@ -241,7 +302,7 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
                /* Negative dentry - give up */
-                if ( !simple_positive(dentry) ) {
+                if (!simple_positive(dentry)) {
                        next = next->next;
                        continue;
                }
@@ -249,31 +310,36 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                dentry = dget(dentry);
                spin_unlock(&dcache_lock);
-                /* Case 1: indirect mount or top level direct mount */
+                /*
+                 * Case 1: (i) indirect mount or top level pseudo direct mount
+                 *         (autofs-4.1).
+                 *         (ii) indirect mount with offset mount, check the "/"
+                 *         offset (autofs-5.0+).
+                 */
                if (d_mountpoint(dentry)) {
                        DPRINTK("checking mountpoint %p %.*s",
                                dentry, (int)dentry->d_name.len, dentry->d_name.name);
-                        /* Can we expire this guy */
+                        /* Can we umount this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
+                        if (autofs4_mount_busy(mnt, dentry))
                                goto next;
-                        /* Can we umount this guy */
+                        /* Can we expire this guy */
-                        if (autofs4_check_mount(mnt, dentry)) {
+                        if (autofs4_can_expire(dentry, timeout, do_now)) {
                                expired = dentry;
                                break;
                        }
                        goto next;
                }
-                if ( simple_empty(dentry) )
+                if (simple_empty(dentry))
                        goto next;
                /* Case 2: tree mount, expire iff entire tree is not busy */
                if (!exp_leaves) {
                        /* Lock the tree as we must expire as a whole */
                        spin_lock(&sbi->fs_lock);
-                        if (autofs4_check_tree(mnt, dentry, timeout, do_now)) {
+                        if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
                                struct autofs_info *inf = autofs4_dentry_ino(dentry);
                                /* Set this flag early to catch sys_chdir and the like */
@@ -283,7 +349,10 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                                break;
                        }
                        spin_unlock(&sbi->fs_lock);
-                /* Case 3: direct mount, expire individual leaves */
+                /*
+                 * Case 3: pseudo direct mount, expire individual leaves
+                 *         (autofs-4.1).
+                 */
                } else {
                        expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
                        if (expired) {
@@ -297,7 +366,7 @@ next:
                next = next->next;
        }
-        if ( expired ) {
+        if (expired) {
                DPRINTK("returning %p %.*s",
                        expired, (int)expired->d_name.len, expired->d_name.name);
                spin_lock(&dcache_lock);
@@ -325,7 +394,7 @@ int autofs4_expire_run(struct super_block *sb,
        pkt.hdr.proto_version = sbi->version;
        pkt.hdr.type = autofs_ptype_expire;
-        if ((dentry = autofs4_expire(sb, mnt, sbi, 0)) == NULL)
+        if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
                return -EAGAIN;
        pkt.len = dentry->d_name.len;
@@ -351,17 +420,22 @@ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
        if (arg && get_user(do_now, arg))
                return -EFAULT;
-        if ((dentry = autofs4_expire(sb, mnt, sbi, do_now)) != NULL) {
+        if (sbi->type & AUTOFS_TYPE_DIRECT)
-                struct autofs_info *de_info = autofs4_dentry_ino(dentry);
+                dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
+        else
+                dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
+        if (dentry) {
+                struct autofs_info *ino = autofs4_dentry_ino(dentry);
                /* This is synchronous because it makes the daemon a
                   little easier */
-                de_info->flags |= AUTOFS_INF_EXPIRING;
+                ino->flags |= AUTOFS_INF_EXPIRING;
                ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
-                de_info->flags &= ~AUTOFS_INF_EXPIRING;
+                ino->flags &= ~AUTOFS_INF_EXPIRING;
                dput(dentry);
        }
-                
        return ret;
 }
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 1ad98d48e550..4eddee4e76fc 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -3,6 +3,7 @@
 * linux/fs/autofs/inode.c
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
+ *  Copyright 2005-2006 Ian Kent <raven@themaw.net>
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
@@ -13,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/file.h>
+#include <linux/seq_file.h>
 #include <linux/pagemap.h>
 #include <linux/parser.h>
 #include <linux/bitops.h>
@@ -46,6 +48,7 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
        ino->size = 0;
        ino->last_used = jiffies;
+        atomic_set(&ino->count, 0);
        ino->sbi = sbi;
@@ -64,10 +67,19 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
 void autofs4_free_ino(struct autofs_info *ino)
 {
+        struct autofs_info *p_ino;
        if (ino->dentry) {
                ino->dentry->d_fsdata = NULL;
-                if (ino->dentry->d_inode)
+                if (ino->dentry->d_inode) {
+                        struct dentry *parent = ino->dentry->d_parent;
+                        if (atomic_dec_and_test(&ino->count)) {
+                                p_ino = autofs4_dentry_ino(parent);
+                                if (p_ino && parent != ino->dentry)
+                                        atomic_dec(&p_ino->count);
+                        }
                        dput(ino->dentry);
+                }
                ino->dentry = NULL;
        }
        if (ino->free)
@@ -145,20 +157,44 @@ static void autofs4_put_super(struct super_block *sb)
                autofs4_catatonic_mode(sbi); /* Free wait queues, close pipe */
        /* Clean up and release dangling references */
-        if (sbi)
+        autofs4_force_release(sbi);
-                autofs4_force_release(sbi);
        kfree(sbi);
        DPRINTK("shutting down");
 }
+static int autofs4_show_options(struct seq_file *m, struct vfsmount *mnt)
+{
+        struct autofs_sb_info *sbi = autofs4_sbi(mnt->mnt_sb);
+        if (!sbi)
+                return 0;
+        seq_printf(m, ",fd=%d", sbi->pipefd);
+        seq_printf(m, ",pgrp=%d", sbi->oz_pgrp);
+        seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
+        seq_printf(m, ",minproto=%d", sbi->min_proto);
+        seq_printf(m, ",maxproto=%d", sbi->max_proto);
+        if (sbi->type & AUTOFS_TYPE_OFFSET)
+                seq_printf(m, ",offset");
+        else if (sbi->type & AUTOFS_TYPE_DIRECT)
+                seq_printf(m, ",direct");
+        else
+                seq_printf(m, ",indirect");
+        return 0;
+}
 static struct super_operations autofs4_sops = {
        .put_super      = autofs4_put_super,
        .statfs         = simple_statfs,
+        .show_options   = autofs4_show_options,
 };
-enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto};
+enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto,
+        Opt_indirect, Opt_direct, Opt_offset};
 static match_table_t tokens = {
        {Opt_fd, "fd=%u"},
@@ -167,11 +203,15 @@ static match_table_t tokens = {
        {Opt_pgrp, "pgrp=%u"},
        {Opt_minproto, "minproto=%u"},
        {Opt_maxproto, "maxproto=%u"},
+        {Opt_indirect, "indirect"},
+        {Opt_direct, "direct"},
+        {Opt_offset, "offset"},
        {Opt_err, NULL}
 };
 static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
-                         pid_t *pgrp, int *minproto, int *maxproto)
+                         pid_t *pgrp, unsigned int *type,
+                         int *minproto, int *maxproto)
 {
        char *p;
        substring_t args[MAX_OPT_ARGS];
@@ -225,6 +265,15 @@ static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
                                return 1;
                        *maxproto = option;
                        break;
+                case Opt_indirect:
+                        *type = AUTOFS_TYPE_INDIRECT;
+                        break;
+                case Opt_direct:
+                        *type = AUTOFS_TYPE_DIRECT;
+                        break;
+                case Opt_offset:
+                        *type = AUTOFS_TYPE_DIRECT | AUTOFS_TYPE_OFFSET;
+                        break;
                default:
                        return 1;
                }
@@ -243,6 +292,11 @@ static struct autofs_info *autofs4_mkroot(struct autofs_sb_info *sbi)
        return ino;
 }
+void autofs4_dentry_release(struct dentry *);
+static struct dentry_operations autofs4_sb_dentry_operations = {
+        .d_release      = autofs4_dentry_release,
+};
 int autofs4_fill_super(struct super_block *s, void *data, int silent)
 {
        struct inode * root_inode;
@@ -251,7 +305,6 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        int pipefd;
        struct autofs_sb_info *sbi;
        struct autofs_info *ino;
-        int minproto, maxproto;
        sbi = (struct autofs_sb_info *) kmalloc(sizeof(*sbi), GFP_KERNEL);
        if ( !sbi )
@@ -263,12 +316,16 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        s->s_fs_info = sbi;
        sbi->magic = AUTOFS_SBI_MAGIC;
        sbi->root = NULL;
+        sbi->pipefd = -1;
        sbi->catatonic = 0;
        sbi->exp_timeout = 0;
        sbi->oz_pgrp = process_group(current);
        sbi->sb = s;
        sbi->version = 0;
        sbi->sub_version = 0;
+        sbi->type = 0;
+        sbi->min_proto = 0;
+        sbi->max_proto = 0;
        mutex_init(&sbi->wq_mutex);
        spin_lock_init(&sbi->fs_lock);
        sbi->queues = NULL;
@@ -285,38 +342,46 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        if (!ino)
                goto fail_free;
        root_inode = autofs4_get_inode(s, ino);
-        kfree(ino);
        if (!root_inode)
-                goto fail_free;
+                goto fail_ino;
-        root_inode->i_op = &autofs4_root_inode_operations;
-        root_inode->i_fop = &autofs4_root_operations;
        root = d_alloc_root(root_inode);
-        pipe = NULL;
        if (!root)
                goto fail_iput;
+        pipe = NULL;
+        root->d_op = &autofs4_sb_dentry_operations;
+        root->d_fsdata = ino;
        /* Can this call block? */
        if (parse_options(data, &pipefd,
                          &root_inode->i_uid, &root_inode->i_gid,
-                          &sbi->oz_pgrp,
+                          &sbi->oz_pgrp, &sbi->type,
-                          &minproto, &maxproto)) {
+                          &sbi->min_proto, &sbi->max_proto)) {
                printk("autofs: called with bogus options\n");
                goto fail_dput;
        }
+        root_inode->i_fop = &autofs4_root_operations;
+        root_inode->i_op = sbi->type & AUTOFS_TYPE_DIRECT ?
+                        &autofs4_direct_root_inode_operations :
+                        &autofs4_indirect_root_inode_operations;
        /* Couldn't this be tested earlier? */
-        if (maxproto < AUTOFS_MIN_PROTO_VERSION ||
+        if (sbi->max_proto < AUTOFS_MIN_PROTO_VERSION ||
-            minproto > AUTOFS_MAX_PROTO_VERSION) {
+            sbi->min_proto > AUTOFS_MAX_PROTO_VERSION) {
                printk("autofs: kernel does not match daemon version "
                       "daemon (%d, %d) kernel (%d, %d)\n",
-                        minproto, maxproto,
+                        sbi->min_proto, sbi->max_proto,
                        AUTOFS_MIN_PROTO_VERSION, AUTOFS_MAX_PROTO_VERSION);
                goto fail_dput;
        }
-        sbi->version = maxproto > AUTOFS_MAX_PROTO_VERSION ? AUTOFS_MAX_PROTO_VERSION : maxproto;
+        /* Establish highest kernel protocol version */
+        if (sbi->max_proto > AUTOFS_MAX_PROTO_VERSION)
+                sbi->version = AUTOFS_MAX_PROTO_VERSION;
+        else
+                sbi->version = sbi->max_proto;
        sbi->sub_version = AUTOFS_PROTO_SUBVERSION;
        DPRINTK("pipe fd = %d, pgrp = %u", pipefd, sbi->oz_pgrp);
@@ -329,6 +394,7 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        if ( !pipe->f_op || !pipe->f_op->write )
                goto fail_fput;
        sbi->pipe = pipe;
+        sbi->pipefd = pipefd;
        /*
         * Take a reference to the root dentry so we get a chance to
@@ -356,6 +422,8 @@ fail_dput:
 fail_iput:
        printk("autofs: get root dentry failed\n");
        iput(root_inode);
+fail_ino:
+        kfree(ino);
 fail_free:
        kfree(sbi);
 fail_unlock:
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 62d8d4acb8bb..c8fe43a475e2 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -4,7 +4,7 @@
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
@@ -30,7 +30,7 @@ static int autofs4_dir_close(struct inode *inode, struct file *file);
 static int autofs4_dir_readdir(struct file * filp, void * dirent, filldir_t filldir);
 static int autofs4_root_readdir(struct file * filp, void * dirent, filldir_t filldir);
 static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *);
-static int autofs4_dcache_readdir(struct file *, void *, filldir_t);
+static void *autofs4_follow_link(struct dentry *, struct nameidata *);
 struct file_operations autofs4_root_operations = {
        .open           = dcache_dir_open,
@@ -47,7 +47,7 @@ struct file_operations autofs4_dir_operations = {
        .readdir        = autofs4_dir_readdir,
 };
-struct inode_operations autofs4_root_inode_operations = {
+struct inode_operations autofs4_indirect_root_inode_operations = {
        .lookup         = autofs4_lookup,
        .unlink         = autofs4_dir_unlink,
        .symlink        = autofs4_dir_symlink,
@@ -55,6 +55,14 @@ struct inode_operations autofs4_root_inode_operations = {
        .rmdir          = autofs4_dir_rmdir,
 };
+struct inode_operations autofs4_direct_root_inode_operations = {
+        .lookup         = autofs4_lookup,
+        .unlink         = autofs4_dir_unlink,
+        .mkdir          = autofs4_dir_mkdir,
+        .rmdir          = autofs4_dir_rmdir,
+        .follow_link    = autofs4_follow_link,
+};
 struct inode_operations autofs4_dir_inode_operations = {
        .lookup         = autofs4_lookup,
        .unlink         = autofs4_dir_unlink,
@@ -82,87 +90,7 @@ static int autofs4_root_readdir(struct file *file, void *dirent,
        DPRINTK("needs_reghost = %d", sbi->needs_reghost);
-        return autofs4_dcache_readdir(file, dirent, filldir);
+        return dcache_readdir(file, dirent, filldir);
-}
-/* Update usage from here to top of tree, so that scan of
-   top-level directories will give a useful result */
-static void autofs4_update_usage(struct vfsmount *mnt, struct dentry *dentry)
-{
-        struct dentry *top = dentry->d_sb->s_root;
-        spin_lock(&dcache_lock);
-        for(; dentry != top; dentry = dentry->d_parent) {
-                struct autofs_info *ino = autofs4_dentry_ino(dentry);
-                if (ino) {
-                        touch_atime(mnt, dentry);
-                        ino->last_used = jiffies;
-                }
-        }
-        spin_unlock(&dcache_lock);
-}
-/*
- * From 2.4 kernel readdir.c
- */
-static int autofs4_dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
-{
-        int i;
-        struct dentry *dentry = filp->f_dentry;
-        i = filp->f_pos;
-        switch (i) {
-                case 0:
-                        if (filldir(dirent, ".", 1, i, dentry->d_inode->i_ino, DT_DIR) < 0)
-                                break;
-                        i++;
-                        filp->f_pos++;
-                        /* fallthrough */
-                case 1:
-                        if (filldir(dirent, "..", 2, i, dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
-                                break;
-                        i++;
-                        filp->f_pos++;
-                        /* fallthrough */
-                default: {
-                        struct list_head *list;
-                        int j = i-2;
-                        spin_lock(&dcache_lock);
-                        list = dentry->d_subdirs.next;
-                        for (;;) {
-                                if (list == &dentry->d_subdirs) {
-                                        spin_unlock(&dcache_lock);
-                                        return 0;
-                                }
-                                if (!j)
-                                        break;
-                                j--;
-                                list = list->next;
-                        }
-                        while(1) {
-                                struct dentry *de = list_entry(list,
-                                                struct dentry, d_u.d_child);
-                                if (!d_unhashed(de) && de->d_inode) {
-                                        spin_unlock(&dcache_lock);
-                                        if (filldir(dirent, de->d_name.name, de->d_name.len, filp->f_pos, de->d_inode->i_ino, DT_UNKNOWN) < 0)
-                                                break;
-                                        spin_lock(&dcache_lock);
-                                }
-                                filp->f_pos++;
-                                list = list->next;
-                                if (list != &dentry->d_subdirs)
-                                        continue;
-                                spin_unlock(&dcache_lock);
-                                break;
-                        }
-                }
-        }
-        return 0;
 }
 static int autofs4_dir_open(struct inode *inode, struct file *file)
@@ -170,8 +98,16 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
        struct dentry *dentry = file->f_dentry;
        struct vfsmount *mnt = file->f_vfsmnt;
        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor;
        int status;
+        status = dcache_dir_open(inode, file);
+        if (status)
+                goto out;
+        cursor = file->private_data;
+        cursor->d_fsdata = NULL;
        DPRINTK("file=%p dentry=%p %.*s",
                file, dentry, dentry->d_name.len, dentry->d_name.name);
@@ -180,12 +116,15 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
        if (autofs4_ispending(dentry)) {
                DPRINTK("dentry busy");
-                return -EBUSY;
+                dcache_dir_close(inode, file);
+                status = -EBUSY;
+                goto out;
        }
+        status = -ENOENT;
        if (!d_mountpoint(dentry) && dentry->d_op && dentry->d_op->d_revalidate) {
                struct nameidata nd;
-                int empty;
+                int empty, ret;
                /* In case there are stale directory dentrys from a failed mount */
                spin_lock(&dcache_lock);
@@ -195,13 +134,13 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
                if (!empty)
                        d_invalidate(dentry);
-                nd.dentry = dentry;
-                nd.mnt = mnt;
                nd.flags = LOOKUP_DIRECTORY;
-                status = (dentry->d_op->d_revalidate)(dentry, &nd);
+                ret = (dentry->d_op->d_revalidate)(dentry, &nd);
-                if (!status)
+                if (!ret) {
-                        return -ENOENT;
+                        dcache_dir_close(inode, file);
+                        goto out;
+                }
        }
        if (d_mountpoint(dentry)) {
@@ -212,25 +151,29 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
                if (!autofs4_follow_mount(&fp_mnt, &fp_dentry)) {
                        dput(fp_dentry);
                        mntput(fp_mnt);
-                        return -ENOENT;
+                        dcache_dir_close(inode, file);
+                        goto out;
                }
                fp = dentry_open(fp_dentry, fp_mnt, file->f_flags);
                status = PTR_ERR(fp);
                if (IS_ERR(fp)) {
-                        file->private_data = NULL;
+                        dcache_dir_close(inode, file);
-                        return status;
+                        goto out;
                }
-                file->private_data = fp;
+                cursor->d_fsdata = fp;
        }
-out:
        return 0;
+out:
+        return status;
 }
 static int autofs4_dir_close(struct inode *inode, struct file *file)
 {
        struct dentry *dentry = file->f_dentry;
        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor = file->private_data;
+        int status = 0;
        DPRINTK("file=%p dentry=%p %.*s",
                file, dentry, dentry->d_name.len, dentry->d_name.name);
@@ -240,26 +183,28 @@ static int autofs4_dir_close(struct inode *inode, struct file *file)
        if (autofs4_ispending(dentry)) {
                DPRINTK("dentry busy");
-                return -EBUSY;
+                status = -EBUSY;
+                goto out;
        }
        if (d_mountpoint(dentry)) {
-                struct file *fp = file->private_data;
+                struct file *fp = cursor->d_fsdata;
+                if (!fp) {
-                if (!fp)
+                        status = -ENOENT;
-                        return -ENOENT;
+                        goto out;
+                }
                filp_close(fp, current->files);
-                file->private_data = NULL;
        }
 out:
-        return 0;
+        dcache_dir_close(inode, file);
+        return status;
 }
 static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
        struct dentry *dentry = file->f_dentry;
        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor = file->private_data;
        int status;
        DPRINTK("file=%p dentry=%p %.*s",
@@ -274,7 +219,7 @@ static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldi
        }
        if (d_mountpoint(dentry)) {
-                struct file *fp = file->private_data;
+                struct file *fp = cursor->d_fsdata;
                if (!fp)
                        return -ENOENT;
@@ -289,27 +234,26 @@ static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldi
                return status;
        }
 out:
-        return autofs4_dcache_readdir(file, dirent, filldir);
+        return dcache_readdir(file, dirent, filldir);
 }
-static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int flags)
+static int try_to_fill_dentry(struct dentry *dentry, int flags)
 {
-        struct super_block *sb = mnt->mnt_sb;
+        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
-        struct autofs_sb_info *sbi = autofs4_sbi(sb);
+        struct autofs_info *ino = autofs4_dentry_ino(dentry);
-        struct autofs_info *de_info = autofs4_dentry_ino(dentry);
        int status = 0;
        /* Block on any pending expiry here; invalidate the dentry
           when expiration is done to trigger mount request with a new
           dentry */
-        if (de_info && (de_info->flags & AUTOFS_INF_EXPIRING)) {
+        if (ino && (ino->flags & AUTOFS_INF_EXPIRING)) {
                DPRINTK("waiting for expire %p name=%.*s",
                         dentry, dentry->d_name.len, dentry->d_name.name);
                status = autofs4_wait(sbi, dentry, NFY_NONE);
-                
                DPRINTK("expire done status=%d", status);
-                
                /*
                 * If the directory still exists the mount request must
                 * continue otherwise it can't be followed at the right
@@ -317,34 +261,36 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
                 */
                status = d_invalidate(dentry);
                if (status != -EBUSY)
-                        return 0;
+                        return -ENOENT;
        }
        DPRINTK("dentry=%p %.*s ino=%p",
                 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
-        /* Wait for a pending mount, triggering one if there isn't one already */
+        /*
+         * Wait for a pending mount, triggering one if there
+         * isn't one already
+         */
        if (dentry->d_inode == NULL) {
                DPRINTK("waiting for mount name=%.*s",
                         dentry->d_name.len, dentry->d_name.name);
                status = autofs4_wait(sbi, dentry, NFY_MOUNT);
-                 
                DPRINTK("mount done status=%d", status);
                if (status && dentry->d_inode)
-                        return 0; /* Try to get the kernel to invalidate this dentry */
+                        return status; /* Try to get the kernel to invalidate this dentry */
-                
                /* Turn this into a real negative dentry? */
                if (status == -ENOENT) {
-                        dentry->d_time = jiffies + AUTOFS_NEGATIVE_TIMEOUT;
                        spin_lock(&dentry->d_lock);
                        dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
                        spin_unlock(&dentry->d_lock);
-                        return 1;
+                        return status;
                } else if (status) {
                        /* Return a negative dentry, but leave it "pending" */
-                        return 1;
+                        return status;
                }
        /* Trigger mount for path component or follow link */
        } else if (flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY) ||
@@ -363,19 +309,87 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
                        spin_lock(&dentry->d_lock);
                        dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
                        spin_unlock(&dentry->d_lock);
-                        return 0;
+                        return status;
                }
        }
-        /* We don't update the usages for the autofs daemon itself, this
+        /* Initialize expiry counter after successful mount */
-           is necessary for recursive autofs mounts */
+        if (ino)
-        if (!autofs4_oz_mode(sbi))
+                ino->last_used = jiffies;
-                autofs4_update_usage(mnt, dentry);
        spin_lock(&dentry->d_lock);
        dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
        spin_unlock(&dentry->d_lock);
-        return 1;
+        return status;
+}
+/* For autofs direct mounts the follow link triggers the mount */
+static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        int oz_mode = autofs4_oz_mode(sbi);
+        unsigned int lookup_type;
+        int status;
+        DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d",
+                dentry, dentry->d_name.len, dentry->d_name.name, oz_mode,
+                nd->flags);
+        /* If it's our master or we shouldn't trigger a mount we're done */
+        lookup_type = nd->flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY);
+        if (oz_mode || !lookup_type)
+                goto done;
+        /*
+         * If a request is pending wait for it.
+         * If it's a mount then it won't be expired till at least
+         * a liitle later and if it's an expire then we might need
+         * to mount it again.
+         */
+        if (autofs4_ispending(dentry)) {
+                DPRINTK("waiting for active request %p name=%.*s",
+                        dentry, dentry->d_name.len, dentry->d_name.name);
+                status = autofs4_wait(sbi, dentry, NFY_NONE);
+                DPRINTK("request done status=%d", status);
+        }
+        /*
+         * If the dentry contains directories then it is an
+         * autofs multi-mount with no root mount offset. So
+         * don't try to mount it again.
+         */
+        spin_lock(&dcache_lock);
+        if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
+                spin_unlock(&dcache_lock);
+                status = try_to_fill_dentry(dentry, 0);
+                if (status)
+                        goto out_error;
+                /*
+                 * The mount succeeded but if there is no root mount
+                 * it must be an autofs multi-mount with no root offset
+                 * so we don't need to follow the mount.
+                 */
+                if (d_mountpoint(dentry)) {
+                        if (!autofs4_follow_mount(&nd->mnt, &nd->dentry)) {
+                                status = -ENOENT;
+                                goto out_error;
+                        }
+                }
+                goto done;
+        }
+        spin_unlock(&dcache_lock);
+done:
+        return NULL;
+out_error:
+        path_release(nd);
+        return ERR_PTR(status);
 }
 /*
@@ -384,47 +398,43 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
 * yet completely filled in, and revalidate has to delay such
 * lookups..
 */
-static int autofs4_revalidate(struct dentry * dentry, struct nameidata *nd)
+static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode * dir = dentry->d_parent->d_inode;
+        struct inode *dir = dentry->d_parent->d_inode;
        struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
        int oz_mode = autofs4_oz_mode(sbi);
        int flags = nd ? nd->flags : 0;
-        int status = 1;
+        int status = 0;
        /* Pending dentry */
        if (autofs4_ispending(dentry)) {
                if (!oz_mode)
-                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
+                        status = try_to_fill_dentry(dentry, flags);
-                return status;
+                return !status;
        }
        /* Negative dentry.. invalidate if "old" */
        if (dentry->d_inode == NULL)
-                return (dentry->d_time - jiffies <= AUTOFS_NEGATIVE_TIMEOUT);
+                return 0;
        /* Check for a non-mountpoint directory with no contents */
        spin_lock(&dcache_lock);
        if (S_ISDIR(dentry->d_inode->i_mode) &&
            !d_mountpoint(dentry) && 
-            list_empty(&dentry->d_subdirs)) {
+            __simple_empty(dentry)) {
                DPRINTK("dentry=%p %.*s, emptydir",
                         dentry, dentry->d_name.len, dentry->d_name.name);
                spin_unlock(&dcache_lock);
                if (!oz_mode)
-                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
+                        status = try_to_fill_dentry(dentry, flags);
-                return status;
+                return !status;
        }
        spin_unlock(&dcache_lock);
-        /* Update the usage list */
-        if (!oz_mode)
-                autofs4_update_usage(nd->mnt, dentry);
        return 1;
 }
-static void autofs4_dentry_release(struct dentry *de)
+void autofs4_dentry_release(struct dentry *de)
 {
        struct autofs_info *inf;
@@ -462,12 +472,13 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
        DPRINTK("name = %.*s",
                dentry->d_name.len, dentry->d_name.name);
+        /* File name too long to exist */
        if (dentry->d_name.len > NAME_MAX)
-                return ERR_PTR(-ENAMETOOLONG);/* File name too long to exist */
+                return ERR_PTR(-ENAMETOOLONG);
        sbi = autofs4_sbi(dir->i_sb);
        oz_mode = autofs4_oz_mode(sbi);
        DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
                 current->pid, process_group(current), sbi->catatonic, oz_mode);
@@ -519,7 +530,7 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
         * doesn't do the right thing for all system calls, but it should
         * be OK for the operations we permit from an autofs.
         */
-        if ( dentry->d_inode && d_unhashed(dentry) )
+        if (dentry->d_inode && d_unhashed(dentry))
                return ERR_PTR(-ENOENT);
        return NULL;
@@ -531,6 +542,7 @@ static int autofs4_dir_symlink(struct inode *dir,
 {
        struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
        struct inode *inode;
        char *cp;
@@ -564,6 +576,10 @@ static int autofs4_dir_symlink(struct inode *dir,
        dentry->d_fsdata = ino;
        ino->dentry = dget(dentry);
+        atomic_inc(&ino->count);
+        p_ino = autofs4_dentry_ino(dentry->d_parent);
+        if (p_ino && dentry->d_parent != dentry)
+                atomic_inc(&p_ino->count);
        ino->inode = inode;
        dir->i_mtime = CURRENT_TIME;
@@ -590,11 +606,17 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
        
        /* This allows root to remove symlinks */
        if ( !autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) )
                return -EACCES;
+        if (atomic_dec_and_test(&ino->count)) {
+                p_ino = autofs4_dentry_ino(dentry->d_parent);
+                if (p_ino && dentry->d_parent != dentry)
+                        atomic_dec(&p_ino->count);
+        }
        dput(ino->dentry);
        dentry->d_inode->i_size = 0;
@@ -611,6 +633,7 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
 {
        struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
        
        if (!autofs4_oz_mode(sbi))
                return -EACCES;
@@ -625,8 +648,12 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);
+        if (atomic_dec_and_test(&ino->count)) {
+                p_ino = autofs4_dentry_ino(dentry->d_parent);
+                if (p_ino && dentry->d_parent != dentry)
+                        atomic_dec(&p_ino->count);
+        }
        dput(ino->dentry);
        dentry->d_inode->i_size = 0;
        dentry->d_inode->i_nlink = 0;
@@ -640,6 +667,7 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
        struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
        struct inode *inode;
        if ( !autofs4_oz_mode(sbi) )
@@ -662,6 +690,10 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        dentry->d_fsdata = ino;
        ino->dentry = dget(dentry);
+        atomic_inc(&ino->count);
+        p_ino = autofs4_dentry_ino(dentry->d_parent);
+        if (p_ino && dentry->d_parent != dentry)
+                atomic_inc(&p_ino->count);
        ino->inode = inode;
        dir->i_nlink++;
        dir->i_mtime = CURRENT_TIME;
@@ -745,7 +777,7 @@ static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
 {
        int status = 0;
-        if (may_umount(mnt) == 0)
+        if (may_umount(mnt))
                status = 1;
        DPRINTK("returning %d", status);
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index be78e9378c03..142ab6aa2aa1 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -3,7 +3,7 @@
 * linux/fs/autofs/waitq.c
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
@@ -33,7 +33,7 @@ void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
        sbi->catatonic = 1;
        wq = sbi->queues;
        sbi->queues = NULL;     /* Erase all wait queues */
-        while ( wq ) {
+        while (wq) {
                nwq = wq->next;
                wq->status = -ENOENT; /* Magic is gone - report failure */
                kfree(wq->name);
@@ -45,7 +45,6 @@ void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
                fput(sbi->pipe);        /* Close the pipe */
                sbi->pipe = NULL;
        }
        shrink_dcache_sb(sbi->sb);
 }
@@ -98,7 +97,10 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
        pkt.hdr.proto_version = sbi->version;
        pkt.hdr.type = type;
-        if (type == autofs_ptype_missing) {
+        switch (type) {
+        /* Kernel protocol v4 missing and expire packets */
+        case autofs_ptype_missing:
+        {
                struct autofs_packet_missing *mp = &pkt.missing;
                pktsz = sizeof(*mp);
@@ -107,7 +109,10 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
                mp->len = wq->len;
                memcpy(mp->name, wq->name, wq->len);
                mp->name[wq->len] = '\0';
-        } else if (type == autofs_ptype_expire_multi) {
+                break;
+        }
+        case autofs_ptype_expire_multi:
+        {
                struct autofs_packet_expire_multi *ep = &pkt.expire_multi;
                pktsz = sizeof(*ep);
@@ -116,7 +121,34 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
                ep->len = wq->len;
                memcpy(ep->name, wq->name, wq->len);
                ep->name[wq->len] = '\0';
-        } else {
+                break;
+        }
+        /*
+         * Kernel protocol v5 packet for handling indirect and direct
+         * mount missing and expire requests
+         */
+        case autofs_ptype_missing_indirect:
+        case autofs_ptype_expire_indirect:
+        case autofs_ptype_missing_direct:
+        case autofs_ptype_expire_direct:
+        {
+                struct autofs_v5_packet *packet = &pkt.v5_packet;
+                pktsz = sizeof(*packet);
+                packet->wait_queue_token = wq->wait_queue_token;
+                packet->len = wq->len;
+                memcpy(packet->name, wq->name, wq->len);
+                packet->name[wq->len] = '\0';
+                packet->dev = wq->dev;
+                packet->ino = wq->ino;
+                packet->uid = wq->uid;
+                packet->gid = wq->gid;
+                packet->pid = wq->pid;
+                packet->tgid = wq->tgid;
+                break;
+        }
+        default:
                printk("autofs4_notify_daemon: bad type %d!\n", type);
                return;
        }
@@ -162,21 +194,29 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
 {
        struct autofs_wait_queue *wq;
        char *name;
-        int len, status;
+        unsigned int len = 0;
+        unsigned int hash = 0;
+        int status;
        /* In catatonic mode, we don't wait for nobody */
-        if ( sbi->catatonic )
+        if (sbi->catatonic)
                return -ENOENT;
        
        name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
        if (!name)
                return -ENOMEM;
-        len = autofs4_getpath(sbi, dentry, &name);
+        /* If this is a direct mount request create a dummy name */
-        if (!len) {
+        if (IS_ROOT(dentry) && (sbi->type & AUTOFS_TYPE_DIRECT))
-                kfree(name);
+                len = sprintf(name, "%p", dentry);
-                return -ENOENT;
+        else {
+                len = autofs4_getpath(sbi, dentry, &name);
+                if (!len) {
+                        kfree(name);
+                        return -ENOENT;
+                }
        }
+        hash = full_name_hash(name, len);
        if (mutex_lock_interruptible(&sbi->wq_mutex)) {
                kfree(name);
@@ -190,7 +230,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                        break;
        }
-        if ( !wq ) {
+        if (!wq) {
                /* Can't wait for an expire if there's no mount */
                if (notify == NFY_NONE && !d_mountpoint(dentry)) {
                        kfree(name);
@@ -200,7 +240,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                /* Create a new wait queue */
                wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
-                if ( !wq ) {
+                if (!wq) {
                        kfree(name);
                        mutex_unlock(&sbi->wq_mutex);
                        return -ENOMEM;
@@ -212,12 +252,18 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                wq->next = sbi->queues;
                sbi->queues = wq;
                init_waitqueue_head(&wq->queue);
-                wq->hash = dentry->d_name.hash;
+                wq->hash = hash;
                wq->name = name;
                wq->len = len;
+                wq->dev = autofs4_get_dev(sbi);
+                wq->ino = autofs4_get_ino(sbi);
+                wq->uid = current->uid;
+                wq->gid = current->gid;
+                wq->pid = current->pid;
+                wq->tgid = current->tgid;
                wq->status = -EINTR; /* Status return if interrupted */
                atomic_set(&wq->wait_ctr, 2);
-                atomic_set(&wq->notified, 1);
+                atomic_set(&wq->notify, 1);
                mutex_unlock(&sbi->wq_mutex);
        } else {
                atomic_inc(&wq->wait_ctr);
@@ -227,9 +273,26 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                        (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify);
        }
-        if (notify != NFY_NONE && atomic_dec_and_test(&wq->notified)) {
+        if (notify != NFY_NONE && atomic_read(&wq->notify)) {
-                int type = (notify == NFY_MOUNT ?
+                int type;
-                        autofs_ptype_missing : autofs_ptype_expire_multi);
+                atomic_dec(&wq->notify);
+                if (sbi->version < 5) {
+                        if (notify == NFY_MOUNT)
+                                type = autofs_ptype_missing;
+                        else
+                                type = autofs_ptype_expire_multi;
+                } else {
+                        if (notify == NFY_MOUNT)
+                                type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
+                                        autofs_ptype_missing_direct :
+                                         autofs_ptype_missing_indirect;
+                        else
+                                type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
+                                        autofs_ptype_expire_direct :
+                                        autofs_ptype_expire_indirect;
+                }
                DPRINTK("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
                        (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify);
@@ -240,14 +303,14 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
        /* wq->name is NULL if and only if the lock is already released */
-        if ( sbi->catatonic ) {
+        if (sbi->catatonic) {
                /* We might have slept, so check again for catatonic mode */
                wq->status = -ENOENT;
                kfree(wq->name);
                wq->name = NULL;
        }
-        if ( wq->name ) {
+        if (wq->name) {
                /* Block all but "shutdown" signals while waiting */
                sigset_t oldset;
                unsigned long irqflags;
@@ -283,12 +346,12 @@ int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_tok
        struct autofs_wait_queue *wq, **wql;
        mutex_lock(&sbi->wq_mutex);
-        for ( wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next ) {
+        for (wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next) {
-                if ( wq->wait_queue_token == wait_queue_token )
+                if (wq->wait_queue_token == wait_queue_token)
                        break;
        }
-        if ( !wq ) {
+        if (!wq) {
                mutex_unlock(&sbi->wq_mutex);
                return -EINVAL;
        }
diff --git a/fs/bio.c b/fs/bio.c
index 73e664c01d30..eb8fbc53f2cd 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -30,7 +30,7 @@
 #define BIO_POOL_SIZE 256
-static kmem_cache_t *bio_slab;
+static kmem_cache_t *bio_slab __read_mostly;
 #define BIOVEC_NR_POOLS 6
@@ -39,7 +39,7 @@ static kmem_cache_t *bio_slab;
 * basically we just need to survive
 */
 #define BIO_SPLIT_ENTRIES 8     
-mempool_t *bio_split_pool;
+mempool_t *bio_split_pool __read_mostly;
 struct biovec_slab {
        int nr_vecs;
@@ -1125,16 +1125,6 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
        return bp;
 }
-static void *bio_pair_alloc(gfp_t gfp_flags, void *data)
-{
-        return kmalloc(sizeof(struct bio_pair), gfp_flags);
-}
-static void bio_pair_free(void *bp, void *data)
-{
-        kfree(bp);
-}
 /*
 * create memory pools for biovec's in a bio_set.
@@ -1151,8 +1141,7 @@ static int biovec_create_pools(struct bio_set *bs, int pool_entries, int scale)
                if (i >= scale)
                        pool_entries >>= 1;
-                *bvp = mempool_create(pool_entries, mempool_alloc_slab,
+                *bvp = mempool_create_slab_pool(pool_entries, bp->slab);
-                                        mempool_free_slab, bp->slab);
                if (!*bvp)
                        return -ENOMEM;
        }
@@ -1189,9 +1178,7 @@ struct bio_set *bioset_create(int bio_pool_size, int bvec_pool_size, int scale)
        if (!bs)
                return NULL;
-        bs->bio_pool = mempool_create(bio_pool_size, mempool_alloc_slab,
+        bs->bio_pool = mempool_create_slab_pool(bio_pool_size, bio_slab);
-                        mempool_free_slab, bio_slab);
        if (!bs->bio_pool)
                goto bad;
@@ -1254,8 +1241,8 @@ static int __init init_bio(void)
        if (!fs_bio_set)
                panic("bio: can't allocate bios\n");
-        bio_split_pool = mempool_create(BIO_SPLIT_ENTRIES,
+        bio_split_pool = mempool_create_kmalloc_pool(BIO_SPLIT_ENTRIES,
-                                bio_pair_alloc, bio_pair_free, NULL);
+                                                     sizeof(struct bio_pair));
        if (!bio_split_pool)
                panic("bio: can't create split pool\n");
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 573fc8e0b67a..17c76182f389 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -131,9 +131,10 @@ blkdev_get_block(struct inode *inode, sector_t iblock,
 static int
 blkdev_get_blocks(struct inode *inode, sector_t iblock,
-                unsigned long max_blocks, struct buffer_head *bh, int create)
+                struct buffer_head *bh, int create)
 {
        sector_t end_block = max_block(I_BDEV(inode));
+        unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
        if ((iblock + max_blocks) > end_block) {
                max_blocks = end_block - iblock;
@@ -234,7 +235,7 @@ static int block_fsync(struct file *filp, struct dentry *dentry, int datasync)
 */
 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
-static kmem_cache_t * bdev_cachep;
+static kmem_cache_t * bdev_cachep __read_mostly;
 static struct inode *bdev_alloc_inode(struct super_block *sb)
 {
@@ -265,6 +266,9 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
                mutex_init(&bdev->bd_mount_mutex);
                INIT_LIST_HEAD(&bdev->bd_inodes);
                INIT_LIST_HEAD(&bdev->bd_list);
+#ifdef CONFIG_SYSFS
+                INIT_LIST_HEAD(&bdev->bd_holder_list);
+#endif
                inode_init_once(&ei->vfs_inode);
        }
 }
@@ -308,7 +312,7 @@ static struct file_system_type bd_type = {
        .kill_sb        = kill_anon_super,
 };
-static struct vfsmount *bd_mnt;
+static struct vfsmount *bd_mnt __read_mostly;
 struct super_block *blockdev_superblock;
 void __init bdev_cache_init(void)
@@ -489,6 +493,300 @@ void bd_release(struct block_device *bdev)
 EXPORT_SYMBOL(bd_release);
+#ifdef CONFIG_SYSFS
+/*
+ * Functions for bd_claim_by_kobject / bd_release_from_kobject
+ *
+ *     If a kobject is passed to bd_claim_by_kobject()
+ *     and the kobject has a parent directory,
+ *     following symlinks are created:
+ *        o from the kobject to the claimed bdev
+ *        o from "holders" directory of the bdev to the parent of the kobject
+ *     bd_release_from_kobject() removes these symlinks.
+ *
+ *     Example:
+ *        If /dev/dm-0 maps to /dev/sda, kobject corresponding to
+ *        /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
+ *           /sys/block/dm-0/slaves/sda --> /sys/block/sda
+ *           /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
+ */
+static struct kobject *bdev_get_kobj(struct block_device *bdev)
+{
+        if (bdev->bd_contains != bdev)
+                return kobject_get(&bdev->bd_part->kobj);
+        else
+                return kobject_get(&bdev->bd_disk->kobj);
+}
+static struct kobject *bdev_get_holder(struct block_device *bdev)
+{
+        if (bdev->bd_contains != bdev)
+                return kobject_get(bdev->bd_part->holder_dir);
+        else
+                return kobject_get(bdev->bd_disk->holder_dir);
+}
+static void add_symlink(struct kobject *from, struct kobject *to)
+{
+        if (!from || !to)
+                return;
+        sysfs_create_link(from, to, kobject_name(to));
+}
+static void del_symlink(struct kobject *from, struct kobject *to)
+{
+        if (!from || !to)
+                return;
+        sysfs_remove_link(from, kobject_name(to));
+}
+/*
+ * 'struct bd_holder' contains pointers to kobjects symlinked by
+ * bd_claim_by_kobject.
+ * It's connected to bd_holder_list which is protected by bdev->bd_sem.
+ */
+struct bd_holder {
+        struct list_head list;  /* chain of holders of the bdev */
+        int count;              /* references from the holder */
+        struct kobject *sdir;   /* holder object, e.g. "/block/dm-0/slaves" */
+        struct kobject *hdev;   /* e.g. "/block/dm-0" */
+        struct kobject *hdir;   /* e.g. "/block/sda/holders" */
+        struct kobject *sdev;   /* e.g. "/block/sda" */
+};
+/*
+ * Get references of related kobjects at once.
+ * Returns 1 on success. 0 on failure.
+ *
+ * Should call bd_holder_release_dirs() after successful use.
+ */
+static int bd_holder_grab_dirs(struct block_device *bdev,
+                        struct bd_holder *bo)
+{
+        if (!bdev || !bo)
+                return 0;
+        bo->sdir = kobject_get(bo->sdir);
+        if (!bo->sdir)
+                return 0;
+        bo->hdev = kobject_get(bo->sdir->parent);
+        if (!bo->hdev)
+                goto fail_put_sdir;
+        bo->sdev = bdev_get_kobj(bdev);
+        if (!bo->sdev)
+                goto fail_put_hdev;
+        bo->hdir = bdev_get_holder(bdev);
+        if (!bo->hdir)
+                goto fail_put_sdev;
+        return 1;
+fail_put_sdev:
+        kobject_put(bo->sdev);
+fail_put_hdev:
+        kobject_put(bo->hdev);
+fail_put_sdir:
+        kobject_put(bo->sdir);
+        return 0;
+}
+/* Put references of related kobjects at once. */
+static void bd_holder_release_dirs(struct bd_holder *bo)
+{
+        kobject_put(bo->hdir);
+        kobject_put(bo->sdev);
+        kobject_put(bo->hdev);
+        kobject_put(bo->sdir);
+}
+static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
+{
+        struct bd_holder *bo;
+        bo = kzalloc(sizeof(*bo), GFP_KERNEL);
+        if (!bo)
+                return NULL;
+        bo->count = 1;
+        bo->sdir = kobj;
+        return bo;
+}
+static void free_bd_holder(struct bd_holder *bo)
+{
+        kfree(bo);
+}
+/**
+ * add_bd_holder - create sysfs symlinks for bd_claim() relationship
+ *
+ * @bdev:       block device to be bd_claimed
+ * @bo:         preallocated and initialized by alloc_bd_holder()
+ *
+ * If there is no matching entry with @bo in @bdev->bd_holder_list,
+ * add @bo to the list, create symlinks.
+ *
+ * Returns 1 if @bo was added to the list.
+ * Returns 0 if @bo wasn't used by any reason and should be freed.
+ */
+static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
+{
+        struct bd_holder *tmp;
+        if (!bo)
+                return 0;
+        list_for_each_entry(tmp, &bdev->bd_holder_list, list) {
+                if (tmp->sdir == bo->sdir) {
+                        tmp->count++;
+                        return 0;
+                }
+        }
+        if (!bd_holder_grab_dirs(bdev, bo))
+                return 0;
+        add_symlink(bo->sdir, bo->sdev);
+        add_symlink(bo->hdir, bo->hdev);
+        list_add_tail(&bo->list, &bdev->bd_holder_list);
+        return 1;
+}
+/**
+ * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
+ *
+ * @bdev:       block device to be bd_claimed
+ * @kobj:       holder's kobject
+ *
+ * If there is matching entry with @kobj in @bdev->bd_holder_list
+ * and no other bd_claim() from the same kobject,
+ * remove the struct bd_holder from the list, delete symlinks for it.
+ *
+ * Returns a pointer to the struct bd_holder when it's removed from the list
+ * and ready to be freed.
+ * Returns NULL if matching claim isn't found or there is other bd_claim()
+ * by the same kobject.
+ */
+static struct bd_holder *del_bd_holder(struct block_device *bdev,
+                                        struct kobject *kobj)
+{
+        struct bd_holder *bo;
+        list_for_each_entry(bo, &bdev->bd_holder_list, list) {
+                if (bo->sdir == kobj) {
+                        bo->count--;
+                        BUG_ON(bo->count < 0);
+                        if (!bo->count) {
+                                list_del(&bo->list);
+                                del_symlink(bo->sdir, bo->sdev);
+                                del_symlink(bo->hdir, bo->hdev);
+                                bd_holder_release_dirs(bo);
+                                return bo;
+                        }
+                        break;
+                }
+        }
+        return NULL;
+}
+/**
+ * bd_claim_by_kobject - bd_claim() with additional kobject signature
+ *
+ * @bdev:       block device to be claimed
+ * @holder:     holder's signature
+ * @kobj:       holder's kobject
+ *
+ * Do bd_claim() and if it succeeds, create sysfs symlinks between
+ * the bdev and the holder's kobject.
+ * Use bd_release_from_kobject() when relesing the claimed bdev.
+ *
+ * Returns 0 on success. (same as bd_claim())
+ * Returns errno on failure.
+ */
+static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
+                                struct kobject *kobj)
+{
+        int res;
+        struct bd_holder *bo;
+        if (!kobj)
+                return -EINVAL;
+        bo = alloc_bd_holder(kobj);
+        if (!bo)
+                return -ENOMEM;
+        mutex_lock(&bdev->bd_mutex);
+        res = bd_claim(bdev, holder);
+        if (res || !add_bd_holder(bdev, bo))
+                free_bd_holder(bo);
+        mutex_unlock(&bdev->bd_mutex);
+        return res;
+}
+/**
+ * bd_release_from_kobject - bd_release() with additional kobject signature
+ *
+ * @bdev:       block device to be released
+ * @kobj:       holder's kobject
+ *
+ * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
+ */
+static void bd_release_from_kobject(struct block_device *bdev,
+                                        struct kobject *kobj)
+{
+        struct bd_holder *bo;
+        if (!kobj)
+                return;
+        mutex_lock(&bdev->bd_mutex);
+        bd_release(bdev);
+        if ((bo = del_bd_holder(bdev, kobj)))
+                free_bd_holder(bo);
+        mutex_unlock(&bdev->bd_mutex);
+}
+/**
+ * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
+ *
+ * @bdev:       block device to be claimed
+ * @holder:     holder's signature
+ * @disk:       holder's gendisk
+ *
+ * Call bd_claim_by_kobject() with getting @disk->slave_dir.
+ */
+int bd_claim_by_disk(struct block_device *bdev, void *holder,
+                        struct gendisk *disk)
+{
+        return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
+}
+EXPORT_SYMBOL_GPL(bd_claim_by_disk);
+/**
+ * bd_release_from_disk - wrapper function for bd_release_from_kobject()
+ *
+ * @bdev:       block device to be claimed
+ * @disk:       holder's gendisk
+ *
+ * Call bd_release_from_kobject() and put @disk->slave_dir.
+ */
+void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
+{
+        bd_release_from_kobject(bdev, disk->slave_dir);
+        kobject_put(disk->slave_dir);
+}
+EXPORT_SYMBOL_GPL(bd_release_from_disk);
+#endif
 /*
 * Tries to open block device by device number.  Use it ONLY if you
 * really do not have anything better - i.e. when you are behind a
diff --git a/fs/buffer.c b/fs/buffer.c
index 3b3ab5281920..23f1f3a68077 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -426,8 +426,10 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)
        if (all_mapped) {
                printk("__find_get_block_slow() failed. "
                        "block=%llu, b_blocknr=%llu\n",
-                        (unsigned long long)block, (unsigned long long)bh->b_blocknr);
+                        (unsigned long long)block,
-                printk("b_state=0x%08lx, b_size=%u\n", bh->b_state, bh->b_size);
+                        (unsigned long long)bh->b_blocknr);
+                printk("b_state=0x%08lx, b_size=%zu\n",
+                        bh->b_state, bh->b_size);
                printk("device blocksize: %d\n", 1 << bd_inode->i_blkbits);
        }
 out_unlock:
@@ -491,7 +493,7 @@ static void free_more_memory(void)
        wakeup_pdflush(1024);
        yield();
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                zones = pgdat->node_zonelists[gfp_zone(GFP_NOFS)].zones;
                if (*zones)
                        try_to_free_pages(zones, GFP_NOFS);
@@ -796,8 +798,7 @@ void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
        if (!mapping->assoc_mapping) {
                mapping->assoc_mapping = buffer_mapping;
        } else {
-                if (mapping->assoc_mapping != buffer_mapping)
+                BUG_ON(mapping->assoc_mapping != buffer_mapping);
-                        BUG();
        }
        if (list_empty(&bh->b_assoc_buffers)) {
                spin_lock(&buffer_mapping->private_lock);
@@ -1114,8 +1115,7 @@ grow_dev_page(struct block_device *bdev, sector_t block,
        if (!page)
                return NULL;
-        if (!PageLocked(page))
+        BUG_ON(!PageLocked(page));
-                BUG();
        if (page_has_buffers(page)) {
                bh = page_buffers(page);
@@ -1522,8 +1522,7 @@ void set_bh_page(struct buffer_head *bh,
                struct page *page, unsigned long offset)
 {
        bh->b_page = page;
-        if (offset >= PAGE_SIZE)
+        BUG_ON(offset >= PAGE_SIZE);
-                BUG();
        if (PageHighMem(page))
                /*
                 * This catches illegal uses and preserves the offset:
@@ -1593,11 +1592,10 @@ EXPORT_SYMBOL(try_to_release_page);
 * point.  Because the caller is about to free (and possibly reuse) those
 * blocks on-disk.
 */
-int block_invalidatepage(struct page *page, unsigned long offset)
+void block_invalidatepage(struct page *page, unsigned long offset)
 {
        struct buffer_head *head, *bh, *next;
        unsigned int curr_off = 0;
-        int ret = 1;
        BUG_ON(!PageLocked(page));
        if (!page_has_buffers(page))
@@ -1624,19 +1622,18 @@ int block_invalidatepage(struct page *page, unsigned long offset)
         * so real IO is not possible anymore.
         */
        if (offset == 0)
-                ret = try_to_release_page(page, 0);
+                try_to_release_page(page, 0);
 out:
-        return ret;
+        return;
 }
 EXPORT_SYMBOL(block_invalidatepage);
-int do_invalidatepage(struct page *page, unsigned long offset)
+void do_invalidatepage(struct page *page, unsigned long offset)
 {
-        int (*invalidatepage)(struct page *, unsigned long);
+        void (*invalidatepage)(struct page *, unsigned long);
-        invalidatepage = page->mapping->a_ops->invalidatepage;
+        invalidatepage = page->mapping->a_ops->invalidatepage ? :
-        if (invalidatepage == NULL)
+                block_invalidatepage;
-                invalidatepage = block_invalidatepage;
+        (*invalidatepage)(page, offset);
-        return (*invalidatepage)(page, offset);
 }
 /*
@@ -1738,6 +1735,7 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
        sector_t block;
        sector_t last_block;
        struct buffer_head *bh, *head;
+        const unsigned blocksize = 1 << inode->i_blkbits;
        int nr_underway = 0;
        BUG_ON(!PageLocked(page));
@@ -1745,7 +1743,7 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
        last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
        if (!page_has_buffers(page)) {
-                create_empty_buffers(page, 1 << inode->i_blkbits,
+                create_empty_buffers(page, blocksize,
                                        (1 << BH_Dirty)|(1 << BH_Uptodate));
        }
@@ -1780,6 +1778,7 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
                        clear_buffer_dirty(bh);
                        set_buffer_uptodate(bh);
                } else if (!buffer_mapped(bh) && buffer_dirty(bh)) {
+                        WARN_ON(bh->b_size != blocksize);
                        err = get_block(inode, block, bh, 1);
                        if (err)
                                goto recover;
@@ -1933,6 +1932,7 @@ static int __block_prepare_write(struct inode *inode, struct page *page,
                if (buffer_new(bh))
                        clear_buffer_new(bh);
                if (!buffer_mapped(bh)) {
+                        WARN_ON(bh->b_size != blocksize);
                        err = get_block(inode, block, bh, 1);
                        if (err)
                                break;
@@ -2088,6 +2088,7 @@ int block_read_full_page(struct page *page, get_block_t *get_block)
                        fully_mapped = 0;
                        if (iblock < lblock) {
+                                WARN_ON(bh->b_size != blocksize);
                                err = get_block(inode, iblock, bh, 0);
                                if (err)
                                        SetPageError(page);
@@ -2409,6 +2410,7 @@ int nobh_prepare_write(struct page *page, unsigned from, unsigned to,
                create = 1;
                if (block_start >= to)
                        create = 0;
+                map_bh.b_size = blocksize;
                ret = get_block(inode, block_in_file + block_in_page,
                                        &map_bh, create);
                if (ret)
@@ -2669,6 +2671,7 @@ int block_truncate_page(struct address_space *mapping,
        err = 0;
        if (!buffer_mapped(bh)) {
+                WARN_ON(bh->b_size != blocksize);
                err = get_block(inode, iblock, bh, 0);
                if (err)
                        goto unlock;
@@ -2755,6 +2758,7 @@ sector_t generic_block_bmap(struct address_space *mapping, sector_t block,
        struct inode *inode = mapping->host;
        tmp.b_state = 0;
        tmp.b_blocknr = 0;
+        tmp.b_size = 1 << inode->i_blkbits;
        get_block(inode, block, &tmp, 0);
        return tmp.b_blocknr;
 }
@@ -3007,7 +3011,7 @@ out:
 }
 EXPORT_SYMBOL(try_to_free_buffers);
-int block_sync_page(struct page *page)
+void block_sync_page(struct page *page)
 {
        struct address_space *mapping;
@@ -3015,7 +3019,6 @@ int block_sync_page(struct page *page)
        mapping = page_mapping(page);
        if (mapping)
                blk_run_backing_dev(mapping->backing_dev_info, page);
-        return 0;
 }
 /*
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 221b3334b737..6b99b51d6694 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -738,10 +738,8 @@ cifs_init_request_bufs(void)
                cERROR(1,("cifs_min_rcv set to maximum (64)"));
        }
-        cifs_req_poolp = mempool_create(cifs_min_rcv,
+        cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
-                                        mempool_alloc_slab,
+                                                  cifs_req_cachep);
-                                        mempool_free_slab,
-                                        cifs_req_cachep);
        if(cifs_req_poolp == NULL) {
                kmem_cache_destroy(cifs_req_cachep);
@@ -771,10 +769,8 @@ cifs_init_request_bufs(void)
                cFYI(1,("cifs_min_small set to maximum (256)"));
        }
-        cifs_sm_req_poolp = mempool_create(cifs_min_small,
+        cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
-                                mempool_alloc_slab,
+                                                     cifs_sm_req_cachep);
-                                mempool_free_slab,
-                                cifs_sm_req_cachep);
        if(cifs_sm_req_poolp == NULL) {
                mempool_destroy(cifs_req_poolp);
@@ -808,10 +804,8 @@ cifs_init_mids(void)
        if (cifs_mid_cachep == NULL)
                return -ENOMEM;
-        cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
+        /* 3 is a reasonable minimum number of simultaneous operations */
-                                        mempool_alloc_slab,
+        cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
-                                        mempool_free_slab,
-                                        cifs_mid_cachep);
        if(cifs_mid_poolp == NULL) {
                kmem_cache_destroy(cifs_mid_cachep);
                return -ENOMEM;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 165d67426381..fb49aef1f2ec 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1339,7 +1339,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
        return rc;
 }
-/* static int cifs_sync_page(struct page *page)
+/* static void cifs_sync_page(struct page *page)
 {
        struct address_space *mapping;
        struct inode *inode;
@@ -1353,16 +1353,18 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
                return 0;
        inode = mapping->host;
        if (!inode)
-                return 0; */
+                return; */
 /*      fill in rpages then 
        result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
 /*      cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
+#if 0
        if (rc < 0)
                return rc;
        return 0;
+#endif
 } */
 /*
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index ff93a9f81d1c..598eec9778f6 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -163,9 +163,9 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                if (num_of_bytes < end_of_file)
                        cFYI(1, ("allocation size less than end of file"));
-                cFYI(1,
+                cFYI(1, ("Size %ld and blocks %llu",
-                     ("Size %ld and blocks %ld",
+                        (unsigned long) inode->i_size,
-                      (unsigned long) inode->i_size, inode->i_blocks));
+                        (unsigned long long)inode->i_blocks));
                if (S_ISREG(inode->i_mode)) {
                        cFYI(1, ("File inode"));
                        inode->i_op = &cifs_file_inode_ops;
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index edb3b6eb34bc..488bd0d81dcf 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -197,10 +197,10 @@ static void fill_in_inode(struct inode *tmp_inode,
        if (allocation_size < end_of_file)
                cFYI(1, ("May be sparse file, allocation less than file size"));
-        cFYI(1,
+        cFYI(1, ("File Size %ld and blocks %llu and blocksize %ld",
-             ("File Size %ld and blocks %ld and blocksize %ld",
+                (unsigned long)tmp_inode->i_size,
-              (unsigned long)tmp_inode->i_size, tmp_inode->i_blocks,
+                (unsigned long long)tmp_inode->i_blocks,
-              tmp_inode->i_blksize));
+                tmp_inode->i_blksize));
        if (S_ISREG(tmp_inode->i_mode)) {
                cFYI(1, ("File inode"));
                tmp_inode->i_op = &cifs_file_inode_ops;
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 8ad52f5bf255..acc1b2c10a86 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -22,6 +22,7 @@
 #include <linux/cramfs_fs_sb.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
+#include <linux/mutex.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
@@ -31,7 +32,7 @@ static struct inode_operations cramfs_dir_inode_operations;
 static struct file_operations cramfs_directory_operations;
 static struct address_space_operations cramfs_aops;
-static DECLARE_MUTEX(read_mutex);
+static DEFINE_MUTEX(read_mutex);
 /* These two macros may change in future, to provide better st_ino
@@ -250,20 +251,20 @@ static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
        memset(sbi, 0, sizeof(struct cramfs_sb_info));
        /* Invalidate the read buffers on mount: think disk change.. */
-        down(&read_mutex);
+        mutex_lock(&read_mutex);
        for (i = 0; i < READ_BUFFERS; i++)
                buffer_blocknr[i] = -1;
        /* Read the first block and get the superblock from it */
        memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super));
-        up(&read_mutex);
+        mutex_unlock(&read_mutex);
        /* Do sanity checks on the superblock */
        if (super.magic != CRAMFS_MAGIC) {
                /* check at 512 byte offset */
-                down(&read_mutex);
+                mutex_lock(&read_mutex);
                memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super));
-                up(&read_mutex);
+                mutex_unlock(&read_mutex);
                if (super.magic != CRAMFS_MAGIC) {
                        if (!silent)
                                printk(KERN_ERR "cramfs: wrong magic\n");
@@ -366,7 +367,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                mode_t mode;
                int namelen, error;
-                down(&read_mutex);
+                mutex_lock(&read_mutex);
                de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+256);
                name = (char *)(de+1);
@@ -379,7 +380,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                memcpy(buf, name, namelen);
                ino = CRAMINO(de);
                mode = de->mode;
-                up(&read_mutex);
+                mutex_unlock(&read_mutex);
                nextoffset = offset + sizeof(*de) + namelen;
                for (;;) {
                        if (!namelen) {
@@ -410,7 +411,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
        unsigned int offset = 0;
        int sorted;
-        down(&read_mutex);
+        mutex_lock(&read_mutex);
        sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
        while (offset < dir->i_size) {
                struct cramfs_inode *de;
@@ -433,7 +434,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
                for (;;) {
                        if (!namelen) {
-                                up(&read_mutex);
+                                mutex_unlock(&read_mutex);
                                return ERR_PTR(-EIO);
                        }
                        if (name[namelen-1])
@@ -447,7 +448,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
                        continue;
                if (!retval) {
                        struct cramfs_inode entry = *de;
-                        up(&read_mutex);
+                        mutex_unlock(&read_mutex);
                        d_add(dentry, get_cramfs_inode(dir->i_sb, &entry));
                        return NULL;
                }
@@ -455,7 +456,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
                if (sorted)
                        break;
        }
-        up(&read_mutex);
+        mutex_unlock(&read_mutex);
        d_add(dentry, NULL);
        return NULL;
 }
@@ -474,21 +475,21 @@ static int cramfs_readpage(struct file *file, struct page * page)
                u32 start_offset, compr_len;
                start_offset = OFFSET(inode) + maxblock*4;
-                down(&read_mutex);
+                mutex_lock(&read_mutex);
                if (page->index)
                        start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 4);
                compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - start_offset);
-                up(&read_mutex);
+                mutex_unlock(&read_mutex);
                pgdata = kmap(page);
                if (compr_len == 0)
                        ; /* hole */
                else {
-                        down(&read_mutex);
+                        mutex_lock(&read_mutex);
                        bytes_filled = cramfs_uncompress_block(pgdata,
                                 PAGE_CACHE_SIZE,
                                 cramfs_read(sb, start_offset, compr_len),
                                 compr_len);
-                        up(&read_mutex);
+                        mutex_unlock(&read_mutex);
                }
        } else
                pgdata = kmap(page);
diff --git a/fs/dcache.c b/fs/dcache.c
index 939584648504..19458d399502 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -34,9 +34,8 @@
 #include <linux/swap.h>
 #include <linux/bootmem.h>
-/* #define DCACHE_DEBUG 1 */
-int sysctl_vfs_cache_pressure = 100;
+int sysctl_vfs_cache_pressure __read_mostly = 100;
 EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure);
 __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lock);
@@ -44,7 +43,7 @@ static seqlock_t rename_lock __cacheline_aligned_in_smp = SEQLOCK_UNLOCKED;
 EXPORT_SYMBOL(dcache_lock);
-static kmem_cache_t *dentry_cache; 
+static kmem_cache_t *dentry_cache __read_mostly;
 #define DNAME_INLINE_LEN (sizeof(struct dentry)-offsetof(struct dentry,d_iname))
@@ -59,9 +58,9 @@ static kmem_cache_t *dentry_cache;
 #define D_HASHBITS     d_hash_shift
 #define D_HASHMASK     d_hash_mask
-static unsigned int d_hash_mask;
+static unsigned int d_hash_mask __read_mostly;
-static unsigned int d_hash_shift;
+static unsigned int d_hash_shift __read_mostly;
-static struct hlist_head *dentry_hashtable;
+static struct hlist_head *dentry_hashtable __read_mostly;
 static LIST_HEAD(dentry_unused);
 /* Statistics gathering. */
@@ -603,10 +602,6 @@ resume:
                 */
                if (!list_empty(&dentry->d_subdirs)) {
                        this_parent = dentry;
-#ifdef DCACHE_DEBUG
-printk(KERN_DEBUG "select_parent: descending to %s/%s, found=%d\n",
-dentry->d_parent->d_name.name, dentry->d_name.name, found);
-#endif
                        goto repeat;
                }
        }
@@ -616,10 +611,6 @@ dentry->d_parent->d_name.name, dentry->d_name.name, found);
        if (this_parent != parent) {
                next = this_parent->d_u.d_child.next;
                this_parent = this_parent->d_parent;
-#ifdef DCACHE_DEBUG
-printk(KERN_DEBUG "select_parent: ascending to %s/%s, found=%d\n",
-this_parent->d_parent->d_name.name, this_parent->d_name.name, found);
-#endif
                goto resume;
        }
 out:
@@ -798,7 +789,7 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 
 void d_instantiate(struct dentry *entry, struct inode * inode)
 {
-        if (!list_empty(&entry->d_alias)) BUG();
+        BUG_ON(!list_empty(&entry->d_alias));
        spin_lock(&dcache_lock);
        if (inode)
                list_add(&entry->d_alias, &inode->i_dentry);
@@ -1719,10 +1710,10 @@ static void __init dcache_init(unsigned long mempages)
 }
 /* SLAB cache for __getname() consumers */
-kmem_cache_t *names_cachep;
+kmem_cache_t *names_cachep __read_mostly;
 /* SLAB cache for file structures */
-kmem_cache_t *filp_cachep;
+kmem_cache_t *filp_cachep __read_mostly;
 EXPORT_SYMBOL(d_genocide);
diff --git a/fs/dcookies.c b/fs/dcookies.c
index f8274a8f83bd..8749339bf4f6 100644
--- a/fs/dcookies.c
+++ b/fs/dcookies.c
@@ -23,6 +23,7 @@
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/dcookies.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 /* The dcookies are allocated from a kmem_cache and
@@ -36,10 +37,10 @@ struct dcookie_struct {
 };
 static LIST_HEAD(dcookie_users);
-static DECLARE_MUTEX(dcookie_sem);
+static DEFINE_MUTEX(dcookie_mutex);
-static kmem_cache_t * dcookie_cache;
+static kmem_cache_t *dcookie_cache __read_mostly;
-static struct list_head * dcookie_hashtable;
+static struct list_head *dcookie_hashtable __read_mostly;
-static size_t hash_size;
+static size_t hash_size __read_mostly;
 static inline int is_live(void)
 {
@@ -114,7 +115,7 @@ int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
        int err = 0;
        struct dcookie_struct * dcs;
-        down(&dcookie_sem);
+        mutex_lock(&dcookie_mutex);
        if (!is_live()) {
                err = -EINVAL;
@@ -134,7 +135,7 @@ int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
        *cookie = dcookie_value(dcs);
 out:
-        up(&dcookie_sem);
+        mutex_unlock(&dcookie_mutex);
        return err;
 }
@@ -157,7 +158,7 @@ asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
-        down(&dcookie_sem);
+        mutex_lock(&dcookie_mutex);
        if (!is_live()) {
                err = -EINVAL;
@@ -192,7 +193,7 @@ asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
 out_free:
        kfree(kbuf);
 out:
-        up(&dcookie_sem);
+        mutex_unlock(&dcookie_mutex);
        return err;
 }
@@ -290,7 +291,7 @@ struct dcookie_user * dcookie_register(void)
 {
        struct dcookie_user * user;
-        down(&dcookie_sem);
+        mutex_lock(&dcookie_mutex);
        user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
        if (!user)
@@ -302,7 +303,7 @@ struct dcookie_user * dcookie_register(void)
        list_add(&user->next, &dcookie_users);
 out:
-        up(&dcookie_sem);
+        mutex_unlock(&dcookie_mutex);
        return user;
 out_free:
        kfree(user);
@@ -313,7 +314,7 @@ out_free:
 void dcookie_unregister(struct dcookie_user * user)
 {
-        down(&dcookie_sem);
+        mutex_lock(&dcookie_mutex);
        list_del(&user->next);
        kfree(user);
@@ -321,7 +322,7 @@ void dcookie_unregister(struct dcookie_user * user)
        if (!is_live())
                dcookie_exit();
-        up(&dcookie_sem);
+        mutex_unlock(&dcookie_mutex);
 }
 EXPORT_SYMBOL_GPL(dcookie_register);
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 235ed8d1f11e..9d1d2aa73e42 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -86,12 +86,12 @@ struct dio {
        unsigned first_block_in_page;   /* doesn't change, Used only once */
        int boundary;                   /* prev block is at a boundary */
        int reap_counter;               /* rate limit reaping */
-        get_blocks_t *get_blocks;       /* block mapping function */
+        get_block_t *get_block;         /* block mapping function */
        dio_iodone_t *end_io;           /* IO completion function */
        sector_t final_block_in_bio;    /* current final block in bio + 1 */
        sector_t next_block_for_io;     /* next block to be put under IO,
                                           in dio_blocks units */
-        struct buffer_head map_bh;      /* last get_blocks() result */
+        struct buffer_head map_bh;      /* last get_block() result */
        /*
         * Deferred addition of a page to the dio.  These variables are
@@ -211,9 +211,9 @@ static struct page *dio_get_page(struct dio *dio)
 /*
 * Called when all DIO BIO I/O has been completed - let the filesystem
- * know, if it registered an interest earlier via get_blocks.  Pass the
+ * know, if it registered an interest earlier via get_block.  Pass the
 * private field of the map buffer_head so that filesystems can use it
- * to hold additional state between get_blocks calls and dio_complete.
+ * to hold additional state between get_block calls and dio_complete.
 */
 static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)
 {
@@ -493,7 +493,7 @@ static int dio_bio_reap(struct dio *dio)
 * The fs is allowed to map lots of blocks at once.  If it wants to do that,
 * it uses the passed inode-relative block number as the file offset, as usual.
 *
- * get_blocks() is passed the number of i_blkbits-sized blocks which direct_io
+ * get_block() is passed the number of i_blkbits-sized blocks which direct_io
 * has remaining to do.  The fs should not map more than this number of blocks.
 *
 * If the fs has mapped a lot of blocks, it should populate bh->b_size to
@@ -506,7 +506,7 @@ static int dio_bio_reap(struct dio *dio)
 * In the case of filesystem holes: the fs may return an arbitrarily-large
 * hole by returning an appropriate value in b_size and by clearing
 * buffer_mapped().  However the direct-io code will only process holes one
- * block at a time - it will repeatedly call get_blocks() as it walks the hole.
+ * block at a time - it will repeatedly call get_block() as it walks the hole.
 */
 static int get_more_blocks(struct dio *dio)
 {
@@ -548,7 +548,8 @@ static int get_more_blocks(struct dio *dio)
                 * at a higher level for inside-i_size block-instantiating
                 * writes.
                 */
-                ret = (*dio->get_blocks)(dio->inode, fs_startblk, fs_count,
+                map_bh->b_size = fs_count << dio->blkbits;
+                ret = (*dio->get_block)(dio->inode, fs_startblk,
                                                map_bh, create);
        }
        return ret;
@@ -783,11 +784,11 @@ static void dio_zero_block(struct dio *dio, int end)
 * happily perform page-sized but 512-byte aligned IOs.  It is important that
 * blockdev IO be able to have fine alignment and large sizes.
 *
- * So what we do is to permit the ->get_blocks function to populate bh.b_size
+ * So what we do is to permit the ->get_block function to populate bh.b_size
 * with the size of IO which is permitted at this offset and this i_blkbits.
 *
 * For best results, the blockdev should be set up with 512-byte i_blkbits and
- * it should set b_size to PAGE_SIZE or more inside get_blocks().  This gives
+ * it should set b_size to PAGE_SIZE or more inside get_block().  This gives
 * fine alignment but still allows this function to work in PAGE_SIZE units.
 */
 static int do_direct_IO(struct dio *dio)
@@ -947,7 +948,7 @@ out:
 static ssize_t
 direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode, 
        const struct iovec *iov, loff_t offset, unsigned long nr_segs, 
-        unsigned blkbits, get_blocks_t get_blocks, dio_iodone_t end_io,
+        unsigned blkbits, get_block_t get_block, dio_iodone_t end_io,
        struct dio *dio)
 {
        unsigned long user_addr; 
@@ -969,7 +970,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
        dio->boundary = 0;
        dio->reap_counter = 0;
-        dio->get_blocks = get_blocks;
+        dio->get_block = get_block;
        dio->end_io = end_io;
        dio->map_bh.b_private = NULL;
        dio->final_block_in_bio = -1;
@@ -1177,7 +1178,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
 ssize_t
 __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
        struct block_device *bdev, const struct iovec *iov, loff_t offset, 
-        unsigned long nr_segs, get_blocks_t get_blocks, dio_iodone_t end_io,
+        unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
        int dio_lock_type)
 {
        int seg;
@@ -1273,7 +1274,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
                (end > i_size_read(inode)));
        retval = direct_io_worker(rw, iocb, inode, iov, offset,
-                                nr_segs, blkbits, get_blocks, end_io, dio);
+                                nr_segs, blkbits, get_block, end_io, dio);
        if (rw == READ && dio_lock_type == DIO_LOCKING)
                release_i_mutex = 0;
diff --git a/fs/dnotify.c b/fs/dnotify.c
index f3b540dd5d11..f932591df5a4 100644
--- a/fs/dnotify.c
+++ b/fs/dnotify.c
@@ -21,9 +21,9 @@
 #include <linux/spinlock.h>
 #include <linux/slab.h>
-int dir_notify_enable = 1;
+int dir_notify_enable __read_mostly = 1;
-static kmem_cache_t *dn_cache;
+static kmem_cache_t *dn_cache __read_mostly;
 static void redo_inode_mask(struct inode *inode)
 {
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index a0f682cdd03e..e067a06c6464 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -281,13 +281,13 @@ static struct mutex epmutex;
 static struct poll_safewake psw;
 /* Slab cache used to allocate "struct epitem" */
-static kmem_cache_t *epi_cache;
+static kmem_cache_t *epi_cache __read_mostly;
 /* Slab cache used to allocate "struct eppoll_entry" */
-static kmem_cache_t *pwq_cache;
+static kmem_cache_t *pwq_cache __read_mostly;
 /* Virtual fs used to allocate inodes for eventpoll files */
-static struct vfsmount *eventpoll_mnt;
+static struct vfsmount *eventpoll_mnt __read_mostly;
 /* File callbacks that implement the eventpoll file behaviour */
 static struct file_operations eventpoll_fops = {
diff --git a/fs/exec.c b/fs/exec.c
index 995cba3c62b8..c7397c46ad6d 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -632,7 +632,7 @@ static int de_thread(struct task_struct *tsk)
                 * synchronize with any firing (by calling del_timer_sync)
                 * before we can safely let the old group leader die.
                 */
-                sig->real_timer.data = current;
+                sig->tsk = current;
                spin_unlock_irq(lock);
                if (hrtimer_cancel(&sig->real_timer))
                        hrtimer_restart(&sig->real_timer);
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index b3dbd716cd3a..0165388c425c 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -416,8 +416,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
        lock_page(page);
        err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
-        if (err)
+        BUG_ON(err);
-                BUG();
        de->inode = cpu_to_le32(inode->i_ino);
        ext2_set_de_type (de, inode);
        err = ext2_commit_chunk(page, from, to);
@@ -554,8 +553,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
                from = (char*)pde - (char*)page_address(page);
        lock_page(page);
        err = mapping->a_ops->prepare_write(NULL, page, from, to);
-        if (err)
+        BUG_ON(err);
-                BUG();
        if (pde)
                pde->rec_len = cpu_to_le16(to-from);
        dir->inode = 0;
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index a717837f272e..04af9c45dce2 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -667,18 +667,6 @@ static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
        return generic_block_bmap(mapping,block,ext2_get_block);
 }
-static int
-ext2_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,
-                        struct buffer_head *bh_result, int create)
-{
-        int ret;
-        ret = ext2_get_block(inode, iblock, bh_result, create);
-        if (ret == 0)
-                bh_result->b_size = (1 << inode->i_blkbits);
-        return ret;
-}
 static ssize_t
 ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
                        loff_t offset, unsigned long nr_segs)
@@ -687,7 +675,7 @@ ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
        struct inode *inode = file->f_mapping->host;
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                offset, nr_segs, ext2_get_blocks, NULL);
+                                offset, nr_segs, ext2_get_block, NULL);
 }
 static int
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index 46623f77666b..77927d6938f6 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -653,9 +653,11 @@ claim_block(spinlock_t *lock, int block, struct buffer_head *bh)
 */
 static int
 ext3_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
-        struct buffer_head *bitmap_bh, int goal, struct ext3_reserve_window *my_rsv)
+                        struct buffer_head *bitmap_bh, int goal,
+                        unsigned long *count, struct ext3_reserve_window *my_rsv)
 {
        int group_first_block, start, end;
+        unsigned long num = 0;
        /* we do allocation within the reservation window if we have a window */
        if (my_rsv) {
@@ -713,8 +715,18 @@ repeat:
                        goto fail_access;
                goto repeat;
        }
-        return goal;
+        num++;
+        goal++;
+        while (num < *count && goal < end
+                && ext3_test_allocatable(goal, bitmap_bh)
+                && claim_block(sb_bgl_lock(EXT3_SB(sb), group), goal, bitmap_bh)) {
+                num++;
+                goal++;
+        }
+        *count = num;
+        return goal - num;
 fail_access:
+        *count = num;
        return -1;
 }
@@ -999,6 +1011,31 @@ retry:
        goto retry;
 }
+static void try_to_extend_reservation(struct ext3_reserve_window_node *my_rsv,
+                        struct super_block *sb, int size)
+{
+        struct ext3_reserve_window_node *next_rsv;
+        struct rb_node *next;
+        spinlock_t *rsv_lock = &EXT3_SB(sb)->s_rsv_window_lock;
+        if (!spin_trylock(rsv_lock))
+                return;
+        next = rb_next(&my_rsv->rsv_node);
+        if (!next)
+                my_rsv->rsv_end += size;
+        else {
+                next_rsv = list_entry(next, struct ext3_reserve_window_node, rsv_node);
+                if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
+                        my_rsv->rsv_end += size;
+                else
+                        my_rsv->rsv_end = next_rsv->rsv_start - 1;
+        }
+        spin_unlock(rsv_lock);
+}
 /*
 * This is the main function used to allocate a new block and its reservation
 * window.
@@ -1024,11 +1061,12 @@ static int
 ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
                        unsigned int group, struct buffer_head *bitmap_bh,
                        int goal, struct ext3_reserve_window_node * my_rsv,
-                        int *errp)
+                        unsigned long *count, int *errp)
 {
        unsigned long group_first_block;
        int ret = 0;
        int fatal;
+        unsigned long num = *count;
        *errp = 0;
@@ -1051,7 +1089,8 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
         * or last attempt to allocate a block with reservation turned on failed
         */
        if (my_rsv == NULL ) {
-                ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh, goal, NULL);
+                ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh,
+                                                goal, count, NULL);
                goto out;
        }
        /*
@@ -1081,6 +1120,8 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
        while (1) {
                if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
                        !goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb)) {
+                        if (my_rsv->rsv_goal_size < *count)
+                                my_rsv->rsv_goal_size = *count;
                        ret = alloc_new_reservation(my_rsv, goal, sb,
                                                        group, bitmap_bh);
                        if (ret < 0)
@@ -1088,16 +1129,21 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
                        if (!goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb))
                                goal = -1;
-                }
+                } else if (goal > 0 && (my_rsv->rsv_end-goal+1) < *count)
+                        try_to_extend_reservation(my_rsv, sb,
+                                        *count-my_rsv->rsv_end + goal - 1);
                if ((my_rsv->rsv_start >= group_first_block + EXT3_BLOCKS_PER_GROUP(sb))
                    || (my_rsv->rsv_end < group_first_block))
                        BUG();
                ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh, goal,
-                                           &my_rsv->rsv_window);
+                                           &num, &my_rsv->rsv_window);
                if (ret >= 0) {
-                        my_rsv->rsv_alloc_hit++;
+                        my_rsv->rsv_alloc_hit += num;
+                        *count = num;
                        break;                          /* succeed */
                }
+                num = *count;
        }
 out:
        if (ret >= 0) {
@@ -1154,8 +1200,8 @@ int ext3_should_retry_alloc(struct super_block *sb, int *retries)
 * bitmap, and then for any free bit if that fails.
 * This function also updates quota and i_blocks field.
 */
-int ext3_new_block(handle_t *handle, struct inode *inode,
+int ext3_new_blocks(handle_t *handle, struct inode *inode,
-                        unsigned long goal, int *errp)
+                        unsigned long goal, unsigned long *count, int *errp)
 {
        struct buffer_head *bitmap_bh = NULL;
        struct buffer_head *gdp_bh;
@@ -1178,6 +1224,7 @@ int ext3_new_block(handle_t *handle, struct inode *inode,
        static int goal_hits, goal_attempts;
 #endif
        unsigned long ngroups;
+        unsigned long num = *count;
        *errp = -ENOSPC;
        sb = inode->i_sb;
@@ -1189,7 +1236,7 @@ int ext3_new_block(handle_t *handle, struct inode *inode,
        /*
         * Check quota for allocation of this block.
         */
-        if (DQUOT_ALLOC_BLOCK(inode, 1)) {
+        if (DQUOT_ALLOC_BLOCK(inode, num)) {
                *errp = -EDQUOT;
                return 0;
        }
@@ -1244,7 +1291,7 @@ retry:
                if (!bitmap_bh)
                        goto io_error;
                ret_block = ext3_try_to_allocate_with_rsv(sb, handle, group_no,
-                                        bitmap_bh, ret_block, my_rsv, &fatal);
+                                        bitmap_bh, ret_block, my_rsv, &num, &fatal);
                if (fatal)
                        goto out;
                if (ret_block >= 0)
@@ -1281,7 +1328,7 @@ retry:
                if (!bitmap_bh)
                        goto io_error;
                ret_block = ext3_try_to_allocate_with_rsv(sb, handle, group_no,
-                                        bitmap_bh, -1, my_rsv, &fatal);
+                                        bitmap_bh, -1, my_rsv, &num, &fatal);
                if (fatal)
                        goto out;
                if (ret_block >= 0) 
@@ -1316,13 +1363,15 @@ allocated:
        target_block = ret_block + group_no * EXT3_BLOCKS_PER_GROUP(sb)
                                + le32_to_cpu(es->s_first_data_block);
-        if (target_block == le32_to_cpu(gdp->bg_block_bitmap) ||
+        if (in_range(le32_to_cpu(gdp->bg_block_bitmap), target_block, num) ||
-            target_block == le32_to_cpu(gdp->bg_inode_bitmap) ||
+            in_range(le32_to_cpu(gdp->bg_inode_bitmap), target_block, num) ||
            in_range(target_block, le32_to_cpu(gdp->bg_inode_table),
+                      EXT3_SB(sb)->s_itb_per_group) ||
+            in_range(target_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
                      EXT3_SB(sb)->s_itb_per_group))
                ext3_error(sb, "ext3_new_block",
                            "Allocating block in system zone - "
-                            "block = %u", target_block);
+                            "blocks from %u, length %lu", target_block, num);
        performed_allocation = 1;
@@ -1341,10 +1390,14 @@ allocated:
        jbd_lock_bh_state(bitmap_bh);
        spin_lock(sb_bgl_lock(sbi, group_no));
        if (buffer_jbd(bitmap_bh) && bh2jh(bitmap_bh)->b_committed_data) {
-                if (ext3_test_bit(ret_block,
+                int i;
-                                bh2jh(bitmap_bh)->b_committed_data)) {
-                        printk("%s: block was unexpectedly set in "
+                for (i = 0; i < num; i++) {
-                                "b_committed_data\n", __FUNCTION__);
+                        if (ext3_test_bit(ret_block,
+                                        bh2jh(bitmap_bh)->b_committed_data)) {
+                                printk("%s: block was unexpectedly set in "
+                                        "b_committed_data\n", __FUNCTION__);
+                        }
                }
        }
        ext3_debug("found bit %d\n", ret_block);
@@ -1355,7 +1408,7 @@ allocated:
        /* ret_block was blockgroup-relative.  Now it becomes fs-relative */
        ret_block = target_block;
-        if (ret_block >= le32_to_cpu(es->s_blocks_count)) {
+        if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
                ext3_error(sb, "ext3_new_block",
                            "block(%d) >= blocks count(%d) - "
                            "block_group = %d, es == %p ", ret_block,
@@ -1373,9 +1426,9 @@ allocated:
        spin_lock(sb_bgl_lock(sbi, group_no));
        gdp->bg_free_blocks_count =
-                        cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) - 1);
+                        cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) - num);
        spin_unlock(sb_bgl_lock(sbi, group_no));
-        percpu_counter_mod(&sbi->s_freeblocks_counter, -1);
+        percpu_counter_mod(&sbi->s_freeblocks_counter, -num);
        BUFFER_TRACE(gdp_bh, "journal_dirty_metadata for group descriptor");
        err = ext3_journal_dirty_metadata(handle, gdp_bh);
@@ -1388,6 +1441,8 @@ allocated:
        *errp = 0;
        brelse(bitmap_bh);
+        DQUOT_FREE_BLOCK(inode, *count-num);
+        *count = num;
        return ret_block;
 io_error:
@@ -1401,11 +1456,19 @@ out:
         * Undo the block allocation
         */
        if (!performed_allocation)
-                DQUOT_FREE_BLOCK(inode, 1);
+                DQUOT_FREE_BLOCK(inode, *count);
        brelse(bitmap_bh);
        return 0;
 }
+int ext3_new_block(handle_t *handle, struct inode *inode,
+                        unsigned long goal, int *errp)
+{
+        unsigned long count = 1;
+        return ext3_new_blocks(handle, inode, goal, &count, errp);
+}
 unsigned long ext3_count_free_blocks(struct super_block *sb)
 {
        unsigned long desc_count;
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 773459164bb2..38bd3f6ec147 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -131,8 +131,9 @@ static int ext3_readdir(struct file * filp,
                struct buffer_head *bh = NULL;
                map_bh.b_state = 0;
-                err = ext3_get_block_handle(NULL, inode, blk, &map_bh, 0, 0);
+                err = ext3_get_blocks_handle(NULL, inode, blk, 1,
-                if (!err) {
+                                                &map_bh, 0, 0);
+                if (err > 0) {
                        page_cache_readahead(sb->s_bdev->bd_inode->i_mapping,
                                &filp->f_ra,
                                filp,
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 2c361377e0a5..48ae0339af17 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -44,16 +44,16 @@ static int ext3_writepage_trans_blocks(struct inode *inode);
 /*
 * Test whether an inode is a fast symlink.
 */
-static inline int ext3_inode_is_fast_symlink(struct inode *inode)
+static int ext3_inode_is_fast_symlink(struct inode *inode)
 {
        int ea_blocks = EXT3_I(inode)->i_file_acl ?
                (inode->i_sb->s_blocksize >> 9) : 0;
-        return (S_ISLNK(inode->i_mode) &&
+        return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
-                inode->i_blocks - ea_blocks == 0);
 }
-/* The ext3 forget function must perform a revoke if we are freeing data
+/*
+ * The ext3 forget function must perform a revoke if we are freeing data
 * which has been journaled.  Metadata (eg. indirect blocks) must be
 * revoked in all cases. 
 *
@@ -61,10 +61,8 @@ static inline int ext3_inode_is_fast_symlink(struct inode *inode)
 * but there may still be a record of it in the journal, and that record
 * still needs to be revoked.
 */
+int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
-int ext3_forget(handle_t *handle, int is_metadata,
+                        struct buffer_head *bh, int blocknr)
-                       struct inode *inode, struct buffer_head *bh,
-                       int blocknr)
 {
        int err;
@@ -104,10 +102,9 @@ int ext3_forget(handle_t *handle, int is_metadata,
 }
 /*
- * Work out how many blocks we need to progress with the next chunk of a
+ * Work out how many blocks we need to proceed with the next chunk of a
 * truncate transaction.
 */
 static unsigned long blocks_for_truncate(struct inode *inode) 
 {
        unsigned long needed;
@@ -141,7 +138,6 @@ static unsigned long blocks_for_truncate(struct inode *inode)
 * extend fails, we need to propagate the failure up and restart the
 * transaction in the top-level truncate loop. --sct 
 */
 static handle_t *start_transaction(struct inode *inode) 
 {
        handle_t *result;
@@ -194,9 +190,11 @@ void ext3_delete_inode (struct inode * inode)
        handle = start_transaction(inode);
        if (IS_ERR(handle)) {
-                /* If we're going to skip the normal cleanup, we still
+                /*
-                 * need to make sure that the in-core orphan linked list
+                 * If we're going to skip the normal cleanup, we still need to
-                 * is properly cleaned up. */
+                 * make sure that the in-core orphan linked list is properly
+                 * cleaned up.
+                 */
                ext3_orphan_del(NULL, inode);
                goto no_delete;
        }
@@ -235,16 +233,6 @@ no_delete:
        clear_inode(inode);     /* We must guarantee clearing of inode... */
 }
-static int ext3_alloc_block (handle_t *handle,
-                        struct inode * inode, unsigned long goal, int *err)
-{
-        unsigned long result;
-        result = ext3_new_block(handle, inode, goal, err);
-        return result;
-}
 typedef struct {
        __le32  *p;
        __le32  key;
@@ -257,7 +245,7 @@ static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
        p->bh = bh;
 }
-static inline int verify_chain(Indirect *from, Indirect *to)
+static int verify_chain(Indirect *from, Indirect *to)
 {
        while (from <= to && from->key == *from->p)
                from++;
@@ -327,10 +315,10 @@ static int ext3_block_to_path(struct inode *inode,
                offsets[n++] = i_block & (ptrs - 1);
                final = ptrs;
        } else {
-                ext3_warning (inode->i_sb, "ext3_block_to_path", "block > big");
+                ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big");
        }
        if (boundary)
-                *boundary = (i_block & (ptrs - 1)) == (final - 1);
+                *boundary = final - 1 - (i_block & (ptrs - 1));
        return n;
 }
@@ -419,7 +407,6 @@ no_block:
 *
 *      Caller must make sure that @ind is valid and will stay that way.
 */
 static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
 {
        struct ext3_inode_info *ei = EXT3_I(inode);
@@ -429,17 +416,18 @@ static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
        unsigned long colour;
        /* Try to find previous block */
-        for (p = ind->p - 1; p >= start; p--)
+        for (p = ind->p - 1; p >= start; p--) {
                if (*p)
                        return le32_to_cpu(*p);
+        }
        /* No such thing, so let's try location of indirect block */
        if (ind->bh)
                return ind->bh->b_blocknr;
        /*
-         * It is going to be refered from inode itself? OK, just put it into
+         * It is going to be referred to from the inode itself? OK, just put it
-         * the same cylinder group then.
+         * into the same cylinder group then.
         */
        bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
                le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
@@ -463,7 +451,9 @@ static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
 static unsigned long ext3_find_goal(struct inode *inode, long block,
                Indirect chain[4], Indirect *partial)
 {
-        struct ext3_block_alloc_info *block_i =  EXT3_I(inode)->i_block_alloc_info;
+        struct ext3_block_alloc_info *block_i;
+        block_i =  EXT3_I(inode)->i_block_alloc_info;
        /*
         * try the heuristic for sequential allocation,
@@ -478,13 +468,113 @@ static unsigned long ext3_find_goal(struct inode *inode, long block,
 }
 /**
+ *      ext3_blks_to_allocate: Look up the block map and count the number
+ *      of direct blocks need to be allocated for the given branch.
+ *
+ *      @branch: chain of indirect blocks
+ *      @k: number of blocks need for indirect blocks
+ *      @blks: number of data blocks to be mapped.
+ *      @blocks_to_boundary:  the offset in the indirect block
+ *
+ *      return the total number of blocks to be allocate, including the
+ *      direct and indirect blocks.
+ */
+static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
+                int blocks_to_boundary)
+{
+        unsigned long count = 0;
+        /*
+         * Simple case, [t,d]Indirect block(s) has not allocated yet
+         * then it's clear blocks on that path have not allocated
+         */
+        if (k > 0) {
+                /* right now we don't handle cross boundary allocation */
+                if (blks < blocks_to_boundary + 1)
+                        count += blks;
+                else
+                        count += blocks_to_boundary + 1;
+                return count;
+        }
+        count++;
+        while (count < blks && count <= blocks_to_boundary &&
+                le32_to_cpu(*(branch[0].p + count)) == 0) {
+                count++;
+        }
+        return count;
+}
+/**
+ *      ext3_alloc_blocks: multiple allocate blocks needed for a branch
+ *      @indirect_blks: the number of blocks need to allocate for indirect
+ *                      blocks
+ *
+ *      @new_blocks: on return it will store the new block numbers for
+ *      the indirect blocks(if needed) and the first direct block,
+ *      @blks:  on return it will store the total number of allocated
+ *              direct blocks
+ */
+static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
+                        unsigned long goal, int indirect_blks, int blks,
+                        unsigned long long new_blocks[4], int *err)
+{
+        int target, i;
+        unsigned long count = 0;
+        int index = 0;
+        unsigned long current_block = 0;
+        int ret = 0;
+        /*
+         * Here we try to allocate the requested multiple blocks at once,
+         * on a best-effort basis.
+         * To build a branch, we should allocate blocks for
+         * the indirect blocks(if not allocated yet), and at least
+         * the first direct block of this branch.  That's the
+         * minimum number of blocks need to allocate(required)
+         */
+        target = blks + indirect_blks;
+        while (1) {
+                count = target;
+                /* allocating blocks for indirect blocks and direct blocks */
+                current_block = ext3_new_blocks(handle,inode,goal,&count,err);
+                if (*err)
+                        goto failed_out;
+                target -= count;
+                /* allocate blocks for indirect blocks */
+                while (index < indirect_blks && count) {
+                        new_blocks[index++] = current_block++;
+                        count--;
+                }
+                if (count > 0)
+                        break;
+        }
+        /* save the new block number for the first direct block */
+        new_blocks[index] = current_block;
+        /* total number of blocks allocated for direct blocks */
+        ret = count;
+        *err = 0;
+        return ret;
+failed_out:
+        for (i = 0; i <index; i++)
+                ext3_free_blocks(handle, inode, new_blocks[i], 1);
+        return ret;
+}
+/**
 *      ext3_alloc_branch - allocate and set up a chain of blocks.
 *      @inode: owner
- *      @num: depth of the chain (number of blocks to allocate)
+ *      @indirect_blks: number of allocated indirect blocks
+ *      @blks: number of allocated direct blocks
 *      @offsets: offsets (in the blocks) to store the pointers to next.
 *      @branch: place to store the chain in.
 *
- *      This function allocates @num blocks, zeroes out all but the last one,
+ *      This function allocates blocks, zeroes out all but the last one,
 *      links them into chain and (if we are synchronous) writes them to disk.
 *      In other words, it prepares a branch that can be spliced onto the
 *      inode. It stores the information about that chain in the branch[], in
@@ -501,97 +591,106 @@ static unsigned long ext3_find_goal(struct inode *inode, long block,
 *      ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain
 *      as described above and return 0.
 */
 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
-                             int num,
+                        int indirect_blks, int *blks, unsigned long goal,
-                             unsigned long goal,
+                        int *offsets, Indirect *branch)
-                             int *offsets,
-                             Indirect *branch)
 {
        int blocksize = inode->i_sb->s_blocksize;
-        int n = 0, keys = 0;
+        int i, n = 0;
        int err = 0;
-        int i;
+        struct buffer_head *bh;
-        int parent = ext3_alloc_block(handle, inode, goal, &err);
+        int num;
+        unsigned long long new_blocks[4];
-        branch[0].key = cpu_to_le32(parent);
+        unsigned long long current_block;
-        if (parent) {
-                for (n = 1; n < num; n++) {
-                        struct buffer_head *bh;
-                        /* Allocate the next block */
-                        int nr = ext3_alloc_block(handle, inode, parent, &err);
-                        if (!nr)
-                                break;
-                        branch[n].key = cpu_to_le32(nr);
-                        /*
+        num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
-                         * Get buffer_head for parent block, zero it out
+                                *blks, new_blocks, &err);
-                         * and set the pointer to new one, then send
+        if (err)
-                         * parent to disk.  
+                return err;
-                         */
-                        bh = sb_getblk(inode->i_sb, parent);
-                        if (!bh)
-                                break;
-                        keys = n+1;
-                        branch[n].bh = bh;
-                        lock_buffer(bh);
-                        BUFFER_TRACE(bh, "call get_create_access");
-                        err = ext3_journal_get_create_access(handle, bh);
-                        if (err) {
-                                unlock_buffer(bh);
-                                brelse(bh);
-                                break;
-                        }
-                        memset(bh->b_data, 0, blocksize);
+        branch[0].key = cpu_to_le32(new_blocks[0]);
-                        branch[n].p = (__le32*) bh->b_data + offsets[n];
+        /*
-                        *branch[n].p = branch[n].key;
+         * metadata blocks and data blocks are allocated.
-                        BUFFER_TRACE(bh, "marking uptodate");
+         */
-                        set_buffer_uptodate(bh);
+        for (n = 1; n <= indirect_blks;  n++) {
+                /*
+                 * Get buffer_head for parent block, zero it out
+                 * and set the pointer to new one, then send
+                 * parent to disk.
+                 */
+                bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
+                branch[n].bh = bh;
+                lock_buffer(bh);
+                BUFFER_TRACE(bh, "call get_create_access");
+                err = ext3_journal_get_create_access(handle, bh);
+                if (err) {
                        unlock_buffer(bh);
+                        brelse(bh);
+                        goto failed;
+                }
-                        BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
+                memset(bh->b_data, 0, blocksize);
-                        err = ext3_journal_dirty_metadata(handle, bh);
+                branch[n].p = (__le32 *) bh->b_data + offsets[n];
-                        if (err)
+                branch[n].key = cpu_to_le32(new_blocks[n]);
-                                break;
+                *branch[n].p = branch[n].key;
+                if ( n == indirect_blks) {
-                        parent = nr;
+                        current_block = new_blocks[n];
+                        /*
+                         * End of chain, update the last new metablock of
+                         * the chain to point to the new allocated
+                         * data blocks numbers
+                         */
+                        for (i=1; i < num; i++)
+                                *(branch[n].p + i) = cpu_to_le32(++current_block);
                }
-        }
+                BUFFER_TRACE(bh, "marking uptodate");
-        if (n == num)
+                set_buffer_uptodate(bh);
-                return 0;
+                unlock_buffer(bh);
+                BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
+                err = ext3_journal_dirty_metadata(handle, bh);
+                if (err)
+                        goto failed;
+        }
+        *blks = num;
+        return err;
+failed:
        /* Allocation failed, free what we already allocated */
-        for (i = 1; i < keys; i++) {
+        for (i = 1; i <= n ; i++) {
                BUFFER_TRACE(branch[i].bh, "call journal_forget");
                ext3_journal_forget(handle, branch[i].bh);
        }
-        for (i = 0; i < keys; i++)
+        for (i = 0; i <indirect_blks; i++)
-                ext3_free_blocks(handle, inode, le32_to_cpu(branch[i].key), 1);
+                ext3_free_blocks(handle, inode, new_blocks[i], 1);
+        ext3_free_blocks(handle, inode, new_blocks[i], num);
        return err;
 }
 /**
- *      ext3_splice_branch - splice the allocated branch onto inode.
+ * ext3_splice_branch - splice the allocated branch onto inode.
- *      @inode: owner
+ * @inode: owner
- *      @block: (logical) number of block we are adding
+ * @block: (logical) number of block we are adding
- *      @chain: chain of indirect blocks (with a missing link - see
+ * @chain: chain of indirect blocks (with a missing link - see
- *              ext3_alloc_branch)
+ *      ext3_alloc_branch)
- *      @where: location of missing link
+ * @where: location of missing link
- *      @num:   number of blocks we are adding
+ * @num:   number of indirect blocks we are adding
- *
+ * @blks:  number of direct blocks we are adding
- *      This function fills the missing link and does all housekeeping needed in
+ *
- *      inode (->i_blocks, etc.). In case of success we end up with the full
+ * This function fills the missing link and does all housekeeping needed in
- *      chain to new block and return 0.
+ * inode (->i_blocks, etc.). In case of success we end up with the full
+ * chain to new block and return 0.
 */
+static int ext3_splice_branch(handle_t *handle, struct inode *inode,
-static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
+                        long block, Indirect *where, int num, int blks)
-                              Indirect chain[4], Indirect *where, int num)
 {
        int i;
        int err = 0;
-        struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;
+        struct ext3_block_alloc_info *block_i;
+        unsigned long current_block;
+        block_i = EXT3_I(inode)->i_block_alloc_info;
        /*
         * If we're splicing into a [td]indirect block (as opposed to the
         * inode) then we need to get write access to the [td]indirect block
@@ -608,13 +707,24 @@ static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
        *where->p = where->key;
        /*
+         * Update the host buffer_head or inode to point to more just allocated
+         * direct blocks blocks
+         */
+        if (num == 0 && blks > 1) {
+                current_block = le32_to_cpu(where->key + 1);
+                for (i = 1; i < blks; i++)
+                        *(where->p + i ) = cpu_to_le32(current_block++);
+        }
+        /*
         * update the most recently allocated logical & physical block
         * in i_block_alloc_info, to assist find the proper goal block for next
         * allocation
         */
        if (block_i) {
-                block_i->last_alloc_logical_block = block;
+                block_i->last_alloc_logical_block = block + blks - 1;
-                block_i->last_alloc_physical_block = le32_to_cpu(where[num-1].key);
+                block_i->last_alloc_physical_block =
+                                le32_to_cpu(where[num].key + blks - 1);
        }
        /* We are done with atomic stuff, now do the rest of housekeeping */
@@ -625,7 +735,7 @@ static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
        /* had we spliced it onto indirect block? */
        if (where->bh) {
                /*
-                 * akpm: If we spliced it onto an indirect block, we haven't
+                 * If we spliced it onto an indirect block, we haven't
                 * altered the inode.  Note however that if it is being spliced
                 * onto an indirect block at the very end of the file (the
                 * file is growing) then we *will* alter the inode to reflect
@@ -647,10 +757,13 @@ static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,
        return err;
 err_out:
-        for (i = 1; i < num; i++) {
+        for (i = 1; i <= num; i++) {
                BUFFER_TRACE(where[i].bh, "call journal_forget");
                ext3_journal_forget(handle, where[i].bh);
+                ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
        }
+        ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
        return err;
 }
@@ -666,26 +779,33 @@ err_out:
 * allocations is needed - we simply release blocks and do not touch anything
 * reachable from inode.
 *
- * akpm: `handle' can be NULL if create == 0.
+ * `handle' can be NULL if create == 0.
 *
 * The BKL may not be held on entry here.  Be sure to take it early.
+ * return > 0, # of blocks mapped or allocated.
+ * return = 0, if plain lookup failed.
+ * return < 0, error case.
 */
+int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
-int
+                sector_t iblock, unsigned long maxblocks,
-ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
+                struct buffer_head *bh_result,
-                struct buffer_head *bh_result, int create, int extend_disksize)
+                int create, int extend_disksize)
 {
        int err = -EIO;
        int offsets[4];
        Indirect chain[4];
        Indirect *partial;
        unsigned long goal;
-        int left;
+        int indirect_blks;
-        int boundary = 0;
+        int blocks_to_boundary = 0;
-        const int depth = ext3_block_to_path(inode, iblock, offsets, &boundary);
+        int depth;
        struct ext3_inode_info *ei = EXT3_I(inode);
+        int count = 0;
+        unsigned long first_block = 0;
        J_ASSERT(handle != NULL || create == 0);
+        depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
        if (depth == 0)
                goto out;
@@ -694,8 +814,31 @@ ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
        /* Simplest case - block found, no allocation needed */
        if (!partial) {
+                first_block = chain[depth - 1].key;
                clear_buffer_new(bh_result);
-                goto got_it;
+                count++;
+                /*map more blocks*/
+                while (count < maxblocks && count <= blocks_to_boundary) {
+                        if (!verify_chain(chain, partial)) {
+                                /*
+                                 * Indirect block might be removed by
+                                 * truncate while we were reading it.
+                                 * Handling of that case: forget what we've
+                                 * got now. Flag the err as EAGAIN, so it
+                                 * will reread.
+                                 */
+                                err = -EAGAIN;
+                                count = 0;
+                                break;
+                        }
+                        if (le32_to_cpu(*(chain[depth-1].p+count) ==
+                                        (first_block + count)))
+                                count++;
+                        else
+                                break;
+                }
+                if (err != -EAGAIN)
+                        goto got_it;
        }
        /* Next simple case - plain lookup or failed read of indirect block */
@@ -723,6 +866,7 @@ ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
                }
                partial = ext3_get_branch(inode, depth, offsets, chain, &err);
                if (!partial) {
+                        count++;
                        mutex_unlock(&ei->truncate_mutex);
                        if (err)
                                goto cleanup;
@@ -740,12 +884,19 @@ ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
        goal = ext3_find_goal(inode, iblock, chain, partial);
-        left = (chain + depth) - partial;
+        /* the number of blocks need to allocate for [d,t]indirect blocks */
+        indirect_blks = (chain + depth) - partial - 1;
        /*
+         * Next look up the indirect map to count the totoal number of
+         * direct blocks to allocate for this branch.
+         */
+        count = ext3_blks_to_allocate(partial, indirect_blks,
+                                        maxblocks, blocks_to_boundary);
+        /*
         * Block out ext3_truncate while we alter the tree
         */
-        err = ext3_alloc_branch(handle, inode, left, goal,
+        err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
                                offsets + (partial - chain), partial);
        /*
@@ -756,8 +907,8 @@ ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
         * may need to return -EAGAIN upwards in the worst case.  --sct
         */
        if (!err)
-                err = ext3_splice_branch(handle, inode, iblock, chain,
+                err = ext3_splice_branch(handle, inode, iblock,
-                                         partial, left);
+                                        partial, indirect_blks, count);
        /*
         * i_disksize growing is protected by truncate_mutex.  Don't forget to
         * protect it if you're about to implement concurrent
@@ -772,8 +923,9 @@ ext3_get_block_handle(handle_t *handle, struct inode *inode, sector_t iblock,
        set_buffer_new(bh_result);
 got_it:
        map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
-        if (boundary)
+        if (blocks_to_boundary == 0)
                set_buffer_boundary(bh_result);
+        err = count;
        /* Clean up and exit */
        partial = chain + depth - 1;    /* the whole chain */
 cleanup:
@@ -787,34 +939,21 @@ out:
        return err;
 }
-static int ext3_get_block(struct inode *inode, sector_t iblock,
-                        struct buffer_head *bh_result, int create)
-{
-        handle_t *handle = NULL;
-        int ret;
-        if (create) {
-                handle = ext3_journal_current_handle();
-                J_ASSERT(handle != 0);
-        }
-        ret = ext3_get_block_handle(handle, inode, iblock,
-                                bh_result, create, 1);
-        return ret;
-}
 #define DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS + 32)
-static int
+static int ext3_get_block(struct inode *inode, sector_t iblock,
-ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
+                        struct buffer_head *bh_result, int create)
-                unsigned long max_blocks, struct buffer_head *bh_result,
-                int create)
 {
        handle_t *handle = journal_current_handle();
        int ret = 0;
+        unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
-        if (!handle)
+        if (!create)
                goto get_block;         /* A read */
+        if (max_blocks == 1)
+                goto get_block;         /* A single block get */
        if (handle->h_transaction->t_state == T_LOCKED) {
                /*
                 * Huge direct-io writes can hold off commits for long
@@ -841,18 +980,22 @@ ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,
        }
 get_block:
-        if (ret == 0)
+        if (ret == 0) {
-                ret = ext3_get_block_handle(handle, inode, iblock,
+                ret = ext3_get_blocks_handle(handle, inode, iblock,
-                                        bh_result, create, 0);
+                                        max_blocks, bh_result, create, 0);
-        bh_result->b_size = (1 << inode->i_blkbits);
+                if (ret > 0) {
+                        bh_result->b_size = (ret << inode->i_blkbits);
+                        ret = 0;
+                }
+        }
        return ret;
 }
 /*
 * `handle' can be NULL if create is zero
 */
-struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
+struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
-                                long block, int create, int * errp)
+                                long block, int create, int *errp)
 {
        struct buffer_head dummy;
        int fatal = 0, err;
@@ -862,8 +1005,16 @@ struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
        dummy.b_state = 0;
        dummy.b_blocknr = -1000;
        buffer_trace_init(&dummy.b_history);
-        *errp = ext3_get_block_handle(handle, inode, block, &dummy, create, 1);
+        err = ext3_get_blocks_handle(handle, inode, block, 1,
-        if (!*errp && buffer_mapped(&dummy)) {
+                                        &dummy, create, 1);
+        if (err == 1) {
+                err = 0;
+        } else if (err >= 0) {
+                WARN_ON(1);
+                err = -EIO;
+        }
+        *errp = err;
+        if (!err && buffer_mapped(&dummy)) {
                struct buffer_head *bh;
                bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
                if (!bh) {
@@ -874,17 +1025,18 @@ struct buffer_head *ext3_getblk(handle_t *handle, struct inode * inode,
                        J_ASSERT(create != 0);
                        J_ASSERT(handle != 0);
-                        /* Now that we do not always journal data, we
+                        /*
-                           should keep in mind whether this should
+                         * Now that we do not always journal data, we should
-                           always journal the new buffer as metadata.
+                         * keep in mind whether this should always journal the
-                           For now, regular file writes use
+                         * new buffer as metadata.  For now, regular file
-                           ext3_get_block instead, so it's not a
+                         * writes use ext3_get_block instead, so it's not a
-                           problem. */
+                         * problem.
+                         */
                        lock_buffer(bh);
                        BUFFER_TRACE(bh, "call get_create_access");
                        fatal = ext3_journal_get_create_access(handle, bh);
                        if (!fatal && !buffer_uptodate(bh)) {
-                                memset(bh->b_data, 0, inode->i_sb->s_blocksize);
+                                memset(bh->b_data,0,inode->i_sb->s_blocksize);
                                set_buffer_uptodate(bh);
                        }
                        unlock_buffer(bh);
@@ -906,7 +1058,7 @@ err:
        return NULL;
 }
-struct buffer_head *ext3_bread(handle_t *handle, struct inode * inode,
+struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
                               int block, int create, int *err)
 {
        struct buffer_head * bh;
@@ -982,9 +1134,8 @@ static int walk_page_buffers(	handle_t *handle,
 * is elevated.  We'll still have enough credits for the tiny quotafile
 * write.  
 */
+static int do_journal_get_write_access(handle_t *handle,
-static int do_journal_get_write_access(handle_t *handle, 
+                                        struct buffer_head *bh)
-                                       struct buffer_head *bh)
 {
        if (!buffer_mapped(bh) || buffer_freed(bh))
                return 0;
@@ -1025,8 +1176,7 @@ out:
        return ret;
 }
-int
+int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
-ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
 {
        int err = journal_dirty_data(handle, bh);
        if (err)
@@ -1051,7 +1201,6 @@ static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
 * ext3 never places buffers on inode->i_mapping->private_list.  metadata
 * buffers are managed internally.
 */
 static int ext3_ordered_commit_write(struct file *file, struct page *page,
                             unsigned from, unsigned to)
 {
@@ -1261,7 +1410,7 @@ static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
 * we don't need to open a transaction here.
 */
 static int ext3_ordered_writepage(struct page *page,
-                        struct writeback_control *wbc)
+                                struct writeback_control *wbc)
 {
        struct inode *inode = page->mapping->host;
        struct buffer_head *page_bufs;
@@ -1430,7 +1579,7 @@ ext3_readpages(struct file *file, struct address_space *mapping,
        return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
 }
-static int ext3_invalidatepage(struct page *page, unsigned long offset)
+static void ext3_invalidatepage(struct page *page, unsigned long offset)
 {
        journal_t *journal = EXT3_JOURNAL(page->mapping->host);
@@ -1440,7 +1589,7 @@ static int ext3_invalidatepage(struct page *page, unsigned long offset)
        if (offset == 0)
                ClearPageChecked(page);
-        return journal_invalidatepage(journal, page, offset);
+        journal_invalidatepage(journal, page, offset);
 }
 static int ext3_releasepage(struct page *page, gfp_t wait)
@@ -1492,11 +1641,10 @@ static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
        ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 
                                 offset, nr_segs,
-                                 ext3_direct_io_get_blocks, NULL);
+                                 ext3_get_block, NULL);
        /*
-         * Reacquire the handle: ext3_direct_io_get_block() can restart the
+         * Reacquire the handle: ext3_get_block() can restart the transaction
-         * transaction
         */
        handle = journal_current_handle();
@@ -1752,11 +1900,8 @@ static inline int all_zeroes(__le32 *p, __le32 *q)
 *              c) free the subtrees growing from the inode past the @chain[0].
 *                      (no partially truncated stuff there).  */
-static Indirect *ext3_find_shared(struct inode *inode,
+static Indirect *ext3_find_shared(struct inode *inode, int depth,
-                                int depth,
+                        int offsets[4], Indirect chain[4], __le32 *top)
-                                int offsets[4],
-                                Indirect chain[4],
-                                __le32 *top)
 {
        Indirect *partial, *p;
        int k, err;
@@ -1795,8 +1940,7 @@ static Indirect *ext3_find_shared(struct inode *inode,
        }
        /* Writer: end */
-        while(partial > p)
+        while(partial > p) {
-        {
                brelse(partial->bh);
                partial--;
        }
@@ -1812,10 +1956,9 @@ no_top:
 * We release `count' blocks on disk, but (last - first) may be greater
 * than `count' because there can be holes in there.
 */
-static void
+static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
-ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,
+                struct buffer_head *bh, unsigned long block_to_free,
-                unsigned long block_to_free, unsigned long count,
+                unsigned long count, __le32 *first, __le32 *last)
-                __le32 *first, __le32 *last)
 {
        __le32 *p;
        if (try_to_extend_transaction(handle, inode)) {
@@ -2076,8 +2219,7 @@ static void ext3_free_branches(handle_t *handle, struct inode *inode,
 * that's fine - as long as they are linked from the inode, the post-crash
 * ext3_truncate() run will find them and release them.
 */
+void ext3_truncate(struct inode *inode)
-void ext3_truncate(struct inode * inode)
 {
        handle_t *handle;
        struct ext3_inode_info *ei = EXT3_I(inode);
@@ -2201,29 +2343,26 @@ void ext3_truncate(struct inode * inode)
 do_indirects:
        /* Kill the remaining (whole) subtrees */
        switch (offsets[0]) {
-                default:
+        default:
-                        nr = i_data[EXT3_IND_BLOCK];
+                nr = i_data[EXT3_IND_BLOCK];
-                        if (nr) {
+                if (nr) {
-                                ext3_free_branches(handle, inode, NULL,
+                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
-                                                   &nr, &nr+1, 1);
+                        i_data[EXT3_IND_BLOCK] = 0;
-                                i_data[EXT3_IND_BLOCK] = 0;
+                }
-                        }
+        case EXT3_IND_BLOCK:
-                case EXT3_IND_BLOCK:
+                nr = i_data[EXT3_DIND_BLOCK];
-                        nr = i_data[EXT3_DIND_BLOCK];
+                if (nr) {
-                        if (nr) {
+                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
-                                ext3_free_branches(handle, inode, NULL,
+                        i_data[EXT3_DIND_BLOCK] = 0;
-                                                   &nr, &nr+1, 2);
+                }
-                                i_data[EXT3_DIND_BLOCK] = 0;
+        case EXT3_DIND_BLOCK:
-                        }
+                nr = i_data[EXT3_TIND_BLOCK];
-                case EXT3_DIND_BLOCK:
+                if (nr) {
-                        nr = i_data[EXT3_TIND_BLOCK];
+                        ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
-                        if (nr) {
+                        i_data[EXT3_TIND_BLOCK] = 0;
-                                ext3_free_branches(handle, inode, NULL,
+                }
-                                                   &nr, &nr+1, 3);
+        case EXT3_TIND_BLOCK:
-                                i_data[EXT3_TIND_BLOCK] = 0;
+                ;
-                        }
-                case EXT3_TIND_BLOCK:
-                        ;
        }
        ext3_discard_reservation(inode);
@@ -2232,8 +2371,10 @@ do_indirects:
        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
        ext3_mark_inode_dirty(handle, inode);
-        /* In a multi-transaction truncate, we only make the final
+        /*
-         * transaction synchronous */
+         * In a multi-transaction truncate, we only make the final transaction
+         * synchronous
+         */
        if (IS_SYNC(inode))
                handle->h_sync = 1;
 out_stop:
@@ -2259,20 +2400,16 @@ static unsigned long ext3_get_inode_block(struct super_block *sb,
        struct ext3_group_desc * gdp;
-        if ((ino != EXT3_ROOT_INO &&
+        if ((ino != EXT3_ROOT_INO && ino != EXT3_JOURNAL_INO &&
-                ino != EXT3_JOURNAL_INO &&
+                ino != EXT3_RESIZE_INO && ino < EXT3_FIRST_INO(sb)) ||
-                ino != EXT3_RESIZE_INO &&
+                ino > le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count)) {
-                ino < EXT3_FIRST_INO(sb)) ||
+                ext3_error(sb, "ext3_get_inode_block",
-                ino > le32_to_cpu(
-                        EXT3_SB(sb)->s_es->s_inodes_count)) {
-                ext3_error (sb, "ext3_get_inode_block",
                            "bad inode number: %lu", ino);
                return 0;
        }
        block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
        if (block_group >= EXT3_SB(sb)->s_groups_count) {
-                ext3_error (sb, "ext3_get_inode_block",
+                ext3_error(sb,"ext3_get_inode_block","group >= groups count");
-                            "group >= groups count");
                return 0;
        }
        smp_rmb();
@@ -2285,7 +2422,7 @@ static unsigned long ext3_get_inode_block(struct super_block *sb,
                return 0;
        }
-        gdp = (struct ext3_group_desc *) bh->b_data;
+        gdp = (struct ext3_group_desc *)bh->b_data;
        /*
         * Figure out the offset within the block group inode table
         */
@@ -2834,7 +2971,7 @@ err_out:
 /*
- * akpm: how many blocks doth make a writepage()?
+ * How many blocks doth make a writepage()?
 *
 * With N blocks per page, it may be:
 * N data blocks
@@ -2924,8 +3061,8 @@ ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
 }
 /*
- * akpm: What we do here is to mark the in-core inode as clean
+ * What we do here is to mark the in-core inode as clean with respect to inode
- * with respect to inode dirtiness (it may still be data-dirty).
+ * dirtiness (it may still be data-dirty).
 * This means that the in-core inode may be reaped by prune_icache
 * without having to perform any I/O.  This is a very good thing,
 * because *any* task may call prune_icache - even ones which
@@ -2957,7 +3094,7 @@ int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
 }
 /*
- * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()
+ * ext3_dirty_inode() is called from __mark_inode_dirty()
 *
 * We're really interested in the case where a file is being extended.
 * i_size has been changed by generic_commit_write() and we thus need
@@ -2993,7 +3130,7 @@ out:
        return;
 }
-#ifdef AKPM
+#if 0
 /* 
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
@@ -3001,8 +3138,7 @@ out:
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
-static inline int
+static int ext3_pin_inode(handle_t *handle, struct inode *inode)
-ext3_pin_inode(handle_t *handle, struct inode *inode)
 {
        struct ext3_iloc iloc;
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 86e443182de4..f8a5266ea1ff 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1678,12 +1678,6 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        }
        if (test_opt(sb, NOBH)) {
-                if (sb->s_blocksize_bits != PAGE_CACHE_SHIFT) {
-                        printk(KERN_WARNING "EXT3-fs: Ignoring nobh option "
-                                "since filesystem blocksize doesn't match "
-                                "pagesize\n");
-                        clear_opt(sbi->s_mount_opt, NOBH);
-                }
                if (!(test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)) {
                        printk(KERN_WARNING "EXT3-fs: Ignoring nobh option - "
                                "its supported only with writeback mode\n");
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 297300fe81c2..404bfc9f7385 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -101,11 +101,11 @@ static int __fat_get_blocks(struct inode *inode, sector_t iblock,
 }
 static int fat_get_blocks(struct inode *inode, sector_t iblock,
-                          unsigned long max_blocks,
                          struct buffer_head *bh_result, int create)
 {
        struct super_block *sb = inode->i_sb;
        int err;
+        unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
        err = __fat_get_blocks(inode, iblock, &max_blocks, bh_result, create);
        if (err)
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 03c789560fb8..2a2479196f96 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -412,7 +412,7 @@ out:
 /* Table to convert sigio signal codes into poll band bitmaps */
-static long band_table[NSIGPOLL] = {
+static const long band_table[NSIGPOLL] = {
        POLLIN | POLLRDNORM,                    /* POLL_IN */
        POLLOUT | POLLWRNORM | POLLWRBAND,      /* POLL_OUT */
        POLLIN | POLLRDNORM | POLLMSG,          /* POLL_MSG */
@@ -531,7 +531,7 @@ int send_sigurg(struct fown_struct *fown)
 }
 static DEFINE_RWLOCK(fasync_lock);
-static kmem_cache_t *fasync_cache;
+static kmem_cache_t *fasync_cache __read_mostly;
 /*
 * fasync_helper() is used by some character device drivers (mainly mice)
diff --git a/fs/hfs/bnode.c b/fs/hfs/bnode.c
index a7a7d77f3fd3..1e44dcfe49c4 100644
--- a/fs/hfs/bnode.c
+++ b/fs/hfs/bnode.c
@@ -306,8 +306,7 @@ void hfs_bnode_unhash(struct hfs_bnode *node)
        for (p = &node->tree->node_hash[hfs_bnode_hash(node->this)];
             *p && *p != node; p = &(*p)->next_hash)
                ;
-        if (!*p)
+        BUG_ON(!*p);
-                BUG();
        *p = node->next_hash;
        node->tree->node_hash_cnt--;
 }
@@ -415,8 +414,7 @@ struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num)
        spin_lock(&tree->hash_lock);
        node = hfs_bnode_findhash(tree, num);
        spin_unlock(&tree->hash_lock);
-        if (node)
+        BUG_ON(node);
-                BUG();
        node = __hfs_bnode_create(tree, num);
        if (!node)
                return ERR_PTR(-ENOMEM);
@@ -459,8 +457,7 @@ void hfs_bnode_put(struct hfs_bnode *node)
                dprint(DBG_BNODE_REFS, "put_node(%d:%d): %d\n",
                       node->tree->cnid, node->this, atomic_read(&node->refcnt));
-                if (!atomic_read(&node->refcnt))
+                BUG_ON(!atomic_read(&node->refcnt));
-                        BUG();
                if (!atomic_dec_and_lock(&node->refcnt, &tree->hash_lock))
                        return;
                for (i = 0; i < tree->pages_per_bnode; i++) {
diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
index 7bb11edd1488..d20131ce4b95 100644
--- a/fs/hfs/btree.c
+++ b/fs/hfs/btree.c
@@ -36,8 +36,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id, btree_keycmp ke
        tree->inode = iget_locked(sb, id);
        if (!tree->inode)
                goto free_tree;
-        if (!(tree->inode->i_state & I_NEW))
+        BUG_ON(!(tree->inode->i_state & I_NEW));
-                BUG();
        {
        struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
        HFS_I(tree->inode)->flags = 0;
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 39fd85b9b916..2c564701724f 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -98,17 +98,6 @@ static int hfs_releasepage(struct page *page, gfp_t mask)
        return res ? try_to_free_buffers(page) : 0;
 }
-static int hfs_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,
-                          struct buffer_head *bh_result, int create)
-{
-        int ret;
-        ret = hfs_get_block(inode, iblock, bh_result, create);
-        if (!ret)
-                bh_result->b_size = (1 << inode->i_blkbits);
-        return ret;
-}
 static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
                const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
@@ -116,7 +105,7 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                  offset, nr_segs, hfs_get_blocks, NULL);
+                                  offset, nr_segs, hfs_get_block, NULL);
 }
 static int hfs_writepages(struct address_space *mapping,
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 12ed2b7d046b..9fbe4d2aeece 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -93,17 +93,6 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
        return res ? try_to_free_buffers(page) : 0;
 }
-static int hfsplus_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,
-                              struct buffer_head *bh_result, int create)
-{
-        int ret;
-        ret = hfsplus_get_block(inode, iblock, bh_result, create);
-        if (!ret)
-                bh_result->b_size = (1 << inode->i_blkbits);
-        return ret;
-}
 static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
                const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
@@ -111,7 +100,7 @@ static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                  offset, nr_segs, hfsplus_get_blocks, NULL);
+                                  offset, nr_segs, hfsplus_get_block, NULL);
 }
 static int hfsplus_writepages(struct address_space *mapping,
diff --git a/fs/hostfs/hostfs_user.c b/fs/hostfs/hostfs_user.c
index b97809deba66..23b7cee72123 100644
--- a/fs/hostfs/hostfs_user.c
+++ b/fs/hostfs/hostfs_user.c
@@ -360,7 +360,6 @@ int do_statfs(char *root, long *bsize_out, long long *blocks_out,
        spare_out[2] = buf.f_spare[2];
        spare_out[3] = buf.f_spare[3];
        spare_out[4] = buf.f_spare[4];
-        spare_out[5] = buf.f_spare[5];
        return(0);
 }
diff --git a/fs/inode.c b/fs/inode.c
index 85da11044adc..1fddf2803af8 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -56,8 +56,8 @@
 #define I_HASHBITS      i_hash_shift
 #define I_HASHMASK      i_hash_mask
-static unsigned int i_hash_mask;
+static unsigned int i_hash_mask __read_mostly;
-static unsigned int i_hash_shift;
+static unsigned int i_hash_shift __read_mostly;
 /*
 * Each inode can be on two separate lists. One is
@@ -73,7 +73,7 @@ static unsigned int i_hash_shift;
 LIST_HEAD(inode_in_use);
 LIST_HEAD(inode_unused);
-static struct hlist_head *inode_hashtable;
+static struct hlist_head *inode_hashtable __read_mostly;
 /*
 * A simple spinlock to protect the list manipulations.
@@ -98,7 +98,7 @@ static DEFINE_MUTEX(iprune_mutex);
 */
 struct inodes_stat_t inodes_stat;
-static kmem_cache_t * inode_cachep;
+static kmem_cache_t * inode_cachep __read_mostly;
 static struct inode *alloc_inode(struct super_block *sb)
 {
diff --git a/fs/inotify.c b/fs/inotify.c
index a61e93e17853..f48a3dae0712 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -39,15 +39,15 @@
 static atomic_t inotify_cookie;
-static kmem_cache_t *watch_cachep;
+static kmem_cache_t *watch_cachep __read_mostly;
-static kmem_cache_t *event_cachep;
+static kmem_cache_t *event_cachep __read_mostly;
-static struct vfsmount *inotify_mnt;
+static struct vfsmount *inotify_mnt __read_mostly;
 /* these are configurable via /proc/sys/fs/inotify/ */
-int inotify_max_user_instances;
+int inotify_max_user_instances __read_mostly;
-int inotify_max_user_watches;
+int inotify_max_user_watches __read_mostly;
-int inotify_max_queued_events;
+int inotify_max_queued_events __read_mostly;
 /*
 * Lock ordering:
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index ada31fa272e3..c609f5034fcd 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -1873,16 +1873,15 @@ zap_buffer_unlocked:
 }
 /** 
- * int journal_invalidatepage() 
+ * void journal_invalidatepage()
 * @journal: journal to use for flush... 
 * @page:    page to flush
 * @offset:  length of page to invalidate.
 *
 * Reap page buffers containing data after offset in page.
 *
- * Return non-zero if the page's buffers were successfully reaped.
 */
-int journal_invalidatepage(journal_t *journal, 
+void journal_invalidatepage(journal_t *journal,
                      struct page *page, 
                      unsigned long offset)
 {
@@ -1893,7 +1892,7 @@ int journal_invalidatepage(journal_t *journal,
        if (!PageLocked(page))
                BUG();
        if (!page_has_buffers(page))
-                return 1;
+                return;
        /* We will potentially be playing with lists other than just the
         * data lists (especially for journaled data mode), so be
@@ -1916,11 +1915,9 @@ int journal_invalidatepage(journal_t *journal,
        } while (bh != head);
        if (!offset) {
-                if (!may_free || !try_to_free_buffers(page))
+                if (may_free && try_to_free_buffers(page))
-                        return 0;
+                        J_ASSERT(!page_has_buffers(page));
-                J_ASSERT(!page_has_buffers(page));
        }
-        return 1;
 }
 /* 
diff --git a/fs/jffs2/compr_zlib.c b/fs/jffs2/compr_zlib.c
index 4db8be8e90cc..5c63e0cdcf4c 100644
--- a/fs/jffs2/compr_zlib.c
+++ b/fs/jffs2/compr_zlib.c
@@ -33,13 +33,14 @@
        */
 #define STREAM_END_SPACE 12
-static DECLARE_MUTEX(deflate_sem);
+static DEFINE_MUTEX(deflate_mutex);
-static DECLARE_MUTEX(inflate_sem);
+static DEFINE_MUTEX(inflate_mutex);
 static z_stream inf_strm, def_strm;
 #ifdef __KERNEL__ /* Linux-only */
 #include <linux/vmalloc.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 static int __init alloc_workspaces(void)
 {
@@ -79,11 +80,11 @@ static int jffs2_zlib_compress(unsigned char *data_in,
        if (*dstlen <= STREAM_END_SPACE)
                return -1;
-        down(&deflate_sem);
+        mutex_lock(&deflate_mutex);
        if (Z_OK != zlib_deflateInit(&def_strm, 3)) {
                printk(KERN_WARNING "deflateInit failed\n");
-                up(&deflate_sem);
+                mutex_unlock(&deflate_mutex);
                return -1;
        }
@@ -104,7 +105,7 @@ static int jffs2_zlib_compress(unsigned char *data_in,
                if (ret != Z_OK) {
                        D1(printk(KERN_DEBUG "deflate in loop returned %d\n", ret));
                        zlib_deflateEnd(&def_strm);
-                        up(&deflate_sem);
+                        mutex_unlock(&deflate_mutex);
                        return -1;
                }
        }
@@ -133,7 +134,7 @@ static int jffs2_zlib_compress(unsigned char *data_in,
        *sourcelen = def_strm.total_in;
        ret = 0;
 out:
-        up(&deflate_sem);
+        mutex_unlock(&deflate_mutex);
        return ret;
 }
@@ -145,7 +146,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
        int ret;
        int wbits = MAX_WBITS;
-        down(&inflate_sem);
+        mutex_lock(&inflate_mutex);
        inf_strm.next_in = data_in;
        inf_strm.avail_in = srclen;
@@ -173,7 +174,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
        if (Z_OK != zlib_inflateInit2(&inf_strm, wbits)) {
                printk(KERN_WARNING "inflateInit failed\n");
-                up(&inflate_sem);
+                mutex_unlock(&inflate_mutex);
                return 1;
        }
@@ -183,7 +184,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
                printk(KERN_NOTICE "inflate returned %d\n", ret);
        }
        zlib_inflateEnd(&inf_strm);
-        up(&inflate_sem);
+        mutex_unlock(&inflate_mutex);
        return 0;
 }
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 51a5fed90cca..04eb78f1252e 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -258,7 +258,8 @@ jfs_get_blocks(struct inode *ip, sector_t lblock, unsigned long max_blocks,
 static int jfs_get_block(struct inode *ip, sector_t lblock,
                         struct buffer_head *bh_result, int create)
 {
-        return jfs_get_blocks(ip, lblock, 1, bh_result, create);
+        return jfs_get_blocks(ip, lblock, bh_result->b_size >> ip->i_blkbits,
+                        bh_result, create);
 }
 static int jfs_writepage(struct page *page, struct writeback_control *wbc)
@@ -301,7 +302,7 @@ static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_mapping->host;
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                offset, nr_segs, jfs_get_blocks, NULL);
+                                offset, nr_segs, jfs_get_block, NULL);
 }
 struct address_space_operations jfs_aops = {
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 0b348b13b551..3315f0b1fbc0 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -69,6 +69,7 @@
 #include <linux/bio.h>
 #include <linux/suspend.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 #include "jfs_incore.h"
 #include "jfs_filsys.h"
 #include "jfs_metapage.h"
@@ -165,7 +166,7 @@ do {						\
 */
 static LIST_HEAD(jfs_external_logs);
 static struct jfs_log *dummy_log = NULL;
-static DECLARE_MUTEX(jfs_log_sem);
+static DEFINE_MUTEX(jfs_log_mutex);
 /*
 * forward references
@@ -1085,20 +1086,20 @@ int lmLogOpen(struct super_block *sb)
        if (sbi->mntflag & JFS_INLINELOG)
                return open_inline_log(sb);
-        down(&jfs_log_sem);
+        mutex_lock(&jfs_log_mutex);
        list_for_each_entry(log, &jfs_external_logs, journal_list) {
                if (log->bdev->bd_dev == sbi->logdev) {
                        if (memcmp(log->uuid, sbi->loguuid,
                                   sizeof(log->uuid))) {
                                jfs_warn("wrong uuid on JFS journal\n");
-                                up(&jfs_log_sem);
+                                mutex_unlock(&jfs_log_mutex);
                                return -EINVAL;
                        }
                        /*
                         * add file system to log active file system list
                         */
                        if ((rc = lmLogFileSystem(log, sbi, 1))) {
-                                up(&jfs_log_sem);
+                                mutex_unlock(&jfs_log_mutex);
                                return rc;
                        }
                        goto journal_found;
@@ -1106,7 +1107,7 @@ int lmLogOpen(struct super_block *sb)
        }
        if (!(log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL))) {
-                up(&jfs_log_sem);
+                mutex_unlock(&jfs_log_mutex);
                return -ENOMEM;
        }
        INIT_LIST_HEAD(&log->sb_list);
@@ -1151,7 +1152,7 @@ journal_found:
        sbi->log = log;
        LOG_UNLOCK(log);
-        up(&jfs_log_sem);
+        mutex_unlock(&jfs_log_mutex);
        return 0;
        /*
@@ -1168,7 +1169,7 @@ journal_found:
        blkdev_put(bdev);
      free:             /* free log descriptor */
-        up(&jfs_log_sem);
+        mutex_unlock(&jfs_log_mutex);
        kfree(log);
        jfs_warn("lmLogOpen: exit(%d)", rc);
@@ -1212,11 +1213,11 @@ static int open_dummy_log(struct super_block *sb)
 {
        int rc;
-        down(&jfs_log_sem);
+        mutex_lock(&jfs_log_mutex);
        if (!dummy_log) {
                dummy_log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL);
                if (!dummy_log) {
-                        up(&jfs_log_sem);
+                        mutex_unlock(&jfs_log_mutex);
                        return -ENOMEM;
                }
                INIT_LIST_HEAD(&dummy_log->sb_list);
@@ -1229,7 +1230,7 @@ static int open_dummy_log(struct super_block *sb)
                if (rc) {
                        kfree(dummy_log);
                        dummy_log = NULL;
-                        up(&jfs_log_sem);
+                        mutex_unlock(&jfs_log_mutex);
                        return rc;
                }
        }
@@ -1238,7 +1239,7 @@ static int open_dummy_log(struct super_block *sb)
        list_add(&JFS_SBI(sb)->log_list, &dummy_log->sb_list);
        JFS_SBI(sb)->log = dummy_log;
        LOG_UNLOCK(dummy_log);
-        up(&jfs_log_sem);
+        mutex_unlock(&jfs_log_mutex);
        return 0;
 }
@@ -1466,7 +1467,7 @@ int lmLogClose(struct super_block *sb)
        jfs_info("lmLogClose: log:0x%p", log);
-        down(&jfs_log_sem);
+        mutex_lock(&jfs_log_mutex);
        LOG_LOCK(log);
        list_del(&sbi->log_list);
        LOG_UNLOCK(log);
@@ -1516,7 +1517,7 @@ int lmLogClose(struct super_block *sb)
        kfree(log);
      out:
-        up(&jfs_log_sem);
+        mutex_unlock(&jfs_log_mutex);
        jfs_info("lmLogClose: exit(%d)", rc);
        return rc;
 }
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 5fbaeaadccd3..f28696f235c4 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -220,8 +220,8 @@ int __init metapage_init(void)
        if (metapage_cache == NULL)
                return -ENOMEM;
-        metapage_mempool = mempool_create(METAPOOL_MIN_PAGES, mempool_alloc_slab,
+        metapage_mempool = mempool_create_slab_pool(METAPOOL_MIN_PAGES,
-                                          mempool_free_slab, metapage_cache);
+                                                    metapage_cache);
        if (metapage_mempool == NULL) {
                kmem_cache_destroy(metapage_cache);
@@ -578,14 +578,13 @@ static int metapage_releasepage(struct page *page, gfp_t gfp_mask)
        return 0;
 }
-static int metapage_invalidatepage(struct page *page, unsigned long offset)
+static void metapage_invalidatepage(struct page *page, unsigned long offset)
 {
        BUG_ON(offset);
-        if (PageWriteback(page))
+        BUG_ON(PageWriteback(page));
-                return 0;
-        return metapage_releasepage(page, 0);
+        metapage_releasepage(page, 0);
 }
 struct address_space_operations jfs_metapage_aops = {
diff --git a/fs/lockd/host.c b/fs/lockd/host.c
index 112ebf8b8dfe..729ac427d359 100644
--- a/fs/lockd/host.c
+++ b/fs/lockd/host.c
@@ -16,6 +16,7 @@
 #include <linux/sunrpc/svc.h>
 #include <linux/lockd/lockd.h>
 #include <linux/lockd/sm_inter.h>
+#include <linux/mutex.h>
 #define NLMDBG_FACILITY         NLMDBG_HOSTCACHE
@@ -30,7 +31,7 @@
 static struct nlm_host *        nlm_hosts[NLM_HOST_NRHASH];
 static unsigned long            next_gc;
 static int                      nrhosts;
-static DECLARE_MUTEX(nlm_host_sema);
+static DEFINE_MUTEX(nlm_host_mutex);
 static void                     nlm_gc_hosts(void);
@@ -71,7 +72,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
        hash = NLM_ADDRHASH(sin->sin_addr.s_addr);
        /* Lock hash table */
-        down(&nlm_host_sema);
+        mutex_lock(&nlm_host_mutex);
        if (time_after_eq(jiffies, next_gc))
                nlm_gc_hosts();
@@ -91,7 +92,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
                                nlm_hosts[hash] = host;
                        }
                        nlm_get_host(host);
-                        up(&nlm_host_sema);
+                        mutex_unlock(&nlm_host_mutex);
                        return host;
                }
        }
@@ -130,7 +131,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
                next_gc = 0;
 nohost:
-        up(&nlm_host_sema);
+        mutex_unlock(&nlm_host_mutex);
        return host;
 }
@@ -141,19 +142,19 @@ nlm_find_client(void)
         * and return it
         */
        int hash;
-        down(&nlm_host_sema);
+        mutex_lock(&nlm_host_mutex);
        for (hash = 0 ; hash < NLM_HOST_NRHASH; hash++) {
                struct nlm_host *host, **hp;
                for (hp = &nlm_hosts[hash]; (host = *hp) != 0; hp = &host->h_next) {
                        if (host->h_server &&
                            host->h_killed == 0) {
                                nlm_get_host(host);
-                                up(&nlm_host_sema);
+                                mutex_unlock(&nlm_host_mutex);
                                return host;
                        }
                }
        }
-        up(&nlm_host_sema);
+        mutex_unlock(&nlm_host_mutex);
        return NULL;
 }
@@ -265,7 +266,7 @@ nlm_shutdown_hosts(void)
        int             i;
        dprintk("lockd: shutting down host module\n");
-        down(&nlm_host_sema);
+        mutex_lock(&nlm_host_mutex);
        /* First, make all hosts eligible for gc */
        dprintk("lockd: nuking all hosts...\n");
@@ -276,7 +277,7 @@ nlm_shutdown_hosts(void)
        /* Then, perform a garbage collection pass */
        nlm_gc_hosts();
-        up(&nlm_host_sema);
+        mutex_unlock(&nlm_host_mutex);
        /* complain if any hosts are left */
        if (nrhosts) {
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 5e85bde6c123..fd56c8872f34 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -25,6 +25,7 @@
 #include <linux/slab.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/stats.h>
@@ -43,13 +44,13 @@ static struct svc_program	nlmsvc_program;
 struct nlmsvc_binding *         nlmsvc_ops;
 EXPORT_SYMBOL(nlmsvc_ops);
-static DECLARE_MUTEX(nlmsvc_sema);
+static DEFINE_MUTEX(nlmsvc_mutex);
 static unsigned int             nlmsvc_users;
 static pid_t                    nlmsvc_pid;
 int                             nlmsvc_grace_period;
 unsigned long                   nlmsvc_timeout;
-static DECLARE_MUTEX_LOCKED(lockd_start);
+static DECLARE_COMPLETION(lockd_start_done);
 static DECLARE_WAIT_QUEUE_HEAD(lockd_exit);
 /*
@@ -112,7 +113,7 @@ lockd(struct svc_rqst *rqstp)
         * Let our maker know we're running.
         */
        nlmsvc_pid = current->pid;
-        up(&lockd_start);
+        complete(&lockd_start_done);
        daemonize("lockd");
@@ -215,7 +216,7 @@ lockd_up(void)
        struct svc_serv *       serv;
        int                     error = 0;
-        down(&nlmsvc_sema);
+        mutex_lock(&nlmsvc_mutex);
        /*
         * Unconditionally increment the user count ... this is
         * the number of clients who _want_ a lockd process.
@@ -263,7 +264,7 @@ lockd_up(void)
                        "lockd_up: create thread failed, error=%d\n", error);
                goto destroy_and_out;
        }
-        down(&lockd_start);
+        wait_for_completion(&lockd_start_done);
        /*
         * Note: svc_serv structures have an initial use count of 1,
@@ -272,7 +273,7 @@ lockd_up(void)
 destroy_and_out:
        svc_destroy(serv);
 out:
-        up(&nlmsvc_sema);
+        mutex_unlock(&nlmsvc_mutex);
        return error;
 }
 EXPORT_SYMBOL(lockd_up);
@@ -285,7 +286,7 @@ lockd_down(void)
 {
        static int warned;
-        down(&nlmsvc_sema);
+        mutex_lock(&nlmsvc_mutex);
        if (nlmsvc_users) {
                if (--nlmsvc_users)
                        goto out;
@@ -315,7 +316,7 @@ lockd_down(void)
        recalc_sigpending();
        spin_unlock_irq(&current->sighand->siglock);
 out:
-        up(&nlmsvc_sema);
+        mutex_unlock(&nlmsvc_mutex);
 }
 EXPORT_SYMBOL(lockd_down);
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index c7a6e3ae44d6..a570e5c8a930 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -11,6 +11,7 @@
 #include <linux/string.h>
 #include <linux/time.h>
 #include <linux/in.h>
+#include <linux/mutex.h>
 #include <linux/sunrpc/svc.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/nfsd/nfsfh.h>
@@ -28,7 +29,7 @@
 #define FILE_HASH_BITS          5
 #define FILE_NRHASH             (1<<FILE_HASH_BITS)
 static struct nlm_file *        nlm_files[FILE_NRHASH];
-static DECLARE_MUTEX(nlm_file_sema);
+static DEFINE_MUTEX(nlm_file_mutex);
 #ifdef NFSD_DEBUG
 static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
@@ -91,7 +92,7 @@ nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result,
        hash = file_hash(f);
        /* Lock file table */
-        down(&nlm_file_sema);
+        mutex_lock(&nlm_file_mutex);
        for (file = nlm_files[hash]; file; file = file->f_next)
                if (!nfs_compare_fh(&file->f_handle, f))
@@ -130,7 +131,7 @@ found:
        nfserr = 0;
 out_unlock:
-        up(&nlm_file_sema);
+        mutex_unlock(&nlm_file_mutex);
        return nfserr;
 out_free:
@@ -239,14 +240,14 @@ nlm_traverse_files(struct nlm_host *host, int action)
        struct nlm_file *file, **fp;
        int             i;
-        down(&nlm_file_sema);
+        mutex_lock(&nlm_file_mutex);
        for (i = 0; i < FILE_NRHASH; i++) {
                fp = nlm_files + i;
                while ((file = *fp) != NULL) {
                        /* Traverse locks, blocks and shares of this file
                         * and update file->f_locks count */
                        if (nlm_inspect_file(host, file, action)) {
-                                up(&nlm_file_sema);
+                                mutex_unlock(&nlm_file_mutex);
                                return 1;
                        }
@@ -261,7 +262,7 @@ nlm_traverse_files(struct nlm_host *host, int action)
                        }
                }
        }
-        up(&nlm_file_sema);
+        mutex_unlock(&nlm_file_mutex);
        return 0;
 }
@@ -281,7 +282,7 @@ nlm_release_file(struct nlm_file *file)
                                file, file->f_count);
        /* Lock file table */
-        down(&nlm_file_sema);
+        mutex_lock(&nlm_file_mutex);
        /* If there are no more locks etc, delete the file */
        if(--file->f_count == 0) {
@@ -289,7 +290,7 @@ nlm_release_file(struct nlm_file *file)
                        nlm_delete_file(file);
        }
-        up(&nlm_file_sema);
+        mutex_unlock(&nlm_file_mutex);
 }
 /*
diff --git a/fs/locks.c b/fs/locks.c
index 56f996e98bbc..4d9e71d43e7e 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -142,7 +142,7 @@ int lease_break_time = 45;
 static LIST_HEAD(file_lock_list);
 static LIST_HEAD(blocked_list);
-static kmem_cache_t *filelock_cache;
+static kmem_cache_t *filelock_cache __read_mostly;
 /* Allocate an empty lock structure. */
 static struct file_lock *locks_alloc_lock(void)
@@ -533,12 +533,7 @@ static void locks_delete_block(struct file_lock *waiter)
 static void locks_insert_block(struct file_lock *blocker, 
                               struct file_lock *waiter)
 {
-        if (!list_empty(&waiter->fl_block)) {
+        BUG_ON(!list_empty(&waiter->fl_block));
-                printk(KERN_ERR "locks_insert_block: removing duplicated lock "
-                        "(pid=%d %Ld-%Ld type=%d)\n", waiter->fl_pid,
-                        waiter->fl_start, waiter->fl_end, waiter->fl_type);
-                __locks_delete_block(waiter);
-        }
        list_add_tail(&waiter->fl_block, &blocker->fl_block);
        waiter->fl_next = blocker;
        if (IS_POSIX(blocker))
@@ -797,9 +792,7 @@ out:
        return error;
 }
-EXPORT_SYMBOL(posix_lock_file);
+static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
-static int __posix_lock_file(struct inode *inode, struct file_lock *request)
 {
        struct file_lock *fl;
        struct file_lock *new_fl, *new_fl2;
@@ -823,6 +816,8 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request)
                                continue;
                        if (!posix_locks_conflict(request, fl))
                                continue;
+                        if (conflock)
+                                locks_copy_lock(conflock, fl);
                        error = -EAGAIN;
                        if (!(request->fl_flags & FL_SLEEP))
                                goto out;
@@ -992,8 +987,24 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request)
 */
 int posix_lock_file(struct file *filp, struct file_lock *fl)
 {
-        return __posix_lock_file(filp->f_dentry->d_inode, fl);
+        return __posix_lock_file_conf(filp->f_dentry->d_inode, fl, NULL);
+}
+EXPORT_SYMBOL(posix_lock_file);
+/**
+ * posix_lock_file_conf - Apply a POSIX-style lock to a file
+ * @filp: The file to apply the lock to
+ * @fl: The lock to be applied
+ * @conflock: Place to return a copy of the conflicting lock, if found.
+ *
+ * Except for the conflock parameter, acts just like posix_lock_file.
+ */
+int posix_lock_file_conf(struct file *filp, struct file_lock *fl,
+                        struct file_lock *conflock)
+{
+        return __posix_lock_file_conf(filp->f_dentry->d_inode, fl, conflock);
 }
+EXPORT_SYMBOL(posix_lock_file_conf);
 /**
 * posix_lock_file_wait - Apply a POSIX-style lock to a file
@@ -1009,7 +1020,7 @@ int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
        int error;
        might_sleep ();
        for (;;) {
-                error = __posix_lock_file(filp->f_dentry->d_inode, fl);
+                error = posix_lock_file(filp, fl);
                if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP))
                        break;
                error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
@@ -1081,7 +1092,7 @@ int locks_mandatory_area(int read_write, struct inode *inode,
        fl.fl_end = offset + count - 1;
        for (;;) {
-                error = __posix_lock_file(inode, &fl);
+                error = __posix_lock_file_conf(inode, &fl, NULL);
                if (error != -EAGAIN)
                        break;
                if (!(fl.fl_flags & FL_SLEEP))
@@ -1694,7 +1705,7 @@ again:
                error = filp->f_op->lock(filp, cmd, file_lock);
        else {
                for (;;) {
-                        error = __posix_lock_file(inode, file_lock);
+                        error = posix_lock_file(filp, file_lock);
                        if ((error != -EAGAIN) || (cmd == F_SETLK))
                                break;
                        error = wait_event_interruptible(file_lock->fl_wait,
@@ -1837,7 +1848,7 @@ again:
                error = filp->f_op->lock(filp, cmd, file_lock);
        else {
                for (;;) {
-                        error = __posix_lock_file(inode, file_lock);
+                        error = posix_lock_file(filp, file_lock);
                        if ((error != -EAGAIN) || (cmd == F_SETLK64))
                                break;
                        error = wait_event_interruptible(file_lock->fl_wait,
diff --git a/fs/mpage.c b/fs/mpage.c
index e431cb3878d6..9bf2eb30e6f4 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -163,9 +163,19 @@ map_buffer_to_page(struct page *page, struct buffer_head *bh, int page_block)
        } while (page_bh != head);
 }
+/*
+ * This is the worker routine which does all the work of mapping the disk
+ * blocks and constructs largest possible bios, submits them for IO if the
+ * blocks are not contiguous on the disk.
+ *
+ * We pass a buffer_head back and forth and use its buffer_mapped() flag to
+ * represent the validity of its disk mapping and to decide when to do the next
+ * get_block() call.
+ */
 static struct bio *
 do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
-                        sector_t *last_block_in_bio, get_block_t get_block)
+                sector_t *last_block_in_bio, struct buffer_head *map_bh,
+                unsigned long *first_logical_block, get_block_t get_block)
 {
        struct inode *inode = page->mapping->host;
        const unsigned blkbits = inode->i_blkbits;
@@ -173,33 +183,72 @@ do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
        const unsigned blocksize = 1 << blkbits;
        sector_t block_in_file;
        sector_t last_block;
+        sector_t last_block_in_file;
        sector_t blocks[MAX_BUF_PER_PAGE];
        unsigned page_block;
        unsigned first_hole = blocks_per_page;
        struct block_device *bdev = NULL;
-        struct buffer_head bh;
        int length;
        int fully_mapped = 1;
+        unsigned nblocks;
+        unsigned relative_block;
        if (page_has_buffers(page))
                goto confused;
        block_in_file = (sector_t)page->index << (PAGE_CACHE_SHIFT - blkbits);
-        last_block = (i_size_read(inode) + blocksize - 1) >> blkbits;
+        last_block = block_in_file + nr_pages * blocks_per_page;
+        last_block_in_file = (i_size_read(inode) + blocksize - 1) >> blkbits;
+        if (last_block > last_block_in_file)
+                last_block = last_block_in_file;
+        page_block = 0;
+        /*
+         * Map blocks using the result from the previous get_blocks call first.
+         */
+        nblocks = map_bh->b_size >> blkbits;
+        if (buffer_mapped(map_bh) && block_in_file > *first_logical_block &&
+                        block_in_file < (*first_logical_block + nblocks)) {
+                unsigned map_offset = block_in_file - *first_logical_block;
+                unsigned last = nblocks - map_offset;
+                for (relative_block = 0; ; relative_block++) {
+                        if (relative_block == last) {
+                                clear_buffer_mapped(map_bh);
+                                break;
+                        }
+                        if (page_block == blocks_per_page)
+                                break;
+                        blocks[page_block] = map_bh->b_blocknr + map_offset +
+                                                relative_block;
+                        page_block++;
+                        block_in_file++;
+                }
+                bdev = map_bh->b_bdev;
+        }
+        /*
+         * Then do more get_blocks calls until we are done with this page.
+         */
+        map_bh->b_page = page;
+        while (page_block < blocks_per_page) {
+                map_bh->b_state = 0;
+                map_bh->b_size = 0;
-        bh.b_page = page;
-        for (page_block = 0; page_block < blocks_per_page;
-                                page_block++, block_in_file++) {
-                bh.b_state = 0;
                if (block_in_file < last_block) {
-                        if (get_block(inode, block_in_file, &bh, 0))
+                        map_bh->b_size = (last_block-block_in_file) << blkbits;
+                        if (get_block(inode, block_in_file, map_bh, 0))
                                goto confused;
+                        *first_logical_block = block_in_file;
                }
-                if (!buffer_mapped(&bh)) {
+                if (!buffer_mapped(map_bh)) {
                        fully_mapped = 0;
                        if (first_hole == blocks_per_page)
                                first_hole = page_block;
+                        page_block++;
+                        block_in_file++;
+                        clear_buffer_mapped(map_bh);
                        continue;
                }
@@ -209,8 +258,8 @@ do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
                 * we just collected from get_block into the page's buffers
                 * so readpage doesn't have to repeat the get_block call
                 */
-                if (buffer_uptodate(&bh)) {
+                if (buffer_uptodate(map_bh)) {
-                        map_buffer_to_page(page, &bh, page_block);
+                        map_buffer_to_page(page, map_bh, page_block);
                        goto confused;
                }
        
@@ -218,10 +267,20 @@ do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
                        goto confused;          /* hole -> non-hole */
                /* Contiguous blocks? */
-                if (page_block && blocks[page_block-1] != bh.b_blocknr-1)
+                if (page_block && blocks[page_block-1] != map_bh->b_blocknr-1)
                        goto confused;
-                blocks[page_block] = bh.b_blocknr;
+                nblocks = map_bh->b_size >> blkbits;
-                bdev = bh.b_bdev;
+                for (relative_block = 0; ; relative_block++) {
+                        if (relative_block == nblocks) {
+                                clear_buffer_mapped(map_bh);
+                                break;
+                        } else if (page_block == blocks_per_page)
+                                break;
+                        blocks[page_block] = map_bh->b_blocknr+relative_block;
+                        page_block++;
+                        block_in_file++;
+                }
+                bdev = map_bh->b_bdev;
        }
        if (first_hole != blocks_per_page) {
@@ -260,7 +319,7 @@ alloc_new:
                goto alloc_new;
        }
-        if (buffer_boundary(&bh) || (first_hole != blocks_per_page))
+        if (buffer_boundary(map_bh) || (first_hole != blocks_per_page))
                bio = mpage_bio_submit(READ, bio);
        else
                *last_block_in_bio = blocks[blocks_per_page - 1];
@@ -331,7 +390,10 @@ mpage_readpages(struct address_space *mapping, struct list_head *pages,
        unsigned page_idx;
        sector_t last_block_in_bio = 0;
        struct pagevec lru_pvec;
+        struct buffer_head map_bh;
+        unsigned long first_logical_block = 0;
+        clear_buffer_mapped(&map_bh);
        pagevec_init(&lru_pvec, 0);
        for (page_idx = 0; page_idx < nr_pages; page_idx++) {
                struct page *page = list_entry(pages->prev, struct page, lru);
@@ -342,7 +404,9 @@ mpage_readpages(struct address_space *mapping, struct list_head *pages,
                                        page->index, GFP_KERNEL)) {
                        bio = do_mpage_readpage(bio, page,
                                        nr_pages - page_idx,
-                                        &last_block_in_bio, get_block);
+                                        &last_block_in_bio, &map_bh,
+                                        &first_logical_block,
+                                        get_block);
                        if (!pagevec_add(&lru_pvec, page))
                                __pagevec_lru_add(&lru_pvec);
                } else {
@@ -364,9 +428,12 @@ int mpage_readpage(struct page *page, get_block_t get_block)
 {
        struct bio *bio = NULL;
        sector_t last_block_in_bio = 0;
+        struct buffer_head map_bh;
+        unsigned long first_logical_block = 0;
-        bio = do_mpage_readpage(bio, page, 1,
+        clear_buffer_mapped(&map_bh);
-                        &last_block_in_bio, get_block);
+        bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio,
+                        &map_bh, &first_logical_block, get_block);
        if (bio)
                mpage_bio_submit(READ, bio);
        return 0;
@@ -472,6 +539,7 @@ __mpage_writepage(struct bio *bio, struct page *page, get_block_t get_block,
        for (page_block = 0; page_block < blocks_per_page; ) {
                map_bh.b_state = 0;
+                map_bh.b_size = 1 << blkbits;
                if (get_block(inode, block_in_file, &map_bh, 1))
                        goto confused;
                if (buffer_new(&map_bh))
diff --git a/fs/namei.c b/fs/namei.c
index 98dc2e134362..22f6e8d16aa8 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -546,6 +546,22 @@ struct path {
        struct dentry *dentry;
 };
+static inline void dput_path(struct path *path, struct nameidata *nd)
+{
+        dput(path->dentry);
+        if (path->mnt != nd->mnt)
+                mntput(path->mnt);
+}
+static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
+{
+        dput(nd->dentry);
+        if (nd->mnt != path->mnt)
+                mntput(nd->mnt);
+        nd->mnt = path->mnt;
+        nd->dentry = path->dentry;
+}
 static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
 {
        int error;
@@ -555,8 +571,11 @@ static __always_inline int __do_follow_link(struct path *path, struct nameidata
        touch_atime(path->mnt, dentry);
        nd_set_link(nd, NULL);
-        if (path->mnt == nd->mnt)
+        if (path->mnt != nd->mnt) {
-                mntget(path->mnt);
+                path_to_nameidata(path, nd);
+                dget(dentry);
+        }
+        mntget(path->mnt);
        cookie = dentry->d_inode->i_op->follow_link(dentry, nd);
        error = PTR_ERR(cookie);
        if (!IS_ERR(cookie)) {
@@ -573,22 +592,6 @@ static __always_inline int __do_follow_link(struct path *path, struct nameidata
        return error;
 }
-static inline void dput_path(struct path *path, struct nameidata *nd)
-{
-        dput(path->dentry);
-        if (path->mnt != nd->mnt)
-                mntput(path->mnt);
-}
-static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
-{
-        dput(nd->dentry);
-        if (nd->mnt != path->mnt)
-                mntput(nd->mnt);
-        nd->mnt = path->mnt;
-        nd->dentry = path->dentry;
-}
 /*
 * This limits recursive symlink follows to 8, while
 * limiting consecutive symlinks to 40.
diff --git a/fs/namespace.c b/fs/namespace.c
index 71e75bcf4d28..bf478addb852 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -43,9 +43,9 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock);
 static int event;
-static struct list_head *mount_hashtable;
+static struct list_head *mount_hashtable __read_mostly;
 static int hash_mask __read_mostly, hash_bits __read_mostly;
-static kmem_cache_t *mnt_cache;
+static kmem_cache_t *mnt_cache __read_mostly;
 static struct rw_semaphore namespace_sem;
 /* /sys/fs */
@@ -459,9 +459,9 @@ int may_umount_tree(struct vfsmount *mnt)
        spin_unlock(&vfsmount_lock);
        if (actual_refs > minimum_refs)
-                return -EBUSY;
+                return 0;
-        return 0;
+        return 1;
 }
 EXPORT_SYMBOL(may_umount_tree);
@@ -481,10 +481,10 @@ EXPORT_SYMBOL(may_umount_tree);
 */
 int may_umount(struct vfsmount *mnt)
 {
-        int ret = 0;
+        int ret = 1;
        spin_lock(&vfsmount_lock);
        if (propagate_mount_busy(mnt, 2))
-                ret = -EBUSY;
+                ret = 0;
        spin_unlock(&vfsmount_lock);
        return ret;
 }
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 99d2cfbce863..90c95adc8c1b 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -14,6 +14,7 @@
 #include <linux/sunrpc/svc.h>
 #include <linux/sunrpc/svcsock.h>
 #include <linux/nfs_fs.h>
+#include <linux/mutex.h>
 #include <net/inet_sock.h>
@@ -31,7 +32,7 @@ struct nfs_callback_data {
 };
 static struct nfs_callback_data nfs_callback_info;
-static DECLARE_MUTEX(nfs_callback_sema);
+static DEFINE_MUTEX(nfs_callback_mutex);
 static struct svc_program nfs4_callback_program;
 unsigned int nfs_callback_set_tcpport;
@@ -95,7 +96,7 @@ int nfs_callback_up(void)
        int ret = 0;
        lock_kernel();
-        down(&nfs_callback_sema);
+        mutex_lock(&nfs_callback_mutex);
        if (nfs_callback_info.users++ || nfs_callback_info.pid != 0)
                goto out;
        init_completion(&nfs_callback_info.started);
@@ -121,7 +122,7 @@ int nfs_callback_up(void)
        nfs_callback_info.serv = serv;
        wait_for_completion(&nfs_callback_info.started);
 out:
-        up(&nfs_callback_sema);
+        mutex_unlock(&nfs_callback_mutex);
        unlock_kernel();
        return ret;
 out_destroy:
@@ -139,7 +140,7 @@ int nfs_callback_down(void)
        int ret = 0;
        lock_kernel();
-        down(&nfs_callback_sema);
+        mutex_lock(&nfs_callback_mutex);
        nfs_callback_info.users--;
        do {
                if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0)
@@ -147,7 +148,7 @@ int nfs_callback_down(void)
                if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0)
                        break;
        } while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0);
-        up(&nfs_callback_sema);
+        mutex_unlock(&nfs_callback_mutex);
        unlock_kernel();
        return ret;
 }
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 5263b2864a44..dee49a0cb995 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -318,10 +318,9 @@ static int nfs_commit_write(struct file *file, struct page *page, unsigned offse
        return status;
 }
-static int nfs_invalidate_page(struct page *page, unsigned long offset)
+static void nfs_invalidate_page(struct page *page, unsigned long offset)
 {
        /* FIXME: we really should cancel any unstarted writes on this page */
-        return 1;
 }
 static int nfs_release_page(struct page *page, gfp_t gfp)
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 3961524fd4ab..624ca7146b6b 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -663,10 +663,8 @@ int nfs_init_readpagecache(void)
        if (nfs_rdata_cachep == NULL)
                return -ENOMEM;
-        nfs_rdata_mempool = mempool_create(MIN_POOL_READ,
+        nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
-                                           mempool_alloc_slab,
+                                                     nfs_rdata_cachep);
-                                           mempool_free_slab,
-                                           nfs_rdata_cachep);
        if (nfs_rdata_mempool == NULL)
                return -ENOMEM;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 3f5225404c97..4cfada2cc09f 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1521,17 +1521,13 @@ int nfs_init_writepagecache(void)
        if (nfs_wdata_cachep == NULL)
                return -ENOMEM;
-        nfs_wdata_mempool = mempool_create(MIN_POOL_WRITE,
+        nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
-                                           mempool_alloc_slab,
+                                                     nfs_wdata_cachep);
-                                           mempool_free_slab,
-                                           nfs_wdata_cachep);
        if (nfs_wdata_mempool == NULL)
                return -ENOMEM;
-        nfs_commit_mempool = mempool_create(MIN_POOL_COMMIT,
+        nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
-                                           mempool_alloc_slab,
+                                                      nfs_wdata_cachep);
-                                           mempool_free_slab,
-                                           nfs_wdata_cachep);
        if (nfs_commit_mempool == NULL)
                return -ENOMEM;
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 417ec02df44f..c340be0a3f59 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -57,27 +57,17 @@ static int		exp_verify_string(char *cp, int max);
 #define EXPKEY_HASHMASK         (EXPKEY_HASHMAX -1)
 static struct cache_head *expkey_table[EXPKEY_HASHMAX];
-static inline int svc_expkey_hash(struct svc_expkey *item)
+static void expkey_put(struct kref *ref)
 {
-        int hash = item->ek_fsidtype;
+        struct svc_expkey *key = container_of(ref, struct svc_expkey, h.ref);
-        char * cp = (char*)item->ek_fsid;
-        int len = key_len(item->ek_fsidtype);
-        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
+        if (test_bit(CACHE_VALID, &key->h.flags) &&
-        hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
+            !test_bit(CACHE_NEGATIVE, &key->h.flags)) {
-        return hash & EXPKEY_HASHMASK;
+                dput(key->ek_dentry);
-}
+                mntput(key->ek_mnt);
-void expkey_put(struct cache_head *item, struct cache_detail *cd)
-{
-        if (cache_put(item, cd)) {
-                struct svc_expkey *key = container_of(item, struct svc_expkey, h);
-                if (test_bit(CACHE_VALID, &item->flags) &&
-                    !test_bit(CACHE_NEGATIVE, &item->flags))
-                        exp_put(key->ek_export);
-                auth_domain_put(key->ek_client);
-                kfree(key);
        }
+        auth_domain_put(key->ek_client);
+        kfree(key);
 }
 static void expkey_request(struct cache_detail *cd,
@@ -95,7 +85,10 @@ static void expkey_request(struct cache_detail *cd,
        (*bpp)[-1] = '\n';
 }
-static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *, int);
+static struct svc_expkey *svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old);
+static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *);
+static struct cache_detail svc_expkey_cache;
 static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
 {
        /* client fsidtype fsid [path] */
@@ -106,6 +99,7 @@ static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
        int fsidtype;
        char *ep;
        struct svc_expkey key;
+        struct svc_expkey *ek;
        if (mesg[mlen-1] != '\n')
                return -EINVAL;
@@ -150,40 +144,38 @@ static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
        key.ek_fsidtype = fsidtype;
        memcpy(key.ek_fsid, buf, len);
+        ek = svc_expkey_lookup(&key);
+        err = -ENOMEM;
+        if (!ek)
+                goto out;
        /* now we want a pathname, or empty meaning NEGATIVE  */
+        err = -EINVAL;
        if ((len=qword_get(&mesg, buf, PAGE_SIZE)) < 0)
                goto out;
        dprintk("Path seems to be <%s>\n", buf);
        err = 0;
        if (len == 0) {
-                struct svc_expkey *ek;
                set_bit(CACHE_NEGATIVE, &key.h.flags);
-                ek = svc_expkey_lookup(&key, 1);
+                ek = svc_expkey_update(&key, ek);
                if (ek)
-                        expkey_put(&ek->h, &svc_expkey_cache);
+                        cache_put(&ek->h, &svc_expkey_cache);
+                else err = -ENOMEM;
        } else {
                struct nameidata nd;
-                struct svc_expkey *ek;
-                struct svc_export *exp;
                err = path_lookup(buf, 0, &nd);
                if (err)
                        goto out;
                dprintk("Found the path %s\n", buf);
-                exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
+                key.ek_mnt = nd.mnt;
+                key.ek_dentry = nd.dentry;
-                err = -ENOENT;
-                if (!exp)
-                        goto out_nd;
-                key.ek_export = exp;
-                dprintk("And found export\n");
                
-                ek = svc_expkey_lookup(&key, 1);
+                ek = svc_expkey_update(&key, ek);
                if (ek)
-                        expkey_put(&ek->h, &svc_expkey_cache);
+                        cache_put(&ek->h, &svc_expkey_cache);
-                exp_put(exp);
+                else
-                err = 0;
+                        err = -ENOMEM;
-        out_nd:
                path_release(&nd);
        }
        cache_flush();
@@ -214,35 +206,31 @@ static int expkey_show(struct seq_file *m,
        if (test_bit(CACHE_VALID, &h->flags) && 
            !test_bit(CACHE_NEGATIVE, &h->flags)) {
                seq_printf(m, " ");
-                seq_path(m, ek->ek_export->ex_mnt, ek->ek_export->ex_dentry, "\\ \t\n");
+                seq_path(m, ek->ek_mnt, ek->ek_dentry, "\\ \t\n");
        }
        seq_printf(m, "\n");
        return 0;
 }
-        
-struct cache_detail svc_expkey_cache = {
-        .owner          = THIS_MODULE,
-        .hash_size      = EXPKEY_HASHMAX,
-        .hash_table     = expkey_table,
-        .name           = "nfsd.fh",
-        .cache_put      = expkey_put,
-        .cache_request  = expkey_request,
-        .cache_parse    = expkey_parse,
-        .cache_show     = expkey_show,
-};
-static inline int svc_expkey_match (struct svc_expkey *a, struct svc_expkey *b)
+static inline int expkey_match (struct cache_head *a, struct cache_head *b)
 {
-        if (a->ek_fsidtype != b->ek_fsidtype ||
+        struct svc_expkey *orig = container_of(a, struct svc_expkey, h);
-            a->ek_client != b->ek_client ||
+        struct svc_expkey *new = container_of(b, struct svc_expkey, h);
-            memcmp(a->ek_fsid, b->ek_fsid, key_len(a->ek_fsidtype)) != 0)
+        if (orig->ek_fsidtype != new->ek_fsidtype ||
+            orig->ek_client != new->ek_client ||
+            memcmp(orig->ek_fsid, new->ek_fsid, key_len(orig->ek_fsidtype)) != 0)
                return 0;
        return 1;
 }
-static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *item)
+static inline void expkey_init(struct cache_head *cnew,
+                                   struct cache_head *citem)
 {
-        cache_get(&item->ek_client->h);
+        struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
+        struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
+        kref_get(&item->ek_client->ref);
        new->ek_client = item->ek_client;
        new->ek_fsidtype = item->ek_fsidtype;
        new->ek_fsid[0] = item->ek_fsid[0];
@@ -250,39 +238,94 @@ static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *it
        new->ek_fsid[2] = item->ek_fsid[2];
 }
-static inline void svc_expkey_update(struct svc_expkey *new, struct svc_expkey *item)
+static inline void expkey_update(struct cache_head *cnew,
+                                   struct cache_head *citem)
+{
+        struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
+        struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
+        new->ek_mnt = mntget(item->ek_mnt);
+        new->ek_dentry = dget(item->ek_dentry);
+}
+static struct cache_head *expkey_alloc(void)
 {
-        cache_get(&item->ek_export->h);
+        struct svc_expkey *i = kmalloc(sizeof(*i), GFP_KERNEL);
-        new->ek_export = item->ek_export;
+        if (i)
+                return &i->h;
+        else
+                return NULL;
 }
-static DefineSimpleCacheLookup(svc_expkey,0) /* no inplace updates */
+static struct cache_detail svc_expkey_cache = {
+        .owner          = THIS_MODULE,
+        .hash_size      = EXPKEY_HASHMAX,
+        .hash_table     = expkey_table,
+        .name           = "nfsd.fh",
+        .cache_put      = expkey_put,
+        .cache_request  = expkey_request,
+        .cache_parse    = expkey_parse,
+        .cache_show     = expkey_show,
+        .match          = expkey_match,
+        .init           = expkey_init,
+        .update         = expkey_update,
+        .alloc          = expkey_alloc,
+};
-#define EXPORT_HASHBITS         8
+static struct svc_expkey *
-#define EXPORT_HASHMAX          (1<< EXPORT_HASHBITS)
+svc_expkey_lookup(struct svc_expkey *item)
-#define EXPORT_HASHMASK         (EXPORT_HASHMAX -1)
+{
+        struct cache_head *ch;
+        int hash = item->ek_fsidtype;
+        char * cp = (char*)item->ek_fsid;
+        int len = key_len(item->ek_fsidtype);
-static struct cache_head *export_table[EXPORT_HASHMAX];
+        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
+        hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
+        hash &= EXPKEY_HASHMASK;
-static inline int svc_export_hash(struct svc_export *item)
+        ch = sunrpc_cache_lookup(&svc_expkey_cache, &item->h,
+                                 hash);
+        if (ch)
+                return container_of(ch, struct svc_expkey, h);
+        else
+                return NULL;
+}
+static struct svc_expkey *
+svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old)
 {
-        int rv;
+        struct cache_head *ch;
+        int hash = new->ek_fsidtype;
+        char * cp = (char*)new->ek_fsid;
+        int len = key_len(new->ek_fsidtype);
-        rv = hash_ptr(item->ex_client, EXPORT_HASHBITS);
+        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
-        rv ^= hash_ptr(item->ex_dentry, EXPORT_HASHBITS);
+        hash ^= hash_ptr(new->ek_client, EXPKEY_HASHBITS);
-        rv ^= hash_ptr(item->ex_mnt, EXPORT_HASHBITS);
+        hash &= EXPKEY_HASHMASK;
-        return rv;
+        ch = sunrpc_cache_update(&svc_expkey_cache, &new->h,
+                                 &old->h, hash);
+        if (ch)
+                return container_of(ch, struct svc_expkey, h);
+        else
+                return NULL;
 }
-void svc_export_put(struct cache_head *item, struct cache_detail *cd)
+#define EXPORT_HASHBITS         8
+#define EXPORT_HASHMAX          (1<< EXPORT_HASHBITS)
+#define EXPORT_HASHMASK         (EXPORT_HASHMAX -1)
+static struct cache_head *export_table[EXPORT_HASHMAX];
+static void svc_export_put(struct kref *ref)
 {
-        if (cache_put(item, cd)) {
+        struct svc_export *exp = container_of(ref, struct svc_export, h.ref);
-                struct svc_export *exp = container_of(item, struct svc_export, h);
+        dput(exp->ex_dentry);
-                dput(exp->ex_dentry);
+        mntput(exp->ex_mnt);
-                mntput(exp->ex_mnt);
+        auth_domain_put(exp->ex_client);
-                auth_domain_put(exp->ex_client);
+        kfree(exp);
-                kfree(exp);
-        }
 }
 static void svc_export_request(struct cache_detail *cd,
@@ -304,7 +347,9 @@ static void svc_export_request(struct cache_detail *cd,
        (*bpp)[-1] = '\n';
 }
-static struct svc_export *svc_export_lookup(struct svc_export *, int);
+static struct svc_export *svc_export_update(struct svc_export *new,
+                                            struct svc_export *old);
+static struct svc_export *svc_export_lookup(struct svc_export *);
 static int check_export(struct inode *inode, int flags)
 {
@@ -417,11 +462,16 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                if (err) goto out;
        }
-        expp = svc_export_lookup(&exp, 1);
+        expp = svc_export_lookup(&exp);
        if (expp)
-                exp_put(expp);
+                expp = svc_export_update(&exp, expp);
-        err = 0;
+        else
+                err = -ENOMEM;
        cache_flush();
+        if (expp == NULL)
+                err = -ENOMEM;
+        else
+                exp_put(expp);
 out:
        if (nd.dentry)
                path_release(&nd);
@@ -455,6 +505,46 @@ static int svc_export_show(struct seq_file *m,
        seq_puts(m, ")\n");
        return 0;
 }
+static int svc_export_match(struct cache_head *a, struct cache_head *b)
+{
+        struct svc_export *orig = container_of(a, struct svc_export, h);
+        struct svc_export *new = container_of(b, struct svc_export, h);
+        return orig->ex_client == new->ex_client &&
+                orig->ex_dentry == new->ex_dentry &&
+                orig->ex_mnt == new->ex_mnt;
+}
+static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct svc_export *new = container_of(cnew, struct svc_export, h);
+        struct svc_export *item = container_of(citem, struct svc_export, h);
+        kref_get(&item->ex_client->ref);
+        new->ex_client = item->ex_client;
+        new->ex_dentry = dget(item->ex_dentry);
+        new->ex_mnt = mntget(item->ex_mnt);
+}
+static void export_update(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct svc_export *new = container_of(cnew, struct svc_export, h);
+        struct svc_export *item = container_of(citem, struct svc_export, h);
+        new->ex_flags = item->ex_flags;
+        new->ex_anon_uid = item->ex_anon_uid;
+        new->ex_anon_gid = item->ex_anon_gid;
+        new->ex_fsid = item->ex_fsid;
+}
+static struct cache_head *svc_export_alloc(void)
+{
+        struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL);
+        if (i)
+                return &i->h;
+        else
+                return NULL;
+}
 struct cache_detail svc_export_cache = {
        .owner          = THIS_MODULE,
        .hash_size      = EXPORT_HASHMAX,
@@ -464,34 +554,49 @@ struct cache_detail svc_export_cache = {
        .cache_request  = svc_export_request,
        .cache_parse    = svc_export_parse,
        .cache_show     = svc_export_show,
+        .match          = svc_export_match,
+        .init           = svc_export_init,
+        .update         = export_update,
+        .alloc          = svc_export_alloc,
 };
-static inline int svc_export_match(struct svc_export *a, struct svc_export *b)
+static struct svc_export *
+svc_export_lookup(struct svc_export *exp)
 {
-        return a->ex_client == b->ex_client &&
+        struct cache_head *ch;
-                a->ex_dentry == b->ex_dentry &&
+        int hash;
-                a->ex_mnt == b->ex_mnt;
+        hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS);
-}
+        hash ^= hash_ptr(exp->ex_dentry, EXPORT_HASHBITS);
-static inline void svc_export_init(struct svc_export *new, struct svc_export *item)
+        hash ^= hash_ptr(exp->ex_mnt, EXPORT_HASHBITS);
-{
-        cache_get(&item->ex_client->h);
+        ch = sunrpc_cache_lookup(&svc_export_cache, &exp->h,
-        new->ex_client = item->ex_client;
+                                 hash);
-        new->ex_dentry = dget(item->ex_dentry);
+        if (ch)
-        new->ex_mnt = mntget(item->ex_mnt);
+                return container_of(ch, struct svc_export, h);
+        else
+                return NULL;
 }
-static inline void svc_export_update(struct svc_export *new, struct svc_export *item)
+static struct svc_export *
+svc_export_update(struct svc_export *new, struct svc_export *old)
 {
-        new->ex_flags = item->ex_flags;
+        struct cache_head *ch;
-        new->ex_anon_uid = item->ex_anon_uid;
+        int hash;
-        new->ex_anon_gid = item->ex_anon_gid;
+        hash = hash_ptr(old->ex_client, EXPORT_HASHBITS);
-        new->ex_fsid = item->ex_fsid;
+        hash ^= hash_ptr(old->ex_dentry, EXPORT_HASHBITS);
+        hash ^= hash_ptr(old->ex_mnt, EXPORT_HASHBITS);
+        ch = sunrpc_cache_update(&svc_export_cache, &new->h,
+                                 &old->h,
+                                 hash);
+        if (ch)
+                return container_of(ch, struct svc_export, h);
+        else
+                return NULL;
 }
-static DefineSimpleCacheLookup(svc_export,1) /* allow inplace updates */
+static struct svc_expkey *
-struct svc_expkey *
 exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
 {
        struct svc_expkey key, *ek;
@@ -504,7 +609,7 @@ exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
        key.ek_fsidtype = fsid_type;
        memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
-        ek = svc_expkey_lookup(&key, 0);
+        ek = svc_expkey_lookup(&key);
        if (ek != NULL)
                if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
                        ek = ERR_PTR(err);
@@ -519,13 +624,16 @@ static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
        key.ek_client = clp;
        key.ek_fsidtype = fsid_type;
        memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
-        key.ek_export = exp;
+        key.ek_mnt = exp->ex_mnt;
+        key.ek_dentry = exp->ex_dentry;
        key.h.expiry_time = NEVER;
        key.h.flags = 0;
-        ek = svc_expkey_lookup(&key, 1);
+        ek = svc_expkey_lookup(&key);
+        if (ek)
+                ek = svc_expkey_update(&key,ek);
        if (ek) {
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
                return 0;
        }
        return -ENOMEM;
@@ -573,7 +681,7 @@ exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
        key.ex_mnt = mnt;
        key.ex_dentry = dentry;
-        exp = svc_export_lookup(&key, 0);
+        exp = svc_export_lookup(&key);
        if (exp != NULL) 
                switch (cache_check(&svc_export_cache, &exp->h, reqp)) {
                case 0: break;
@@ -654,7 +762,7 @@ static void exp_fsid_unhash(struct svc_export *exp)
        ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
        if (ek && !IS_ERR(ek)) {
                ek->h.expiry_time = get_seconds()-1;
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
        }
        svc_expkey_cache.nextcheck = get_seconds();
 }
@@ -692,7 +800,7 @@ static void exp_unhash(struct svc_export *exp)
        ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
        if (ek && !IS_ERR(ek)) {
                ek->h.expiry_time = get_seconds()-1;
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
        }
        svc_expkey_cache.nextcheck = get_seconds();
 }
@@ -741,8 +849,8 @@ exp_export(struct nfsctl_export *nxp)
        if ((nxp->ex_flags & NFSEXP_FSID) &&
            (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
            !IS_ERR(fsid_key) &&
-            fsid_key->ek_export &&
+            fsid_key->ek_mnt &&
-            fsid_key->ek_export != exp)
+            (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
                goto finish;
        if (exp) {
@@ -775,13 +883,13 @@ exp_export(struct nfsctl_export *nxp)
        new.ex_anon_gid = nxp->ex_anon_gid;
        new.ex_fsid = nxp->ex_dev;
-        exp = svc_export_lookup(&new, 1);
+        exp = svc_export_lookup(&new);
+        if (exp)
+                exp = svc_export_update(&new, exp);
-        if (exp == NULL)
+        if (!exp)
                goto finish;
-        err = 0;
        if (exp_hash(clp, exp) ||
            exp_fsid_hash(clp, exp)) {
                /* failed to create at least one index */
@@ -794,7 +902,7 @@ finish:
        if (exp)
                exp_put(exp);
        if (fsid_key && !IS_ERR(fsid_key))
-                expkey_put(&fsid_key->h, &svc_expkey_cache);
+                cache_put(&fsid_key->h, &svc_expkey_cache);
        if (clp)
                auth_domain_put(clp);
        path_release(&nd);
@@ -912,6 +1020,24 @@ out:
        return err;
 }
+struct svc_export *
+exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
+         struct cache_req *reqp)
+{
+        struct svc_export *exp;
+        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
+        if (!ek || IS_ERR(ek))
+                return ERR_PTR(PTR_ERR(ek));
+        exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
+        cache_put(&ek->h, &svc_expkey_cache);
+        if (!exp || IS_ERR(exp))
+                return ERR_PTR(PTR_ERR(exp));
+        return exp;
+}
 /*
 * Called when we need the filehandle for the root of the pseudofs,
 * for a given NFSv4 client.   The root is defined to be the
@@ -922,6 +1048,7 @@ exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
               struct cache_req *creq)
 {
        struct svc_expkey *fsid_key;
+        struct svc_export *exp;
        int rv;
        u32 fsidv[2];
@@ -933,9 +1060,15 @@ exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
        if (!fsid_key || IS_ERR(fsid_key))
                return nfserr_perm;
-        rv = fh_compose(fhp, fsid_key->ek_export, 
+        exp = exp_get_by_name(clp, fsid_key->ek_mnt, fsid_key->ek_dentry, creq);
-                          fsid_key->ek_export->ex_dentry, NULL);
+        if (exp == NULL)
-        expkey_put(&fsid_key->h, &svc_expkey_cache);
+                rv = nfserr_perm;
+        else if (IS_ERR(exp))
+                rv = nfserrno(PTR_ERR(exp));
+        else
+                rv = fh_compose(fhp, exp,
+                                fsid_key->ek_dentry, NULL);
+        cache_put(&fsid_key->h, &svc_expkey_cache);
        return rv;
 }
@@ -1054,7 +1187,7 @@ static int e_show(struct seq_file *m, void *p)
        cache_get(&exp->h);
        if (cache_check(&svc_export_cache, &exp->h, NULL))
                return 0;
-        if (cache_put(&exp->h, &svc_export_cache)) BUG();
+        cache_put(&exp->h, &svc_export_cache);
        return svc_export_show(m, &svc_export_cache, cp);
 }
@@ -1129,7 +1262,6 @@ exp_delclient(struct nfsctl_client *ncp)
         */
        if (dom) {
                err = auth_unix_forget_old(dom);
-                dom->h.expiry_time = get_seconds();
                auth_domain_put(dom);
        }
diff --git a/fs/nfsd/nfs4idmap.c b/fs/nfsd/nfs4idmap.c
index 13369650cdf9..4b6aa60dfceb 100644
--- a/fs/nfsd/nfs4idmap.c
+++ b/fs/nfsd/nfs4idmap.c
@@ -76,21 +76,18 @@ struct ent {
        char              authname[IDMAP_NAMESZ];
 };
-#define DefineSimpleCacheLookupMap(STRUCT, FUNC)                        \
-        DefineCacheLookup(struct STRUCT, h, FUNC##_lookup,              \
-        (struct STRUCT *item, int set), /*no setup */,                  \
-        & FUNC##_cache, FUNC##_hash(item), FUNC##_match(item, tmp),     \
-        STRUCT##_init(new, item), STRUCT##_update(tmp, item), 0)
 /* Common entry handling */
 #define ENT_HASHBITS          8
 #define ENT_HASHMAX           (1 << ENT_HASHBITS)
 #define ENT_HASHMASK          (ENT_HASHMAX - 1)
-static inline void
+static void
-ent_init(struct ent *new, struct ent *itm)
+ent_init(struct cache_head *cnew, struct cache_head *citm)
 {
+        struct ent *new = container_of(cnew, struct ent, h);
+        struct ent *itm = container_of(citm, struct ent, h);
        new->id = itm->id;
        new->type = itm->type;
@@ -98,19 +95,21 @@ ent_init(struct ent *new, struct ent *itm)
        strlcpy(new->authname, itm->authname, sizeof(new->name));
 }
-static inline void
+static void
-ent_update(struct ent *new, struct ent *itm)
+ent_put(struct kref *ref)
 {
-        ent_init(new, itm);
+        struct ent *map = container_of(ref, struct ent, h.ref);
+        kfree(map);
 }
-static void
+static struct cache_head *
-ent_put(struct cache_head *ch, struct cache_detail *cd)
+ent_alloc(void)
 {
-        if (cache_put(ch, cd)) {
+        struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
-                struct ent *map = container_of(ch, struct ent, h);
+        if (e)
-                kfree(map);
+                return &e->h;
-        }
+        else
+                return NULL;
 }
 /*
@@ -149,9 +148,12 @@ idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
        (*bpp)[-1] = '\n';
 }
-static inline int
+static int
-idtoname_match(struct ent *a, struct ent *b)
+idtoname_match(struct cache_head *ca, struct cache_head *cb)
 {
+        struct ent *a = container_of(ca, struct ent, h);
+        struct ent *b = container_of(cb, struct ent, h);
        return (a->id == b->id && a->type == b->type &&
            strcmp(a->authname, b->authname) == 0);
 }
@@ -184,7 +186,8 @@ warn_no_idmapd(struct cache_detail *detail)
 static int         idtoname_parse(struct cache_detail *, char *, int);
-static struct ent *idtoname_lookup(struct ent *, int);
+static struct ent *idtoname_lookup(struct ent *);
+static struct ent *idtoname_update(struct ent *, struct ent *);
 static struct cache_detail idtoname_cache = {
        .owner          = THIS_MODULE,
@@ -196,6 +199,10 @@ static struct cache_detail idtoname_cache = {
        .cache_parse    = idtoname_parse,
        .cache_show     = idtoname_show,
        .warn_no_listener = warn_no_idmapd,
+        .match          = idtoname_match,
+        .init           = ent_init,
+        .update         = ent_init,
+        .alloc          = ent_alloc,
 };
 int
@@ -238,6 +245,11 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
        if (ent.h.expiry_time == 0)
                goto out;
+        error = -ENOMEM;
+        res = idtoname_lookup(&ent);
+        if (!res)
+                goto out;
        /* Name */
        error = qword_get(&buf, buf1, PAGE_SIZE);
        if (error == -EINVAL)
@@ -252,10 +264,11 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
                memcpy(ent.name, buf1, sizeof(ent.name));
        }
        error = -ENOMEM;
-        if ((res = idtoname_lookup(&ent, 1)) == NULL)
+        res = idtoname_update(&ent, res);
+        if (res == NULL)
                goto out;
-        ent_put(&res->h, &idtoname_cache);
+        cache_put(&res->h, &idtoname_cache);
        error = 0;
 out:
@@ -264,7 +277,31 @@ out:
        return error;
 }
-static DefineSimpleCacheLookupMap(ent, idtoname);
+static struct ent *
+idtoname_lookup(struct ent *item)
+{
+        struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
+                                                    &item->h,
+                                                    idtoname_hash(item));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
+static struct ent *
+idtoname_update(struct ent *new, struct ent *old)
+{
+        struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
+                                                    &new->h, &old->h,
+                                                    idtoname_hash(new));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
 /*
 * Name -> ID cache
@@ -291,9 +328,12 @@ nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
        (*bpp)[-1] = '\n';
 }
-static inline int
+static int
-nametoid_match(struct ent *a, struct ent *b)
+nametoid_match(struct cache_head *ca, struct cache_head *cb)
 {
+        struct ent *a = container_of(ca, struct ent, h);
+        struct ent *b = container_of(cb, struct ent, h);
        return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
            strcmp(a->authname, b->authname) == 0);
 }
@@ -317,7 +357,8 @@ nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
        return 0;
 }
-static struct ent *nametoid_lookup(struct ent *, int);
+static struct ent *nametoid_lookup(struct ent *);
+static struct ent *nametoid_update(struct ent *, struct ent *);
 static int         nametoid_parse(struct cache_detail *, char *, int);
 static struct cache_detail nametoid_cache = {
@@ -330,6 +371,10 @@ static struct cache_detail nametoid_cache = {
        .cache_parse    = nametoid_parse,
        .cache_show     = nametoid_show,
        .warn_no_listener = warn_no_idmapd,
+        .match          = nametoid_match,
+        .init           = ent_init,
+        .update         = ent_init,
+        .alloc          = ent_alloc,
 };
 static int
@@ -379,10 +424,14 @@ nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
                set_bit(CACHE_NEGATIVE, &ent.h.flags);
        error = -ENOMEM;
-        if ((res = nametoid_lookup(&ent, 1)) == NULL)
+        res = nametoid_lookup(&ent);
+        if (res == NULL)
+                goto out;
+        res = nametoid_update(&ent, res);
+        if (res == NULL)
                goto out;
-        ent_put(&res->h, &nametoid_cache);
+        cache_put(&res->h, &nametoid_cache);
        error = 0;
 out:
        kfree(buf1);
@@ -390,7 +439,30 @@ out:
        return (error);
 }
-static DefineSimpleCacheLookupMap(ent, nametoid);
+static struct ent *
+nametoid_lookup(struct ent *item)
+{
+        struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
+                                                    &item->h,
+                                                    nametoid_hash(item));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
+static struct ent *
+nametoid_update(struct ent *new, struct ent *old)
+{
+        struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
+                                                    &new->h, &old->h,
+                                                    nametoid_hash(new));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
 /*
 * Exported API
@@ -458,24 +530,24 @@ idmap_defer(struct cache_req *req)
 }
 static inline int
-do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
+do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                struct cache_detail *detail, struct ent **item,
                struct idmap_defer_req *mdr)
 {
-        *item = lookup_fn(key, 0);
+        *item = lookup_fn(key);
        if (!*item)
                return -ENOMEM;
        return cache_check(detail, &(*item)->h, &mdr->req);
 }
 static inline int
-do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *, int),
+do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *),
                        struct ent *key, struct cache_detail *detail,
                        struct ent **item)
 {
        int ret = -ENOMEM;
-        *item = lookup_fn(key, 0);
+        *item = lookup_fn(key);
        if (!*item)
                goto out_err;
        ret = -ETIMEDOUT;
@@ -488,7 +560,7 @@ do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *, int),
                goto out_put;
        return 0;
 out_put:
-        ent_put(&(*item)->h, detail);
+        cache_put(&(*item)->h, detail);
 out_err:
        *item = NULL;
        return ret;
@@ -496,7 +568,7 @@ out_err:
 static int
 idmap_lookup(struct svc_rqst *rqstp,
-                struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
+                struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                struct cache_detail *detail, struct ent **item)
 {
        struct idmap_defer_req *mdr;
@@ -539,7 +611,7 @@ idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen
        if (ret)
                return ret;
        *id = item->id;
-        ent_put(&item->h, &nametoid_cache);
+        cache_put(&item->h, &nametoid_cache);
        return 0;
 }
@@ -561,7 +633,7 @@ idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
        ret = strlen(item->name);
        BUG_ON(ret > IDMAP_NAMESZ);
        memcpy(name, item->name, ret);
-        ent_put(&item->h, &idtoname_cache);
+        cache_put(&item->h, &idtoname_cache);
        return ret;
 }
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index f6ab762bea99..47ec112b266c 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -49,6 +49,7 @@
 #include <linux/nfsd/state.h>
 #include <linux/nfsd/xdr4.h>
 #include <linux/namei.h>
+#include <linux/mutex.h>
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
@@ -77,11 +78,11 @@ static void nfs4_set_recdir(char *recdir);
 /* Locking:
 *
- * client_sema: 
+ * client_mutex:
 *      protects clientid_hashtbl[], clientstr_hashtbl[],
 *      unconfstr_hashtbl[], uncofid_hashtbl[].
 */
-static DECLARE_MUTEX(client_sema);
+static DEFINE_MUTEX(client_mutex);
 static kmem_cache_t *stateowner_slab = NULL;
 static kmem_cache_t *file_slab = NULL;
@@ -91,13 +92,13 @@ static kmem_cache_t *deleg_slab = NULL;
 void
 nfs4_lock_state(void)
 {
-        down(&client_sema);
+        mutex_lock(&client_mutex);
 }
 void
 nfs4_unlock_state(void)
 {
-        up(&client_sema);
+        mutex_unlock(&client_mutex);
 }
 static inline u32
@@ -2749,37 +2750,31 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
        * Note: locks.c uses the BKL to protect the inode's lock list.
        */
-        status = posix_lock_file(filp, &file_lock);
+        /* XXX?: Just to divert the locks_release_private at the start of
-        dprintk("NFSD: nfsd4_lock: posix_lock_file status %d\n",status);
+         * locks_copy_lock: */
+        conflock.fl_ops = NULL;
+        conflock.fl_lmops = NULL;
+        status = posix_lock_file_conf(filp, &file_lock, &conflock);
+        dprintk("NFSD: nfsd4_lock: posix_lock_file_conf status %d\n",status);
        switch (-status) {
        case 0: /* success! */
                update_stateid(&lock_stp->st_stateid);
                memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid, 
                                sizeof(stateid_t));
-                goto out;
+                break;
-        case (EAGAIN):
+        case (EAGAIN):          /* conflock holds conflicting lock */
-                goto conflicting_lock;
+                status = nfserr_denied;
+                dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
+                nfs4_set_lock_denied(&conflock, &lock->lk_denied);
+                break;
        case (EDEADLK):
                status = nfserr_deadlock;
-                dprintk("NFSD: nfsd4_lock: posix_lock_file() failed! status %d\n",status);
+                break;
-                goto out;
        default:        
-                status = nfserrno(status);
+                dprintk("NFSD: nfsd4_lock: posix_lock_file_conf() failed! status %d\n",status);
-                dprintk("NFSD: nfsd4_lock: posix_lock_file() failed! status %d\n",status);
+                status = nfserr_resource;
-                goto out;
+                break;
-        }
-conflicting_lock:
-        dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
-        status = nfserr_denied;
-        /* XXX There is a race here. Future patch needed to provide 
-         * an atomic posix_lock_and_test_file
-         */
-        if (!posix_test_lock(filp, &file_lock, &conflock)) {
-                status = nfserr_serverfault;
-                goto out;
        }
-        nfs4_set_lock_denied(&conflock, &lock->lk_denied);
 out:
        if (status && lock->lk_is_new && lock_sop)
                release_stateowner(lock_sop);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 7a3e397b4ed3..3f2ec2e6d06c 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -506,7 +506,7 @@ fh_put(struct svc_fh *fhp)
                nfsd_nr_put++;
        }
        if (exp) {
-                svc_export_put(&exp->h, &svc_export_cache);
+                cache_put(&exp->h, &svc_export_cache);
                fhp->fh_export = NULL;
        }
        return;
diff --git a/fs/ntfs/logfile.c b/fs/ntfs/logfile.c
index 0fd70295cca6..4af2ad1193ec 100644
--- a/fs/ntfs/logfile.c
+++ b/fs/ntfs/logfile.c
@@ -515,10 +515,10 @@ BOOL ntfs_check_logfile(struct inode *log_vi, RESTART_PAGE_HEADER **rp)
                log_page_size = PAGE_CACHE_SIZE;
        log_page_mask = log_page_size - 1;
        /*
-         * Use generic_ffs() instead of ffs() to enable the compiler to
+         * Use ntfs_ffs() instead of ffs() to enable the compiler to
         * optimize log_page_size and log_page_bits into constants.
         */
-        log_page_bits = generic_ffs(log_page_size) - 1;
+        log_page_bits = ntfs_ffs(log_page_size) - 1;
        size &= ~(s64)(log_page_size - 1);
        /*
         * Ensure the log file is big enough to store at least the two restart
diff --git a/fs/ntfs/mft.c b/fs/ntfs/mft.c
index 4e72bc7afdf9..2438c00ec0ce 100644
--- a/fs/ntfs/mft.c
+++ b/fs/ntfs/mft.c
@@ -2670,7 +2670,7 @@ mft_rec_already_initialized:
                        ni->name_len = 4;
                        ni->itype.index.block_size = 4096;
-                        ni->itype.index.block_size_bits = generic_ffs(4096) - 1;
+                        ni->itype.index.block_size_bits = ntfs_ffs(4096) - 1;
                        ni->itype.index.collation_rule = COLLATION_FILE_NAME;
                        if (vol->cluster_size <= ni->itype.index.block_size) {
                                ni->itype.index.vcn_size = vol->cluster_size;
diff --git a/fs/ntfs/ntfs.h b/fs/ntfs/ntfs.h
index 0624c8ef4d9c..166142960b53 100644
--- a/fs/ntfs/ntfs.h
+++ b/fs/ntfs/ntfs.h
@@ -132,4 +132,33 @@ extern int ntfs_ucstonls(const ntfs_volume *vol, const ntfschar *ins,
 /* From fs/ntfs/upcase.c */
 extern ntfschar *generate_default_upcase(void);
+static inline int ntfs_ffs(int x)
+{
+        int r = 1;
+        if (!x)
+                return 0;
+        if (!(x & 0xffff)) {
+                x >>= 16;
+                r += 16;
+        }
+        if (!(x & 0xff)) {
+                x >>= 8;
+                r += 8;
+        }
+        if (!(x & 0xf)) {
+                x >>= 4;
+                r += 4;
+        }
+        if (!(x & 3)) {
+                x >>= 2;
+                r += 2;
+        }
+        if (!(x & 1)) {
+                x >>= 1;
+                r += 1;
+        }
+        return r;
+}
 #endif /* _LINUX_NTFS_H */
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index bf931ba1d364..0d858d0b25be 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -540,7 +540,6 @@ bail:
 *                                      fs_count, map_bh, dio->rw == WRITE);
 */
 static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
-                                     unsigned long max_blocks,
                                     struct buffer_head *bh_result, int create)
 {
        int ret;
@@ -548,6 +547,7 @@ static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
        u64 p_blkno;
        int contig_blocks;
        unsigned char blocksize_bits;
+        unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
        if (!inode || !bh_result) {
                mlog(ML_ERROR, "inode or bh_result is null\n");
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index ae3440ca083c..6a610ae53583 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -377,7 +377,7 @@ int ocfs2_journal_access(struct ocfs2_journal_handle *handle,
        BUG_ON(!bh);
        BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED));
-        mlog_entry("bh->b_blocknr=%llu, type=%d (\"%s\"), bh->b_size = %hu\n",
+        mlog_entry("bh->b_blocknr=%llu, type=%d (\"%s\"), bh->b_size = %zu\n",
                   (unsigned long long)bh->b_blocknr, type,
                   (type == OCFS2_JOURNAL_ACCESS_CREATE) ?
                   "OCFS2_JOURNAL_ACCESS_CREATE" :
@@ -582,7 +582,8 @@ int ocfs2_journal_init(struct ocfs2_journal *journal, int *dirty)
        }
        mlog(0, "inode->i_size = %lld\n", inode->i_size);
-        mlog(0, "inode->i_blocks = %lu\n", inode->i_blocks);
+        mlog(0, "inode->i_blocks = %llu\n",
+                        (unsigned long long)inode->i_blocks);
        mlog(0, "inode->ip_clusters = %u\n", OCFS2_I(inode)->ip_clusters);
        /* call the kernels journal init function now */
@@ -850,8 +851,9 @@ static int ocfs2_force_read_journal(struct inode *inode)
        memset(bhs, 0, sizeof(struct buffer_head *) * CONCURRENT_JOURNAL_FILL);
-        mlog(0, "Force reading %lu blocks\n",
+        mlog(0, "Force reading %llu blocks\n",
-             (inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9)));
+                (unsigned long long)(inode->i_blocks >>
+                        (inode->i_sb->s_blocksize_bits - 9)));
        v_blkno = 0;
        while (v_blkno <
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 274f61d0cda9..0673862c8bdd 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -1444,8 +1444,9 @@ static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
         * write i_size + 1 bytes. */
        blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
-        mlog_entry("i_blocks = %lu, i_size = %llu, blocks = %d\n",
+        mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
-                       inode->i_blocks, i_size_read(inode), blocks);
+                        (unsigned long long)inode->i_blocks,
+                        i_size_read(inode), blocks);
        /* Sanity check -- make sure we're going to fit. */
        if (bytes_left >
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index f924f459bdb8..af0cb4b9e784 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -297,6 +297,25 @@ struct kobj_type ktype_part = {
        .sysfs_ops      = &part_sysfs_ops,
 };
+static inline void partition_sysfs_add_subdir(struct hd_struct *p)
+{
+        struct kobject *k;
+        k = kobject_get(&p->kobj);
+        p->holder_dir = kobject_add_dir(k, "holders");
+        kobject_put(k);
+}
+static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
+{
+        struct kobject *k;
+        k = kobject_get(&disk->kobj);
+        disk->holder_dir = kobject_add_dir(k, "holders");
+        disk->slave_dir = kobject_add_dir(k, "slaves");
+        kobject_put(k);
+}
 void delete_partition(struct gendisk *disk, int part)
 {
        struct hd_struct *p = disk->part[part-1];
@@ -310,6 +329,8 @@ void delete_partition(struct gendisk *disk, int part)
        p->ios[0] = p->ios[1] = 0;
        p->sectors[0] = p->sectors[1] = 0;
        devfs_remove("%s/part%d", disk->devfs_name, part);
+        if (p->holder_dir)
+                kobject_unregister(p->holder_dir);
        kobject_unregister(&p->kobj);
 }
@@ -337,6 +358,7 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len)
        p->kobj.parent = &disk->kobj;
        p->kobj.ktype = &ktype_part;
        kobject_register(&p->kobj);
+        partition_sysfs_add_subdir(p);
        disk->part[part-1] = p;
 }
@@ -383,6 +405,7 @@ void register_disk(struct gendisk *disk)
        if ((err = kobject_add(&disk->kobj)))
                return;
        disk_sysfs_symlinks(disk);
+        disk_sysfs_add_subdirs(disk);
        kobject_uevent(&disk->kobj, KOBJ_ADD);
        /* No minors to use for partitions */
@@ -483,6 +506,10 @@ void del_gendisk(struct gendisk *disk)
        devfs_remove_disk(disk);
+        if (disk->holder_dir)
+                kobject_unregister(disk->holder_dir);
+        if (disk->slave_dir)
+                kobject_unregister(disk->slave_dir);
        if (disk->driverfs_dev) {
                char *disk_name = make_block_name(disk);
                sysfs_remove_link(&disk->kobj, "device");
diff --git a/fs/partitions/devfs.c b/fs/partitions/devfs.c
index 87f50444fd39..3f0a780c9cec 100644
--- a/fs/partitions/devfs.c
+++ b/fs/partitions/devfs.c
@@ -6,7 +6,7 @@
 #include <linux/vmalloc.h>
 #include <linux/genhd.h>
 #include <linux/bitops.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 struct unique_numspace {
@@ -16,7 +16,7 @@ struct unique_numspace {
        struct semaphore  mutex;
 };
-static DECLARE_MUTEX(numspace_mutex);
+static DEFINE_MUTEX(numspace_mutex);
 static int expand_numspace(struct unique_numspace *s)
 {
@@ -48,7 +48,7 @@ static int alloc_unique_number(struct unique_numspace *s)
 {
        int rval = 0;
-        down(&numspace_mutex);
+        mutex_lock(&numspace_mutex);
        if (s->num_free < 1)
                rval = expand_numspace(s);
        if (!rval) {
@@ -56,7 +56,7 @@ static int alloc_unique_number(struct unique_numspace *s)
                --s->num_free;
                __set_bit(rval, s->bits);
        }
-        up(&numspace_mutex);
+        mutex_unlock(&numspace_mutex);
        return rval;
 }
@@ -66,11 +66,11 @@ static void dealloc_unique_number(struct unique_numspace *s, int number)
        int old_val;
        if (number >= 0) {
-                down(&numspace_mutex);
+                mutex_lock(&numspace_mutex);
                old_val = __test_and_clear_bit(number, s->bits);
                if (old_val)
                        ++s->num_free;
-                up(&numspace_mutex);
+                mutex_unlock(&numspace_mutex);
        }
 }
diff --git a/fs/pipe.c b/fs/pipe.c
index d976866a115b..4384c9290943 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -675,7 +675,7 @@ fail_page:
        return NULL;
 }
-static struct vfsmount *pipe_mnt;
+static struct vfsmount *pipe_mnt __read_mostly;
 static int pipefs_delete_dentry(struct dentry *dentry)
 {
        return 1;
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 7eb1bd7f800c..7a76ad570230 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -330,7 +330,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
        unsigned long  min_flt = 0,  maj_flt = 0;
        cputime_t cutime, cstime, utime, stime;
        unsigned long rsslim = 0;
-        DEFINE_KTIME(it_real_value);
        struct task_struct *t;
        char tcomm[sizeof(task->comm)];
@@ -386,7 +385,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                        utime = cputime_add(utime, task->signal->utime);
                        stime = cputime_add(stime, task->signal->stime);
                }
-                it_real_value = task->signal->real_timer.expires;
        }
        ppid = pid_alive(task) ? task->group_leader->real_parent->tgid : 0;
        read_unlock(&tasklist_lock);
@@ -413,7 +411,7 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
        start_time = nsec_to_clock_t(start_time);
        res = sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
-%lu %lu %lu %lu %lu %ld %ld %ld %ld %d %ld %llu %lu %ld %lu %lu %lu %lu %lu \
+%lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu\n",
                task->pid,
                tcomm,
@@ -435,7 +433,6 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                priority,
                nice,
                num_threads,
-                (long) ktime_to_clock_t(it_real_value),
                start_time,
                vsize,
                mm ? get_mm_rss(mm) : 0,
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 20e5c4509a43..47b7a20d45eb 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -19,6 +19,7 @@
 #include <linux/idr.h>
 #include <linux/namei.h>
 #include <linux/bitops.h>
+#include <linux/spinlock.h>
 #include <asm/uaccess.h>
 #include "internal.h"
@@ -29,6 +30,8 @@ static ssize_t proc_file_write(struct file *file, const char __user *buffer,
                               size_t count, loff_t *ppos);
 static loff_t proc_file_lseek(struct file *, loff_t, int);
+DEFINE_SPINLOCK(proc_subdir_lock);
 int proc_match(int len, const char *name, struct proc_dir_entry *de)
 {
        if (de->namelen != len)
@@ -277,7 +280,9 @@ static int xlate_proc_name(const char *name,
        const char              *cp = name, *next;
        struct proc_dir_entry   *de;
        int                     len;
+        int                     rtn = 0;
+        spin_lock(&proc_subdir_lock);
        de = &proc_root;
        while (1) {
                next = strchr(cp, '/');
@@ -289,13 +294,17 @@ static int xlate_proc_name(const char *name,
                        if (proc_match(len, cp, de))
                                break;
                }
-                if (!de)
+                if (!de) {
-                        return -ENOENT;
+                        rtn = -ENOENT;
+                        goto out;
+                }
                cp += len + 1;
        }
        *residual = cp;
        *ret = de;
-        return 0;
+out:
+        spin_unlock(&proc_subdir_lock);
+        return rtn;
 }
 static DEFINE_IDR(proc_inum_idr);
@@ -380,6 +389,7 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
        int error = -ENOENT;
        lock_kernel();
+        spin_lock(&proc_subdir_lock);
        de = PDE(dir);
        if (de) {
                for (de = de->subdir; de ; de = de->next) {
@@ -388,12 +398,15 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                        if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                                unsigned int ino = de->low_ino;
+                                spin_unlock(&proc_subdir_lock);
                                error = -EINVAL;
                                inode = proc_get_inode(dir->i_sb, ino, de);
+                                spin_lock(&proc_subdir_lock);
                                break;
                        }
                }
        }
+        spin_unlock(&proc_subdir_lock);
        unlock_kernel();
        if (inode) {
@@ -447,11 +460,13 @@ int proc_readdir(struct file * filp,
                        filp->f_pos++;
                        /* fall through */
                default:
+                        spin_lock(&proc_subdir_lock);
                        de = de->subdir;
                        i -= 2;
                        for (;;) {
                                if (!de) {
                                        ret = 1;
+                                        spin_unlock(&proc_subdir_lock);
                                        goto out;
                                }
                                if (!i)
@@ -461,12 +476,16 @@ int proc_readdir(struct file * filp,
                        }
                        do {
+                                /* filldir passes info to user space */
+                                spin_unlock(&proc_subdir_lock);
                                if (filldir(dirent, de->name, de->namelen, filp->f_pos,
                                            de->low_ino, de->mode >> 12) < 0)
                                        goto out;
+                                spin_lock(&proc_subdir_lock);
                                filp->f_pos++;
                                de = de->next;
                        } while (de);
+                        spin_unlock(&proc_subdir_lock);
        }
        ret = 1;
 out:    unlock_kernel();
@@ -500,9 +519,13 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
        if (i == 0)
                return -EAGAIN;
        dp->low_ino = i;
+        spin_lock(&proc_subdir_lock);
        dp->next = dir->subdir;
        dp->parent = dir;
        dir->subdir = dp;
+        spin_unlock(&proc_subdir_lock);
        if (S_ISDIR(dp->mode)) {
                if (dp->proc_iops == NULL) {
                        dp->proc_fops = &proc_dir_operations;
@@ -694,6 +717,8 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
        if (!parent && xlate_proc_name(name, &parent, &fn) != 0)
                goto out;
        len = strlen(fn);
+        spin_lock(&proc_subdir_lock);
        for (p = &parent->subdir; *p; p=&(*p)->next ) {
                if (!proc_match(len, fn, *p))
                        continue;
@@ -714,6 +739,7 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
                }
                break;
        }
+        spin_unlock(&proc_subdir_lock);
 out:
        return;
 }
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index 9bdd077d6f55..596b4b4f1cc8 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -136,9 +136,11 @@ void proc_device_tree_add_node(struct device_node *np,
                 * properties are quite unimportant for us though, thus we
                 * simply "skip" them here, but we do have to check.
                 */
+                spin_lock(&proc_subdir_lock);
                for (ent = de->subdir; ent != NULL; ent = ent->next)
                        if (!strcmp(ent->name, pp->name))
                                break;
+                spin_unlock(&proc_subdir_lock);
                if (ent != NULL) {
                        printk(KERN_WARNING "device-tree: property \"%s\" name"
                               " conflicts with node in %s\n", pp->name,
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index d60f6238c66a..9857e50f85e7 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -466,7 +466,6 @@ static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
   direct_IO request. */
 static int reiserfs_get_blocks_direct_io(struct inode *inode,
                                         sector_t iblock,
-                                         unsigned long max_blocks,
                                         struct buffer_head *bh_result,
                                         int create)
 {
@@ -2793,7 +2792,7 @@ static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
 }
 /* clm -- taken from fs/buffer.c:block_invalidate_page */
-static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
+static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
 {
        struct buffer_head *head, *bh, *next;
        struct inode *inode = page->mapping->host;
@@ -2832,10 +2831,12 @@ static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
         * The get_block cached value has been unconditionally invalidated,
         * so real IO is not possible anymore.
         */
-        if (!offset && ret)
+        if (!offset && ret) {
                ret = try_to_release_page(page, 0);
+                /* maybe should BUG_ON(!ret); - neilb */
+        }
      out:
-        return ret;
+        return;
 }
 static int reiserfs_set_page_dirty(struct page *page)
diff --git a/fs/reiserfs/prints.c b/fs/reiserfs/prints.c
index 78b40621b88b..27bd3a1df2ad 100644
--- a/fs/reiserfs/prints.c
+++ b/fs/reiserfs/prints.c
@@ -143,7 +143,7 @@ static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
        char b[BDEVNAME_SIZE];
        sprintf(buf,
-                "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
+                "dev %s, size %zd, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
                bdevname(bh->b_bdev, b), bh->b_size,
                (unsigned long long)bh->b_blocknr, atomic_read(&(bh->b_count)),
                bh->b_state, bh->b_page,
diff --git a/fs/super.c b/fs/super.c
index 8743e9bbb297..a66f66bb8049 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -37,6 +37,7 @@
 #include <linux/writeback.h>            /* for the emergency remount stuff */
 #include <linux/idr.h>
 #include <linux/kobject.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
@@ -380,9 +381,9 @@ restart:
 void sync_filesystems(int wait)
 {
        struct super_block *sb;
-        static DECLARE_MUTEX(mutex);
+        static DEFINE_MUTEX(mutex);
-        down(&mutex);           /* Could be down_interruptible */
+        mutex_lock(&mutex);             /* Could be down_interruptible */
        spin_lock(&sb_lock);
        list_for_each_entry(sb, &super_blocks, s_list) {
                if (!sb->s_op->sync_fs)
@@ -411,7 +412,7 @@ restart:
                        goto restart;
        }
        spin_unlock(&sb_lock);
-        up(&mutex);
+        mutex_unlock(&mutex);
 }
 /**
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 97fc056130eb..c02f7c5b7462 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1310,20 +1310,21 @@ xfs_get_block(
        struct buffer_head      *bh_result,
        int                     create)
 {
-        return __xfs_get_block(inode, iblock, 0, bh_result,
+        return __xfs_get_block(inode, iblock,
-                                        create, 0, BMAPI_WRITE);
+                                bh_result->b_size >> inode->i_blkbits,
+                                bh_result, create, 0, BMAPI_WRITE);
 }
 STATIC int
 xfs_get_blocks_direct(
        struct inode            *inode,
        sector_t                iblock,
-        unsigned long           max_blocks,
        struct buffer_head      *bh_result,
        int                     create)
 {
-        return __xfs_get_block(inode, iblock, max_blocks, bh_result,
+        return __xfs_get_block(inode, iblock,
-                                        create, 1, BMAPI_WRITE|BMAPI_DIRECT);
+                                bh_result->b_size >> inode->i_blkbits,
+                                bh_result, create, 1, BMAPI_WRITE|BMAPI_DIRECT);
 }
 STATIC void
@@ -1442,14 +1443,14 @@ xfs_vm_readpages(
        return mpage_readpages(mapping, pages, nr_pages, xfs_get_block);
 }
-STATIC int
+STATIC void
 xfs_vm_invalidatepage(
        struct page             *page,
        unsigned long           offset)
 {
        xfs_page_trace(XFS_INVALIDPAGE_ENTER,
                        page->mapping->host, page, offset);
-        return block_invalidatepage(page, offset);
+        block_invalidatepage(page, offset);
 }
 struct address_space_operations xfs_address_space_operations = {
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 8355faf8ffde..1884300417e3 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -375,9 +375,8 @@ xfs_init_zones(void)
        if (!xfs_ioend_zone)
                goto out_destroy_vnode_zone;
-        xfs_ioend_pool = mempool_create(4 * MAX_BUF_PER_PAGE,
+        xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
-                                        mempool_alloc_slab, mempool_free_slab,
+                                                  xfs_ioend_zone);
-                                        xfs_ioend_zone);
        if (!xfs_ioend_pool)
                goto out_free_ioend_zone;
        return 0;