230 files changed, 2284 insertions, 2116 deletions
diff --git a/fs/9p/conv.c b/fs/9p/conv.c
index 56d88c1a09c5..a3ed571eee31 100644
--- a/fs/9p/conv.c
+++ b/fs/9p/conv.c
@@ -27,6 +27,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/idr.h>
 #include <asm/uaccess.h>
 #include "debug.h"
diff --git a/fs/9p/fcall.c b/fs/9p/fcall.c
index 8556097fcda8..dc336a67592f 100644
--- a/fs/9p/fcall.c
+++ b/fs/9p/fcall.c
@@ -27,6 +27,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/idr.h>
 #include "debug.h"
diff --git a/fs/9p/fid.c b/fs/9p/fid.c
index 70492ccb4385..27507201f9e7 100644
--- a/fs/9p/fid.c
+++ b/fs/9p/fid.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/idr.h>
 #include "debug.h"
diff --git a/fs/9p/mux.c b/fs/9p/mux.c
index 90a79c784549..944273c3dbff 100644
--- a/fs/9p/mux.c
+++ b/fs/9p/mux.c
@@ -110,8 +110,8 @@ struct v9fs_mux_rpc {
 };
 static int v9fs_poll_proc(void *);
-static void v9fs_read_work(void *);
+static void v9fs_read_work(struct work_struct *work);
-static void v9fs_write_work(void *);
+static void v9fs_write_work(struct work_struct *work);
 static void v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
                          poll_table * p);
 static u16 v9fs_mux_get_tag(struct v9fs_mux_data *);
@@ -297,8 +297,8 @@ struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
        m->rbuf = NULL;
        m->wpos = m->wsize = 0;
        m->wbuf = NULL;
-        INIT_WORK(&m->rq, v9fs_read_work, m);
+        INIT_WORK(&m->rq, v9fs_read_work);
-        INIT_WORK(&m->wq, v9fs_write_work, m);
+        INIT_WORK(&m->wq, v9fs_write_work);
        m->wsched = 0;
        memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
        m->poll_task = NULL;
@@ -458,13 +458,13 @@ static int v9fs_poll_proc(void *a)
 /**
 * v9fs_write_work - called when a transport can send some data
 */
-static void v9fs_write_work(void *a)
+static void v9fs_write_work(struct work_struct *work)
 {
        int n, err;
        struct v9fs_mux_data *m;
        struct v9fs_req *req;
-        m = a;
+        m = container_of(work, struct v9fs_mux_data, wq);
        if (m->err < 0) {
                clear_bit(Wworksched, &m->wsched);
@@ -564,7 +564,7 @@ static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
 /**
 * v9fs_read_work - called when there is some data to be read from a transport
 */
-static void v9fs_read_work(void *a)
+static void v9fs_read_work(struct work_struct *work)
 {
        int n, err;
        struct v9fs_mux_data *m;
@@ -572,7 +572,7 @@ static void v9fs_read_work(void *a)
        struct v9fs_fcall *rcall;
        char *rbuf;
-        m = a;
+        m = container_of(work, struct v9fs_mux_data, rq);
        if (m->err < 0)
                return;
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 0f628041e3f7..0b96fae8b479 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/parser.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index e32d5971039b..905c882f4e2f 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -30,6 +30,7 @@
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
+#include <linux/sched.h>
 #include <linux/inet.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index c3c47eda7574..79e6f9cd7340 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 5241c600ce28..18f26cdfd882 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -256,7 +256,7 @@ static int
 v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name, u32 perm,
        u8 mode, char *extension, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
 {
-        u32 fid;
+        int fid;
        int err;
        struct v9fs_fcall *fcall;
@@ -310,7 +310,7 @@ static struct v9fs_fid*
 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
 {
        int err;
-        u32 nfid;
+        int nfid;
        struct v9fs_fid *ret;
        struct v9fs_fcall *fcall;
diff --git a/fs/Kconfig b/fs/Kconfig
index 7b1511d50b05..b3b5aa0edff9 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -972,7 +972,7 @@ config SYSFS
        Some system agents rely on the information in sysfs to operate.
        /sbin/hotplug uses device and object attributes in sysfs to assist in
-        delegating policy decisions, like persistantly naming devices.
+        delegating policy decisions, like persistently naming devices.
        sysfs is currently used by the block subsystem to mount the root
        partition.  If sysfs is disabled you must specify the boot device on
@@ -1145,7 +1145,7 @@ config BEFS_FS
        help
          The BeOS File System (BeFS) is the native file system of Be, Inc's
          BeOS. Notable features include support for arbitrary attributes
-          on files and directories, and database-like indeces on selected
+          on files and directories, and database-like indices on selected
          attributes. (Also note that this driver doesn't make those features
          available at this time). It is a 64 bit filesystem, so it supports
          extremely large volumes and files.
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 9ade139086fc..5023351a7afe 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -36,7 +36,7 @@ void __adfs_error(struct super_block *sb, const char *function, const char *fmt,
        va_list args;
        va_start(args, fmt);
-        vsprintf(error_buf, fmt, args);
+        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
        va_end(args);
        printk(KERN_CRIT "ADFS-fs error (device %s)%s%s: %s\n",
@@ -212,12 +212,12 @@ static int adfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        return 0;
 }
-static kmem_cache_t *adfs_inode_cachep;
+static struct kmem_cache *adfs_inode_cachep;
 static struct inode *adfs_alloc_inode(struct super_block *sb)
 {
        struct adfs_inode_info *ei;
-        ei = (struct adfs_inode_info *)kmem_cache_alloc(adfs_inode_cachep, SLAB_KERNEL);
+        ei = (struct adfs_inode_info *)kmem_cache_alloc(adfs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -228,7 +228,7 @@ static void adfs_destroy_inode(struct inode *inode)
        kmem_cache_free(adfs_inode_cachep, ADFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct adfs_inode_info *ei = (struct adfs_inode_info *) foo;
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index ccd624ef4272..f4de4b98004f 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -445,7 +445,7 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
        va_list  args;
        va_start(args,fmt);
-        vsprintf(ErrorBuffer,fmt,args);
+        vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
        va_end(args);
        printk(KERN_CRIT "AFFS error (device %s): %s(): %s\n", sb->s_id,
@@ -461,7 +461,7 @@ affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
        va_list  args;
        va_start(args,fmt);
-        vsprintf(ErrorBuffer,fmt,args);
+        vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
        va_end(args);
        printk(KERN_WARNING "AFFS warning (device %s): %s(): %s\n", sb->s_id,
diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
index b0b953683c1a..b330009fe42d 100644
--- a/fs/affs/bitmap.c
+++ b/fs/affs/bitmap.c
@@ -289,12 +289,11 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
        sbi->s_bmap_count = (sbi->s_partition_size - sbi->s_reserved +
                                 sbi->s_bmap_bits - 1) / sbi->s_bmap_bits;
        size = sbi->s_bmap_count * sizeof(*bm);
-        bm = sbi->s_bitmap = kmalloc(size, GFP_KERNEL);
+        bm = sbi->s_bitmap = kzalloc(size, GFP_KERNEL);
        if (!sbi->s_bitmap) {
                printk(KERN_ERR "AFFS: Bitmap allocation failed\n");
                return -ENOMEM;
        }
-        memset(sbi->s_bitmap, 0, size);
        bmap_blk = (__be32 *)sbi->s_root_bh->b_data;
        blk = sb->s_blocksize / 4 - 49;
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 5ea72c3a16c3..3de93e799949 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -66,12 +66,12 @@ affs_write_super(struct super_block *sb)
        pr_debug("AFFS: write_super() at %lu, clean=%d\n", get_seconds(), clean);
 }
-static kmem_cache_t * affs_inode_cachep;
+static struct kmem_cache * affs_inode_cachep;
 static struct inode *affs_alloc_inode(struct super_block *sb)
 {
        struct affs_inode_info *ei;
-        ei = (struct affs_inode_info *)kmem_cache_alloc(affs_inode_cachep, SLAB_KERNEL);
+        ei = (struct affs_inode_info *)kmem_cache_alloc(affs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        ei->vfs_inode.i_version = 1;
@@ -83,7 +83,7 @@ static void affs_destroy_inode(struct inode *inode)
        kmem_cache_free(affs_inode_cachep, AFFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct affs_inode_info *ei = (struct affs_inode_info *) foo;
diff --git a/fs/afs/kafsasyncd.c b/fs/afs/kafsasyncd.c
index f09a794f248e..615df2407cb2 100644
--- a/fs/afs/kafsasyncd.c
+++ b/fs/afs/kafsasyncd.c
@@ -20,6 +20,7 @@
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/completion.h>
+#include <linux/freezer.h>
 #include "cell.h"
 #include "server.h"
 #include "volume.h"
diff --git a/fs/afs/kafstimod.c b/fs/afs/kafstimod.c
index 65bc05ab8182..694344e4d3c7 100644
--- a/fs/afs/kafstimod.c
+++ b/fs/afs/kafstimod.c
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/completion.h>
+#include <linux/freezer.h>
 #include "cell.h"
 #include "volume.h"
 #include "kafstimod.h"
diff --git a/fs/afs/server.c b/fs/afs/server.c
index 22afaae1a4ce..44aff81dc6a7 100644
--- a/fs/afs/server.c
+++ b/fs/afs/server.c
@@ -55,13 +55,12 @@ int afs_server_lookup(struct afs_cell *cell, const struct in_addr *addr,
        _enter("%p,%08x,", cell, ntohl(addr->s_addr));
        /* allocate and initialise a server record */
-        server = kmalloc(sizeof(struct afs_server), GFP_KERNEL);
+        server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
        if (!server) {
                _leave(" = -ENOMEM");
                return -ENOMEM;
        }
-        memset(server, 0, sizeof(struct afs_server));
        atomic_set(&server->usage, 1);
        INIT_LIST_HEAD(&server->link);
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 67d1f5c819ec..18d9b77ba40f 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -35,7 +35,7 @@ struct afs_mount_params {
        struct afs_volume       *volume;
 };
-static void afs_i_init_once(void *foo, kmem_cache_t *cachep,
+static void afs_i_init_once(void *foo, struct kmem_cache *cachep,
                            unsigned long flags);
 static int afs_get_sb(struct file_system_type *fs_type,
@@ -65,7 +65,7 @@ static struct super_operations afs_super_ops = {
        .put_super      = afs_put_super,
 };
-static kmem_cache_t *afs_inode_cachep;
+static struct kmem_cache *afs_inode_cachep;
 static atomic_t afs_count_active_inodes;
 /*****************************************************************************/
@@ -242,14 +242,12 @@ static int afs_fill_super(struct super_block *sb, void *data, int silent)
        kenter("");
        /* allocate a superblock info record */
-        as = kmalloc(sizeof(struct afs_super_info), GFP_KERNEL);
+        as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
        if (!as) {
                _leave(" = -ENOMEM");
                return -ENOMEM;
        }
-        memset(as, 0, sizeof(struct afs_super_info));
        afs_get_volume(params->volume);
        as->volume = params->volume;
@@ -384,7 +382,7 @@ static void afs_put_super(struct super_block *sb)
 /*
 * initialise an inode cache slab element prior to any use
 */
-static void afs_i_init_once(void *_vnode, kmem_cache_t *cachep,
+static void afs_i_init_once(void *_vnode, struct kmem_cache *cachep,
                            unsigned long flags)
 {
        struct afs_vnode *vnode = (struct afs_vnode *) _vnode;
@@ -412,7 +410,7 @@ static struct inode *afs_alloc_inode(struct super_block *sb)
        struct afs_vnode *vnode;
        vnode = (struct afs_vnode *)
-                kmem_cache_alloc(afs_inode_cachep, SLAB_KERNEL);
+                kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL);
        if (!vnode)
                return NULL;
diff --git a/fs/aio.c b/fs/aio.c
index 94766599db00..d3a6ec2c9627 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -47,19 +47,19 @@ unsigned long aio_nr;		/* current system wide number of aio requests */
 unsigned long aio_max_nr = 0x10000; /* system wide maximum number of aio requests */
 /*----end sysctl variables---*/
-static kmem_cache_t     *kiocb_cachep;
+static struct kmem_cache        *kiocb_cachep;
-static kmem_cache_t     *kioctx_cachep;
+static struct kmem_cache        *kioctx_cachep;
 static struct workqueue_struct *aio_wq;
 /* Used for rare fput completion. */
-static void aio_fput_routine(void *);
+static void aio_fput_routine(struct work_struct *);
-static DECLARE_WORK(fput_work, aio_fput_routine, NULL);
+static DECLARE_WORK(fput_work, aio_fput_routine);
 static DEFINE_SPINLOCK(fput_lock);
 static LIST_HEAD(fput_head);
-static void aio_kick_handler(void *);
+static void aio_kick_handler(struct work_struct *);
 static void aio_queue_work(struct kioctx *);
 /* aio_setup
@@ -227,7 +227,7 @@ static struct kioctx *ioctx_alloc(unsigned nr_events)
        INIT_LIST_HEAD(&ctx->active_reqs);
        INIT_LIST_HEAD(&ctx->run_list);
-        INIT_WORK(&ctx->wq, aio_kick_handler, ctx);
+        INIT_DELAYED_WORK(&ctx->wq, aio_kick_handler);
        if (aio_setup_ring(ctx) < 0)
                goto out_freectx;
@@ -367,8 +367,7 @@ void fastcall __put_ioctx(struct kioctx *ctx)
 {
        unsigned nr_events = ctx->max_reqs;
-        if (unlikely(ctx->reqs_active))
+        BUG_ON(ctx->reqs_active);
-                BUG();
        cancel_delayed_work(&ctx->wq);
        flush_workqueue(aio_wq);
@@ -470,7 +469,7 @@ static inline void really_put_req(struct kioctx *ctx, struct kiocb *req)
                wake_up(&ctx->wait);
 }
-static void aio_fput_routine(void *data)
+static void aio_fput_routine(struct work_struct *data)
 {
        spin_lock_irq(&fput_lock);
        while (likely(!list_empty(&fput_head))) {
@@ -505,8 +504,7 @@ static int __aio_put_req(struct kioctx *ctx, struct kiocb *req)
        assert_spin_locked(&ctx->ctx_lock);
        req->ki_users --;
-        if (unlikely(req->ki_users < 0))
+        BUG_ON(req->ki_users < 0);
-                BUG();
        if (likely(req->ki_users))
                return 0;
        list_del(&req->ki_list);                /* remove from active_reqs */
@@ -668,17 +666,6 @@ static ssize_t aio_run_iocb(struct kiocb *iocb)
        ssize_t (*retry)(struct kiocb *);
        ssize_t ret;
-        if (iocb->ki_retried++ > 1024*1024) {
-                printk("Maximal retry count.  Bytes done %Zd\n",
-                        iocb->ki_nbytes - iocb->ki_left);
-                return -EAGAIN;
-        }
-        if (!(iocb->ki_retried & 0xff)) {
-                pr_debug("%ld retry: %zd of %zd\n", iocb->ki_retried,
-                        iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes);
-        }
        if (!(retry = iocb->ki_retry)) {
                printk("aio_run_iocb: iocb->ki_retry = NULL\n");
                return 0;
@@ -859,9 +846,9 @@ static inline void aio_run_all_iocbs(struct kioctx *ctx)
 *      space.
 * Run on aiod's context.
 */
-static void aio_kick_handler(void *data)
+static void aio_kick_handler(struct work_struct *work)
 {
-        struct kioctx *ctx = data;
+        struct kioctx *ctx = container_of(work, struct kioctx, wq.work);
        mm_segment_t oldfs = get_fs();
        int requeue;
@@ -876,7 +863,7 @@ static void aio_kick_handler(void *data)
         * we're in a worker thread already, don't use queue_delayed_work,
         */
        if (requeue)
-                queue_work(aio_wq, &ctx->wq);
+                queue_delayed_work(aio_wq, &ctx->wq, 0);
 }
@@ -1007,9 +994,6 @@ int fastcall aio_complete(struct kiocb *iocb, long res, long res2)
        kunmap_atomic(ring, KM_IRQ1);
        pr_debug("added to ring %p at [%lu]\n", iocb, tail);
-        pr_debug("%ld retries: %zd of %zd\n", iocb->ki_retried,
-                iocb->ki_nbytes - iocb->ki_left, iocb->ki_nbytes);
 put_rq:
        /* everything turned out well, dispose of the aiocb. */
        ret = __aio_put_req(ctx, iocb);
@@ -1415,7 +1399,6 @@ static ssize_t aio_setup_single_vector(struct kiocb *kiocb)
        kiocb->ki_iovec->iov_len = kiocb->ki_left;
        kiocb->ki_nr_segs = 1;
        kiocb->ki_cur_seg = 0;
-        kiocb->ki_nbytes = kiocb->ki_left;
        return 0;
 }
@@ -1593,7 +1576,6 @@ int fastcall io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
        req->ki_opcode = iocb->aio_lio_opcode;
        init_waitqueue_func_entry(&req->ki_wait, aio_wake_function);
        INIT_LIST_HEAD(&req->ki_wait.task_list);
-        req->ki_retried = 0;
        ret = aio_setup_iocb(req);
diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c
index 38ede5c9d6fd..f968d1342808 100644
--- a/fs/autofs/inode.c
+++ b/fs/autofs/inode.c
@@ -28,10 +28,11 @@ void autofs_kill_sb(struct super_block *sb)
        /*
         * In the event of a failure in get_sb_nodev the superblock
         * info is not present so nothing else has been setup, so
-         * just exit when we are called from deactivate_super.
+         * just call kill_anon_super when we are called from
+         * deactivate_super.
         */
        if (!sbi)
-                return;
+                goto out_kill_sb;
        if ( !sbi->catatonic )
                autofs_catatonic_mode(sbi); /* Free wait queues, close pipe */
@@ -44,6 +45,7 @@ void autofs_kill_sb(struct super_block *sb)
        kfree(sb->s_fs_info);
+out_kill_sb:
        DPRINTK(("autofs: shutting down\n"));
        kill_anon_super(sb);
 }
@@ -209,7 +211,6 @@ fail_iput:
 fail_free:
        kfree(sbi);
        s->s_fs_info = NULL;
-        kill_anon_super(s);
 fail_unlock:
        return -EINVAL;
 }
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index ce7c0f1dd529..9c48250fd726 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -152,10 +152,11 @@ void autofs4_kill_sb(struct super_block *sb)
        /*
         * In the event of a failure in get_sb_nodev the superblock
         * info is not present so nothing else has been setup, so
-         * just exit when we are called from deactivate_super.
+         * just call kill_anon_super when we are called from
+         * deactivate_super.
         */
        if (!sbi)
-                return;
+                goto out_kill_sb;
        sb->s_fs_info = NULL;
@@ -167,6 +168,7 @@ void autofs4_kill_sb(struct super_block *sb)
        kfree(sbi);
+out_kill_sb:
        DPRINTK("shutting down");
        kill_anon_super(sb);
 }
@@ -426,7 +428,6 @@ fail_ino:
 fail_free:
        kfree(sbi);
        s->s_fs_info = NULL;
-        kill_anon_super(s);
 fail_unlock:
        return -EINVAL;
 }
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 07f7144f0e2e..bce402eee554 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -61,7 +61,7 @@ static const struct super_operations befs_sops = {
 };
 /* slab cache for befs_inode_info objects */
-static kmem_cache_t *befs_inode_cachep;
+static struct kmem_cache *befs_inode_cachep;
 static const struct file_operations befs_dir_operations = {
        .read           = generic_read_dir,
@@ -277,7 +277,7 @@ befs_alloc_inode(struct super_block *sb)
 {
        struct befs_inode_info *bi;
        bi = (struct befs_inode_info *)kmem_cache_alloc(befs_inode_cachep,
-                                                        SLAB_KERNEL);
+                                                        GFP_KERNEL);
        if (!bi)
                return NULL;
        return &bi->vfs_inode;
@@ -289,7 +289,7 @@ befs_destroy_inode(struct inode *inode)
        kmem_cache_free(befs_inode_cachep, BEFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct befs_inode_info *bi = (struct befs_inode_info *) foo;
        
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index ed27ffb3459e..eac175ed9f44 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -228,12 +228,12 @@ static void bfs_write_super(struct super_block *s)
        unlock_kernel();
 }
-static kmem_cache_t * bfs_inode_cachep;
+static struct kmem_cache * bfs_inode_cachep;
 static struct inode *bfs_alloc_inode(struct super_block *sb)
 {
        struct bfs_inode_info *bi;
-        bi = kmem_cache_alloc(bfs_inode_cachep, SLAB_KERNEL);
+        bi = kmem_cache_alloc(bfs_inode_cachep, GFP_KERNEL);
        if (!bi)
                return NULL;
        return &bi->vfs_inode;
@@ -244,7 +244,7 @@ static void bfs_destroy_inode(struct inode *inode)
        kmem_cache_free(bfs_inode_cachep, BFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct bfs_inode_info *bi = foo;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 79b05a1a4365..be5869d34999 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -47,10 +47,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
 static int load_elf_library(struct file *);
 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);
-#ifndef elf_addr_t
-#define elf_addr_t unsigned long
-#endif
 /*
 * If we don't support core dumping, then supply a NULL so we
 * don't even try.
@@ -243,8 +239,9 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
        if (interp_aout) {
                argv = sp + 2;
                envp = argv + argc + 1;
-                __put_user((elf_addr_t)(unsigned long)argv, sp++);
+                if (__put_user((elf_addr_t)(unsigned long)argv, sp++) ||
-                __put_user((elf_addr_t)(unsigned long)envp, sp++);
+                    __put_user((elf_addr_t)(unsigned long)envp, sp++))
+                        return -EFAULT;
        } else {
                argv = sp;
                envp = argv + argc + 1;
@@ -254,7 +251,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
        p = current->mm->arg_end = current->mm->arg_start;
        while (argc-- > 0) {
                size_t len;
-                __put_user((elf_addr_t)p, argv++);
+                if (__put_user((elf_addr_t)p, argv++))
+                        return -EFAULT;
                len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return 0;
@@ -265,7 +263,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
        current->mm->arg_end = current->mm->env_start = p;
        while (envc-- > 0) {
                size_t len;
-                __put_user((elf_addr_t)p, envp++);
+                if (__put_user((elf_addr_t)p, envp++))
+                        return -EFAULT;
                len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return 0;
@@ -545,7 +544,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
        unsigned long reloc_func_desc = 0;
        char passed_fileno[6];
        struct files_struct *files;
-        int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;
+        int executable_stack = EXSTACK_DEFAULT;
        unsigned long def_flags = 0;
        struct {
                struct elfhdr elf_ex;
@@ -708,7 +707,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                                executable_stack = EXSTACK_DISABLE_X;
                        break;
                }
-        have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);
        /* Some simple consistency checks for the interpreter */
        if (elf_interpreter) {
@@ -856,7 +854,13 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                         * default mmap base, as well as whatever program they
                         * might try to exec.  This is because the brk will
                         * follow the loader, and is not movable.  */
-                        load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
+                        if (current->flags & PF_RANDOMIZE)
+                                load_bias = randomize_range(0x10000,
+                                                            ELF_ET_DYN_BASE,
+                                                            0);
+                        else
+                                load_bias = ELF_ET_DYN_BASE;
+                        load_bias = ELF_PAGESTART(load_bias - vaddr);
                }
                error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
@@ -1582,6 +1586,10 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
                
                sz += thread_status_size;
+#ifdef ELF_CORE_WRITE_EXTRA_NOTES
+                sz += ELF_CORE_EXTRA_NOTES_SIZE;
+#endif
                fill_elf_note_phdr(&phdr, sz, offset);
                offset += sz;
                DUMP_WRITE(&phdr, sizeof(phdr));
@@ -1622,6 +1630,10 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
                if (!writenote(notes + i, file, &foffset))
                        goto end_coredump;
+#ifdef ELF_CORE_WRITE_EXTRA_NOTES
+        ELF_CORE_WRITE_EXTRA_NOTES;
+#endif
        /* write out the thread status notes section */
        list_for_each(t, &thread_list) {
                struct elf_thread_status *tmp =
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index f86d5c9ce5eb..ed9a61c6beb3 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -40,9 +40,6 @@
 #include <asm/pgalloc.h>
 typedef char *elf_caddr_t;
-#ifndef elf_addr_t
-#define elf_addr_t unsigned long
-#endif
 #if 0
 #define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
diff --git a/fs/bio.c b/fs/bio.c
index f95c8749499f..7ec737eda72b 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -30,7 +30,7 @@
 #define BIO_POOL_SIZE 256
-static kmem_cache_t *bio_slab __read_mostly;
+static struct kmem_cache *bio_slab __read_mostly;
 #define BIOVEC_NR_POOLS 6
@@ -44,7 +44,7 @@ mempool_t *bio_split_pool __read_mostly;
 struct biovec_slab {
        int nr_vecs;
        char *name; 
-        kmem_cache_t *slab;
+        struct kmem_cache *slab;
 };
 /*
@@ -560,10 +560,8 @@ struct bio *bio_copy_user(request_queue_t *q, unsigned long uaddr,
                        break;
                }
-                if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes) {
+                if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
-                        ret = -EINVAL;
                        break;
-                }
                len -= bytes;
        }
@@ -622,10 +620,9 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
                nr_pages += end - start;
                /*
-                 * transfer and buffer must be aligned to at least hardsector
+                 * buffer must be aligned to at least hardsector size for now
-                 * size for now, in the future we can relax this restriction
                 */
-                if ((uaddr & queue_dma_alignment(q)) || (len & queue_dma_alignment(q)))
+                if (uaddr & queue_dma_alignment(q))
                        return ERR_PTR(-EINVAL);
        }
@@ -751,7 +748,6 @@ struct bio *bio_map_user_iov(request_queue_t *q, struct block_device *bdev,
                             int write_to_vm)
 {
        struct bio *bio;
-        int len = 0, i;
        bio = __bio_map_user_iov(q, bdev, iov, iov_count, write_to_vm);
@@ -766,18 +762,7 @@ struct bio *bio_map_user_iov(request_queue_t *q, struct block_device *bdev,
         */
        bio_get(bio);
-        for (i = 0; i < iov_count; i++)
+        return bio;
-                len += iov[i].iov_len;
-        if (bio->bi_size == len)
-                return bio;
-        /*
-         * don't support partial mappings
-         */
-        bio_endio(bio, bio->bi_size, 0);
-        bio_unmap_user(bio);
-        return ERR_PTR(-EINVAL);
 }
 static void __bio_unmap_user(struct bio *bio)
@@ -955,16 +940,16 @@ static void bio_release_pages(struct bio *bio)
 * run one bio_put() against the BIO.
 */
-static void bio_dirty_fn(void *data);
+static void bio_dirty_fn(struct work_struct *work);
-static DECLARE_WORK(bio_dirty_work, bio_dirty_fn, NULL);
+static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
 static DEFINE_SPINLOCK(bio_dirty_lock);
 static struct bio *bio_dirty_list;
 /*
 * This runs in process context
 */
-static void bio_dirty_fn(void *data)
+static void bio_dirty_fn(struct work_struct *work)
 {
        unsigned long flags;
        struct bio *bio;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 36c0e7af9d0f..13816b4d76f6 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -235,11 +235,11 @@ 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 __read_mostly;
+static struct kmem_cache * bdev_cachep __read_mostly;
 static struct inode *bdev_alloc_inode(struct super_block *sb)
 {
-        struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, SLAB_KERNEL);
+        struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -253,7 +253,7 @@ static void bdev_destroy_inode(struct inode *inode)
        kmem_cache_free(bdev_cachep, bdi);
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct bdev_inode *ei = (struct bdev_inode *) foo;
        struct block_device *bdev = &ei->bdev;
diff --git a/fs/buffer.c b/fs/buffer.c
index 35527dca1dbc..517860f2d75b 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2908,7 +2908,7 @@ asmlinkage long sys_bdflush(int func, long data)
 /*
 * Buffer-head allocation
 */
-static kmem_cache_t *bh_cachep;
+static struct kmem_cache *bh_cachep;
 /*
 * Once the number of bh's in the machine exceeds this level, we start
@@ -2961,7 +2961,7 @@ void free_buffer_head(struct buffer_head *bh)
 EXPORT_SYMBOL(free_buffer_head);
 static void
-init_buffer_head(void *data, kmem_cache_t *cachep, unsigned long flags)
+init_buffer_head(void *data, struct kmem_cache *cachep, unsigned long flags)
 {
        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
                            SLAB_CTOR_CONSTRUCTOR) {
@@ -2972,7 +2972,6 @@ init_buffer_head(void *data, kmem_cache_t *cachep, unsigned long flags)
        }
 }
-#ifdef CONFIG_HOTPLUG_CPU
 static void buffer_exit_cpu(int cpu)
 {
        int i;
@@ -2994,7 +2993,6 @@ static int buffer_cpu_notify(struct notifier_block *self,
                buffer_exit_cpu((unsigned long)hcpu);
        return NOTIFY_OK;
 }
-#endif /* CONFIG_HOTPLUG_CPU */
 void __init buffer_init(void)
 {
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 84976cdbe713..71bc87a37fc1 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -34,6 +34,7 @@
 #include <linux/mempool.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/freezer.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
 #define DECLARE_GLOBALS_HERE
@@ -81,7 +82,7 @@ extern mempool_t *cifs_sm_req_poolp;
 extern mempool_t *cifs_req_poolp;
 extern mempool_t *cifs_mid_poolp;
-extern kmem_cache_t *cifs_oplock_cachep;
+extern struct kmem_cache *cifs_oplock_cachep;
 static int
 cifs_read_super(struct super_block *sb, void *data,
@@ -232,11 +233,11 @@ static int cifs_permission(struct inode * inode, int mask, struct nameidata *nd)
                return generic_permission(inode, mask, NULL);
 }
-static kmem_cache_t *cifs_inode_cachep;
+static struct kmem_cache *cifs_inode_cachep;
-static kmem_cache_t *cifs_req_cachep;
+static struct kmem_cache *cifs_req_cachep;
-static kmem_cache_t *cifs_mid_cachep;
+static struct kmem_cache *cifs_mid_cachep;
-kmem_cache_t *cifs_oplock_cachep;
+struct kmem_cache *cifs_oplock_cachep;
-static kmem_cache_t *cifs_sm_req_cachep;
+static struct kmem_cache *cifs_sm_req_cachep;
 mempool_t *cifs_sm_req_poolp;
 mempool_t *cifs_req_poolp;
 mempool_t *cifs_mid_poolp;
@@ -245,7 +246,7 @@ static struct inode *
 cifs_alloc_inode(struct super_block *sb)
 {
        struct cifsInodeInfo *cifs_inode;
-        cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
+        cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
        if (!cifs_inode)
                return NULL;
        cifs_inode->cifsAttrs = 0x20;   /* default */
@@ -668,7 +669,7 @@ const struct file_operations cifs_dir_ops = {
 };
 static void
-cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
+cifs_init_once(void *inode, struct kmem_cache * cachep, unsigned long flags)
 {
        struct cifsInodeInfo *cifsi = inode;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 71f77914ce93..2caca06b4bae 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -31,6 +31,7 @@
 #include <linux/delay.h>
 #include <linux/completion.h>
 #include <linux/pagevec.h>
+#include <linux/freezer.h>
 #include <asm/uaccess.h>
 #include <asm/processor.h>
 #include "cifspdu.h"
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 1ad8c9fcc742..c4fa91b8b62f 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -318,6 +318,7 @@ int cifs_get_inode_info(struct inode **pinode,
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
        char *tmp_path;
        char *buf = NULL;
+        int adjustTZ = FALSE;
        pTcon = cifs_sb->tcon;
        cFYI(1,("Getting info on %s", search_path));
@@ -348,6 +349,7 @@ int cifs_get_inode_info(struct inode **pinode,
                                        pfindData, cifs_sb->local_nls, 
                                        cifs_sb->mnt_cifs_flags &
                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        adjustTZ = TRUE;
                }
                
        }
@@ -444,6 +446,10 @@ int cifs_get_inode_info(struct inode **pinode,
                inode->i_ctime =
                    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
                cFYI(0, ("Attributes came in as 0x%x", attr));
+                if(adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
+                        inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
+                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
+                }
                /* set default mode. will override for dirs below */
                if (atomic_read(&cifsInfo->inUse) == 0)
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 0bee8b7e521a..8e259969354b 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -69,17 +69,30 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
                        rc = -EOPNOTSUPP;  
        }
-/* if (!rc)     */
+        d_drop(direntry);       /* force new lookup from server of target */
-        {
-                /*   renew_parental_timestamps(old_file);
+        /* if source file is cached (oplocked) revalidate will not go to server
-                   inode->i_nlink++;
+           until the file is closed or oplock broken so update nlinks locally */
-                   mark_inode_dirty(inode);
+        if(old_file->d_inode) {
-                   d_instantiate(direntry, inode); */
+                cifsInode = CIFS_I(old_file->d_inode);
-                /* BB add call to either mark inode dirty or refresh its data and timestamp to current time */
+                if(rc == 0) {
+                        old_file->d_inode->i_nlink++;
+                        old_file->d_inode->i_ctime = CURRENT_TIME;
+                        /* parent dir timestamps will update from srv
+                        within a second, would it really be worth it
+                        to set the parent dir cifs inode time to zero
+                        to force revalidate (faster) for it too? */
+                }
+                /* if not oplocked will force revalidate to get info 
+                   on source file from srv */
+                cifsInode->time = 0;
+                /* Will update parent dir timestamps from srv within a second.
+                   Would it really be worth it to set the parent dir (cifs
+                   inode) time field to zero to force revalidate on parent
+                   directory faster ie 
+                        CIFS_I(inode)->time = 0;  */
        }
-        d_drop(direntry);       /* force new lookup from server */
-        cifsInode = CIFS_I(old_file->d_inode);
-        cifsInode->time = 0;    /* will force revalidate to go get info when needed */
 cifs_hl_exit:
        kfree(fromName);
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index bbc9cd34b6ea..aedf683f011f 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -153,7 +153,7 @@ cifs_buf_get(void)
   albeit slightly larger than necessary and maxbuffersize 
   defaults to this and can not be bigger */
        ret_buf =
-            (struct smb_hdr *) mempool_alloc(cifs_req_poolp, SLAB_KERNEL | SLAB_NOFS);
+            (struct smb_hdr *) mempool_alloc(cifs_req_poolp, GFP_KERNEL | GFP_NOFS);
        /* clear the first few header bytes */
        /* for most paths, more is cleared in header_assemble */
@@ -192,7 +192,7 @@ cifs_small_buf_get(void)
   albeit slightly larger than necessary and maxbuffersize 
   defaults to this and can not be bigger */
        ret_buf =
-            (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, SLAB_KERNEL | SLAB_NOFS);
+            (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, GFP_KERNEL | GFP_NOFS);
        if (ret_buf) {
        /* No need to clear memory here, cleared in header assemble */
        /*      memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 48d47b46b1fb..f80007eaebf4 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -34,7 +34,7 @@
 #include "cifs_debug.h"
  
 extern mempool_t *cifs_mid_poolp;
-extern kmem_cache_t *cifs_oplock_cachep;
+extern struct kmem_cache *cifs_oplock_cachep;
 static struct mid_q_entry *
 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
@@ -51,7 +51,7 @@ AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
        }
        
        temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,
-                                                    SLAB_KERNEL | SLAB_NOFS);
+                                                    GFP_KERNEL | GFP_NOFS);
        if (temp == NULL)
                return temp;
        else {
@@ -118,7 +118,7 @@ AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
                return NULL;
        }
        temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
-                                                       SLAB_KERNEL);
+                                                       GFP_KERNEL);
        if (temp == NULL)
                return temp;
        else {
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 88d123321164..b64659fa82d0 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -38,12 +38,12 @@ static void coda_clear_inode(struct inode *);
 static void coda_put_super(struct super_block *);
 static int coda_statfs(struct dentry *dentry, struct kstatfs *buf);
-static kmem_cache_t * coda_inode_cachep;
+static struct kmem_cache * coda_inode_cachep;
 static struct inode *coda_alloc_inode(struct super_block *sb)
 {
        struct coda_inode_info *ei;
-        ei = (struct coda_inode_info *)kmem_cache_alloc(coda_inode_cachep, SLAB_KERNEL);
+        ei = (struct coda_inode_info *)kmem_cache_alloc(coda_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        memset(&ei->c_fid, 0, sizeof(struct CodaFid));
@@ -58,7 +58,7 @@ static void coda_destroy_inode(struct inode *inode)
        kmem_cache_free(coda_inode_cachep, ITOC(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct coda_inode_info *ei = (struct coda_inode_info *) foo;
diff --git a/fs/compat.c b/fs/compat.c
index 8d0a0018a7d2..a7e3f162fb15 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -45,6 +45,8 @@
 #include <linux/personality.h>
 #include <linux/rwsem.h>
 #include <linux/tsacct_kern.h>
+#include <linux/highmem.h>
+#include <linux/poll.h>
 #include <linux/mm.h>
 #include <net/sock.h>           /* siocdevprivate_ioctl */
@@ -869,7 +871,7 @@ asmlinkage long compat_sys_mount(char __user * dev_name, char __user * dir_name,
        retval = -EINVAL;
-        if (type_page) {
+        if (type_page && data_page) {
                if (!strcmp((char *)type_page, SMBFS_NAME)) {
                        do_smb_super_data_conv((void *)data_page);
                } else if (!strcmp((char *)type_page, NCPFS_NAME)) {
@@ -1142,7 +1144,9 @@ asmlinkage long compat_sys_getdents64(unsigned int fd,
        lastdirent = buf.previous;
        if (lastdirent) {
                typeof(lastdirent->d_off) d_off = file->f_pos;
-                __put_user_unaligned(d_off, &lastdirent->d_off);
+                error = -EFAULT;
+                if (__put_user_unaligned(d_off, &lastdirent->d_off))
+                        goto out_putf;
                error = count - buf.count;
        }
@@ -1609,14 +1613,14 @@ int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
                nr &= ~1UL;
                while (nr) {
                        unsigned long h, l;
-                        __get_user(l, ufdset);
+                        if (__get_user(l, ufdset) || __get_user(h, ufdset+1))
-                        __get_user(h, ufdset+1);
+                                return -EFAULT;
                        ufdset += 2;
                        *fdset++ = h << 32 | l;
                        nr -= 2;
                }
-                if (odd)
+                if (odd && __get_user(*fdset, ufdset))
-                        __get_user(*fdset, ufdset);
+                        return -EFAULT;
        } else {
                /* Tricky, must clear full unsigned long in the
                 * kernel fdset at the end, this makes sure that
@@ -1628,14 +1632,14 @@ int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
 }
 static
-void compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
+int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
-                        unsigned long *fdset)
+                      unsigned long *fdset)
 {
        unsigned long odd;
        nr = ROUND_UP(nr, __COMPAT_NFDBITS);
        if (!ufdset)
-                return;
+                return 0;
        odd = nr & 1UL;
        nr &= ~1UL;
@@ -1643,13 +1647,14 @@ void compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
                unsigned long h, l;
                l = *fdset++;
                h = l >> 32;
-                __put_user(l, ufdset);
+                if (__put_user(l, ufdset) || __put_user(h, ufdset+1))
-                __put_user(h, ufdset+1);
+                        return -EFAULT;
                ufdset += 2;
                nr -= 2;
        }
-        if (odd)
+        if (odd && __put_user(*fdset, ufdset))
-                __put_user(*fdset, ufdset);
+                return -EFAULT;
+        return 0;
 }
@@ -1724,10 +1729,10 @@ int compat_core_sys_select(int n, compat_ulong_t __user *inp,
                ret = 0;
        }
-        compat_set_fd_set(n, inp, fds.res_in);
+        if (compat_set_fd_set(n, inp, fds.res_in) ||
-        compat_set_fd_set(n, outp, fds.res_out);
+            compat_set_fd_set(n, outp, fds.res_out) ||
-        compat_set_fd_set(n, exp, fds.res_ex);
+            compat_set_fd_set(n, exp, fds.res_ex))
+                ret = -EFAULT;
 out:
        kfree(bits);
 out_nofds:
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index a91f2628c981..bcc3caf5d820 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -211,8 +211,10 @@ static int do_video_stillpicture(unsigned int fd, unsigned int cmd, unsigned lon
        up_native =
                compat_alloc_user_space(sizeof(struct video_still_picture));
-        put_user(compat_ptr(fp), &up_native->iFrame);
+        err =  put_user(compat_ptr(fp), &up_native->iFrame);
-        put_user(size, &up_native->size);
+        err |= put_user(size, &up_native->size);
+        if (err)
+                return -EFAULT;
        err = sys_ioctl(fd, cmd, (unsigned long) up_native);
@@ -236,8 +238,10 @@ static int do_video_set_spu_palette(unsigned int fd, unsigned int cmd, unsigned
        err |= get_user(length, &up->length);
        up_native = compat_alloc_user_space(sizeof(struct video_spu_palette));
-        put_user(compat_ptr(palp), &up_native->palette);
+        err  = put_user(compat_ptr(palp), &up_native->palette);
-        put_user(length, &up_native->length);
+        err |= put_user(length, &up_native->length);
+        if (err)
+                return -EFAULT;
        err = sys_ioctl(fd, cmd, (unsigned long) up_native);
@@ -2043,16 +2047,19 @@ static int serial_struct_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
        struct serial_struct ss;
        mm_segment_t oldseg = get_fs();
        __u32 udata;
+        unsigned int base;
        if (cmd == TIOCSSERIAL) {
                if (!access_ok(VERIFY_READ, ss32, sizeof(SS32)))
                        return -EFAULT;
                if (__copy_from_user(&ss, ss32, offsetof(SS32, iomem_base)))
                        return -EFAULT;
-                __get_user(udata, &ss32->iomem_base);
+                if (__get_user(udata, &ss32->iomem_base))
+                        return -EFAULT;
                ss.iomem_base = compat_ptr(udata);
-                __get_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
+                if (__get_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift) ||
-                __get_user(ss.port_high, &ss32->port_high);
+                    __get_user(ss.port_high, &ss32->port_high))
+                        return -EFAULT;
                ss.iomap_base = 0UL;
        }
        set_fs(KERNEL_DS);
@@ -2063,12 +2070,12 @@ static int serial_struct_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
                        return -EFAULT;
                if (__copy_to_user(ss32,&ss,offsetof(SS32,iomem_base)))
                        return -EFAULT;
-                __put_user((unsigned long)ss.iomem_base  >> 32 ?
+                base = (unsigned long)ss.iomem_base  >> 32 ?
-                            0xffffffff : (unsigned)(unsigned long)ss.iomem_base,
+                        0xffffffff : (unsigned)(unsigned long)ss.iomem_base;
-                            &ss32->iomem_base);
+                if (__put_user(base, &ss32->iomem_base) ||
-                __put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
+                    __put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift) ||
-                __put_user(ss.port_high, &ss32->port_high);
+                    __put_user(ss.port_high, &ss32->port_high))
+                        return -EFAULT;
        }
        return err;
 }
@@ -2397,6 +2404,7 @@ HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
 HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
 HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
 HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
+HANDLE_IOCTL(SIOCSIFHWBROADCAST, dev_ifsioc)
 /* ioctls used by appletalk ddp.c */
 HANDLE_IOCTL(SIOCATALKDIFADDR, dev_ifsioc)
diff --git a/fs/configfs/configfs_internal.h b/fs/configfs/configfs_internal.h
index 3f4ff7a242b9..f92cd303d2c9 100644
--- a/fs/configfs/configfs_internal.h
+++ b/fs/configfs/configfs_internal.h
@@ -49,7 +49,7 @@ struct configfs_dirent {
 #define CONFIGFS_NOT_PINNED     (CONFIGFS_ITEM_ATTR)
 extern struct vfsmount * configfs_mount;
-extern kmem_cache_t *configfs_dir_cachep;
+extern struct kmem_cache *configfs_dir_cachep;
 extern int configfs_is_root(struct config_item *item);
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 8a3b6a1a6ad1..c398861f78a5 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -93,8 +93,8 @@ static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent * pare
 *
 * called with parent inode's i_mutex held
 */
-int configfs_dirent_exists(struct configfs_dirent *parent_sd,
+static int configfs_dirent_exists(struct configfs_dirent *parent_sd,
-                           const unsigned char *new)
+                                  const unsigned char *new)
 {
        struct configfs_dirent * sd;
@@ -1176,8 +1176,9 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
                return;
        }
-        mutex_lock(&configfs_sb->s_root->d_inode->i_mutex);
+        mutex_lock_nested(&configfs_sb->s_root->d_inode->i_mutex,
-        mutex_lock(&dentry->d_inode->i_mutex);
+                          I_MUTEX_PARENT);
+        mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
        if (configfs_detach_prep(dentry)) {
                printk(KERN_ERR "configfs: Tried to unregister non-empty subsystem!\n");
        }
diff --git a/fs/configfs/mount.c b/fs/configfs/mount.c
index 68bd5c93ca52..ed678529ebb2 100644
--- a/fs/configfs/mount.c
+++ b/fs/configfs/mount.c
@@ -38,7 +38,7 @@
 struct vfsmount * configfs_mount = NULL;
 struct super_block * configfs_sb = NULL;
-kmem_cache_t *configfs_dir_cachep;
+struct kmem_cache *configfs_dir_cachep;
 static int configfs_mnt_count = 0;
 static struct super_operations configfs_ops = {
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index a624c3ec8189..0509cedd415c 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -481,6 +481,8 @@ static int cramfs_readpage(struct file *file, struct page * page)
                pgdata = kmap(page);
                if (compr_len == 0)
                        ; /* hole */
+                else if (compr_len > (PAGE_CACHE_SIZE << 1))
+                        printk(KERN_ERR "cramfs: bad compressed blocksize %u\n", compr_len);
                else {
                        mutex_lock(&read_mutex);
                        bytes_filled = cramfs_uncompress_block(pgdata,
diff --git a/fs/dcache.c b/fs/dcache.c
index fd4a428998ef..d68631f18df1 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -43,7 +43,7 @@ static __cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock);
 EXPORT_SYMBOL(dcache_lock);
-static kmem_cache_t *dentry_cache __read_mostly;
+static struct kmem_cache *dentry_cache __read_mostly;
 #define DNAME_INLINE_LEN (sizeof(struct dentry)-offsetof(struct dentry,d_iname))
@@ -68,15 +68,19 @@ struct dentry_stat_t dentry_stat = {
        .age_limit = 45,
 };
-static void d_callback(struct rcu_head *head)
+static void __d_free(struct dentry *dentry)
 {
-        struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu);
        if (dname_external(dentry))
                kfree(dentry->d_name.name);
        kmem_cache_free(dentry_cache, dentry); 
 }
+static void d_callback(struct rcu_head *head)
+{
+        struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu);
+        __d_free(dentry);
+}
 /*
 * no dcache_lock, please.  The caller must decrement dentry_stat.nr_dentry
 * inside dcache_lock.
@@ -85,7 +89,11 @@ static void d_free(struct dentry *dentry)
 {
        if (dentry->d_op && dentry->d_op->d_release)
                dentry->d_op->d_release(dentry);
-        call_rcu(&dentry->d_u.d_rcu, d_callback);
+        /* if dentry was never inserted into hash, immediate free is OK */
+        if (dentry->d_hash.pprev == NULL)
+                __d_free(dentry);
+        else
+                call_rcu(&dentry->d_u.d_rcu, d_callback);
 }
 /*
@@ -2072,10 +2080,10 @@ static void __init dcache_init(unsigned long mempages)
 }
 /* SLAB cache for __getname() consumers */
-kmem_cache_t *names_cachep __read_mostly;
+struct kmem_cache *names_cachep __read_mostly;
 /* SLAB cache for file structures */
-kmem_cache_t *filp_cachep __read_mostly;
+struct kmem_cache *filp_cachep __read_mostly;
 EXPORT_SYMBOL(d_genocide);
diff --git a/fs/dcookies.c b/fs/dcookies.c
index 0c4b0674854b..21af1629f9bc 100644
--- a/fs/dcookies.c
+++ b/fs/dcookies.c
@@ -37,7 +37,7 @@ struct dcookie_struct {
 static LIST_HEAD(dcookie_users);
 static DEFINE_MUTEX(dcookie_mutex);
-static kmem_cache_t *dcookie_cache __read_mostly;
+static struct kmem_cache *dcookie_cache __read_mostly;
 static struct list_head *dcookie_hashtable __read_mostly;
 static size_t hash_size __read_mostly;
diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
index 989b608fd836..5352b03ff5aa 100644
--- a/fs/dlm/memory.c
+++ b/fs/dlm/memory.c
@@ -15,7 +15,7 @@
 #include "config.h"
 #include "memory.h"
-static kmem_cache_t *lkb_cache;
+static struct kmem_cache *lkb_cache;
 int dlm_memory_init(void)
diff --git a/fs/dnotify.c b/fs/dnotify.c
index 2b0442db67e0..1f26a2b9eee1 100644
--- a/fs/dnotify.c
+++ b/fs/dnotify.c
@@ -23,7 +23,7 @@
 int dir_notify_enable __read_mostly = 1;
-static kmem_cache_t *dn_cache __read_mostly;
+static struct kmem_cache *dn_cache __read_mostly;
 static void redo_inode_mask(struct inode *inode)
 {
@@ -77,7 +77,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
        inode = filp->f_dentry->d_inode;
        if (!S_ISDIR(inode->i_mode))
                return -ENOTDIR;
-        dn = kmem_cache_alloc(dn_cache, SLAB_KERNEL);
+        dn = kmem_cache_alloc(dn_cache, GFP_KERNEL);
        if (dn == NULL)
                return -ENOMEM;
        spin_lock(&inode->i_lock);
diff --git a/fs/dquot.c b/fs/dquot.c
index 9af789567e51..f9cd5e23ebdf 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -131,7 +131,7 @@ static struct quota_format_type *quota_formats;	/* List of registered formats */
 static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
 /* SLAB cache for dquot structures */
-static kmem_cache_t *dquot_cachep;
+static struct kmem_cache *dquot_cachep;
 int register_quota_format(struct quota_format_type *fmt)
 {
@@ -600,7 +600,7 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
 {
        struct dquot *dquot;
-        dquot = kmem_cache_alloc(dquot_cachep, SLAB_NOFS);
+        dquot = kmem_cache_alloc(dquot_cachep, GFP_NOFS);
        if(!dquot)
                return NODQUOT;
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index f63a7755fe86..7196f50fe152 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -628,7 +628,7 @@ int ecryptfs_decrypt_page(struct file *file, struct page *page)
        num_extents_per_page = PAGE_CACHE_SIZE / crypt_stat->extent_size;
        base_extent = (page->index * num_extents_per_page);
        lower_page_virt = kmem_cache_alloc(ecryptfs_lower_page_cache,
-                                           SLAB_KERNEL);
+                                           GFP_KERNEL);
        if (!lower_page_virt) {
                rc = -ENOMEM;
                ecryptfs_printk(KERN_ERR, "Error getting page for encrypted "
@@ -1334,7 +1334,7 @@ int ecryptfs_write_headers(struct dentry *ecryptfs_dentry,
                goto out;
        }
        /* Released in this function */
-        page_virt = kmem_cache_alloc(ecryptfs_header_cache_0, SLAB_USER);
+        page_virt = kmem_cache_alloc(ecryptfs_header_cache_0, GFP_USER);
        if (!page_virt) {
                ecryptfs_printk(KERN_ERR, "Out of memory\n");
                rc = -ENOMEM;
@@ -1493,7 +1493,7 @@ int ecryptfs_read_headers(struct dentry *ecryptfs_dentry,
            &ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->crypt_stat;
        /* Read the first page from the underlying file */
-        page_virt = kmem_cache_alloc(ecryptfs_header_cache_1, SLAB_USER);
+        page_virt = kmem_cache_alloc(ecryptfs_header_cache_1, GFP_USER);
        if (!page_virt) {
                rc = -ENOMEM;
                ecryptfs_printk(KERN_ERR, "Unable to allocate page_virt\n");
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index a92ef05eff8f..42099e779a56 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -250,7 +250,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
        int lower_flags;
        /* Released in ecryptfs_release or end of function if failure */
-        file_info = kmem_cache_alloc(ecryptfs_file_info_cache, SLAB_KERNEL);
+        file_info = kmem_cache_alloc(ecryptfs_file_info_cache, GFP_KERNEL);
        ecryptfs_set_file_private(file, file_info);
        if (!file_info) {
                ecryptfs_printk(KERN_ERR,
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index dfcc68484f47..8a1945a84c36 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -369,7 +369,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
        BUG_ON(!atomic_read(&lower_dentry->d_count));
        ecryptfs_set_dentry_private(dentry,
                                    kmem_cache_alloc(ecryptfs_dentry_info_cache,
-                                                     SLAB_KERNEL));
+                                                     GFP_KERNEL));
        if (!ecryptfs_dentry_to_private(dentry)) {
                rc = -ENOMEM;
                ecryptfs_printk(KERN_ERR, "Out of memory whilst attempting "
@@ -404,7 +404,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
        /* Released in this function */
        page_virt =
            (char *)kmem_cache_alloc(ecryptfs_header_cache_2,
-                                     SLAB_USER);
+                                     GFP_USER);
        if (!page_virt) {
                rc = -ENOMEM;
                ecryptfs_printk(KERN_ERR,
@@ -795,7 +795,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
        /* Released at out_free: label */
        ecryptfs_set_file_private(&fake_ecryptfs_file,
                                  kmem_cache_alloc(ecryptfs_file_info_cache,
-                                                   SLAB_KERNEL));
+                                                   GFP_KERNEL));
        if (unlikely(!ecryptfs_file_to_private(&fake_ecryptfs_file))) {
                rc = -ENOMEM;
                goto out;
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index c3746f56d162..745c0f1bfbbd 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -207,7 +207,7 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
        /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
         * at end of function upon failure */
        auth_tok_list_item =
-            kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache, SLAB_KERNEL);
+            kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
        if (!auth_tok_list_item) {
                ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
                rc = -ENOMEM;
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index a78d87d14baf..3ede12b25933 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -378,7 +378,7 @@ ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
        /* Released in ecryptfs_put_super() */
        ecryptfs_set_superblock_private(sb,
                                        kmem_cache_alloc(ecryptfs_sb_info_cache,
-                                                         SLAB_KERNEL));
+                                                         GFP_KERNEL));
        if (!ecryptfs_superblock_to_private(sb)) {
                ecryptfs_printk(KERN_WARNING, "Out of memory\n");
                rc = -ENOMEM;
@@ -402,7 +402,7 @@ ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
        /* through deactivate_super(sb) from get_sb_nodev() */
        ecryptfs_set_dentry_private(sb->s_root,
                                    kmem_cache_alloc(ecryptfs_dentry_info_cache,
-                                                     SLAB_KERNEL));
+                                                     GFP_KERNEL));
        if (!ecryptfs_dentry_to_private(sb->s_root)) {
                ecryptfs_printk(KERN_ERR,
                                "dentry_info_cache alloc failed\n");
@@ -546,7 +546,7 @@ inode_info_init_once(void *vptr, struct kmem_cache *cachep, unsigned long flags)
 }
 static struct ecryptfs_cache_info {
-        kmem_cache_t **cache;
+        struct kmem_cache **cache;
        const char *name;
        size_t size;
        void (*ctor)(void*, struct kmem_cache *, unsigned long);
@@ -691,7 +691,7 @@ static ssize_t version_show(struct ecryptfs_obj *obj, char *buff)
 static struct ecryptfs_attribute sysfs_attr_version = __ATTR_RO(version);
-struct ecryptfs_version_str_map_elem {
+static struct ecryptfs_version_str_map_elem {
        u32 flag;
        char *str;
 } ecryptfs_version_str_map[] = {
diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
index 825757ae4867..eaa5daaf106e 100644
--- a/fs/ecryptfs/super.c
+++ b/fs/ecryptfs/super.c
@@ -50,7 +50,7 @@ static struct inode *ecryptfs_alloc_inode(struct super_block *sb)
        struct inode *inode = NULL;
        ecryptfs_inode = kmem_cache_alloc(ecryptfs_inode_info_cache,
-                                          SLAB_KERNEL);
+                                          GFP_KERNEL);
        if (unlikely(!ecryptfs_inode))
                goto out;
        ecryptfs_init_crypt_stat(&ecryptfs_inode->crypt_stat);
diff --git a/fs/efs/super.c b/fs/efs/super.c
index b3f50651eb6b..dfebf21289f4 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -52,12 +52,12 @@ static struct pt_types sgi_pt_types[] = {
 };
-static kmem_cache_t * efs_inode_cachep;
+static struct kmem_cache * efs_inode_cachep;
 static struct inode *efs_alloc_inode(struct super_block *sb)
 {
        struct efs_inode_info *ei;
-        ei = (struct efs_inode_info *)kmem_cache_alloc(efs_inode_cachep, SLAB_KERNEL);
+        ei = (struct efs_inode_info *)kmem_cache_alloc(efs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -68,7 +68,7 @@ static void efs_destroy_inode(struct inode *inode)
        kmem_cache_free(efs_inode_cachep, INODE_INFO(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct efs_inode_info *ei = (struct efs_inode_info *) foo;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index ae228ec54e94..88a6f8d0b88e 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -283,10 +283,10 @@ static struct mutex epmutex;
 static struct poll_safewake psw;
 /* Slab cache used to allocate "struct epitem" */
-static kmem_cache_t *epi_cache __read_mostly;
+static struct kmem_cache *epi_cache __read_mostly;
 /* Slab cache used to allocate "struct eppoll_entry" */
-static kmem_cache_t *pwq_cache __read_mostly;
+static struct kmem_cache *pwq_cache __read_mostly;
 /* Virtual fs used to allocate inodes for eventpoll files */
 static struct vfsmount *eventpoll_mnt __read_mostly;
@@ -961,7 +961,7 @@ static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
        struct epitem *epi = ep_item_from_epqueue(pt);
        struct eppoll_entry *pwq;
-        if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, SLAB_KERNEL))) {
+        if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
                init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
                pwq->whead = whead;
                pwq->base = epi;
@@ -1004,7 +1004,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
        struct ep_pqueue epq;
        error = -ENOMEM;
-        if (!(epi = kmem_cache_alloc(epi_cache, SLAB_KERNEL)))
+        if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL)))
                goto eexit_1;
        /* Item initialization follow here ... */
diff --git a/fs/exec.c b/fs/exec.c
index d993ea1a81ae..add0e03c3ea9 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -404,7 +404,7 @@ int setup_arg_pages(struct linux_binprm *bprm,
                bprm->loader += stack_base;
        bprm->exec += stack_base;
-        mpnt = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
+        mpnt = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
        if (!mpnt)
                return -ENOMEM;
@@ -1515,7 +1515,8 @@ int do_coredump(long signr, int exit_code, struct pt_regs * regs)
                ispipe = 1;
        } else
                file = filp_open(corename,
-                                 O_CREAT | 2 | O_NOFOLLOW | O_LARGEFILE, 0600);
+                                 O_CREAT | 2 | O_NOFOLLOW | O_LARGEFILE | flag,
+                                 0600);
        if (IS_ERR(file))
                goto fail_unlock;
        inode = file->f_dentry->d_inode;
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index 1dfba77eab10..e3cf8c81507f 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -44,6 +44,7 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                if (!S_ISDIR(inode->i_mode))
                        flags &= ~EXT2_DIRSYNC_FL;
+                mutex_lock(&inode->i_mutex);
                oldflags = ei->i_flags;
                /*
@@ -53,13 +54,16 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                 * This test looks nicer. Thanks to Pauline Middelink
                 */
                if ((flags ^ oldflags) & (EXT2_APPEND_FL | EXT2_IMMUTABLE_FL)) {
-                        if (!capable(CAP_LINUX_IMMUTABLE))
+                        if (!capable(CAP_LINUX_IMMUTABLE)) {
+                                mutex_unlock(&inode->i_mutex);
                                return -EPERM;
+                        }
                }
                flags = flags & EXT2_FL_USER_MODIFIABLE;
                flags |= oldflags & ~EXT2_FL_USER_MODIFIABLE;
                ei->i_flags = flags;
+                mutex_unlock(&inode->i_mutex);
                ext2_set_inode_flags(inode);
                inode->i_ctime = CURRENT_TIME_SEC;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index d8b9abd95d07..255cef5f7420 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -135,12 +135,12 @@ static void ext2_put_super (struct super_block * sb)
        return;
 }
-static kmem_cache_t * ext2_inode_cachep;
+static struct kmem_cache * ext2_inode_cachep;
 static struct inode *ext2_alloc_inode(struct super_block *sb)
 {
        struct ext2_inode_info *ei;
-        ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, SLAB_KERNEL);
+        ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
@@ -156,7 +156,7 @@ static void ext2_destroy_inode(struct inode *inode)
        kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
@@ -1090,8 +1090,10 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
 {
        struct super_block *sb = dentry->d_sb;
        struct ext2_sb_info *sbi = EXT2_SB(sb);
+        struct ext2_super_block *es = sbi->s_es;
        unsigned long overhead;
        int i;
+        u64 fsid;
        if (test_opt (sb, MINIX_DF))
                overhead = 0;
@@ -1104,7 +1106,7 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
                 * All of the blocks before first_data_block are
                 * overhead
                 */
-                overhead = le32_to_cpu(sbi->s_es->s_first_data_block);
+                overhead = le32_to_cpu(es->s_first_data_block);
                /*
                 * Add the overhead attributed to the superblock and
@@ -1125,14 +1127,18 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
        buf->f_type = EXT2_SUPER_MAGIC;
        buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = le32_to_cpu(sbi->s_es->s_blocks_count) - overhead;
+        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
        buf->f_bfree = ext2_count_free_blocks(sb);
-        buf->f_bavail = buf->f_bfree - le32_to_cpu(sbi->s_es->s_r_blocks_count);
+        buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
-        if (buf->f_bfree < le32_to_cpu(sbi->s_es->s_r_blocks_count))
+        if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
                buf->f_bavail = 0;
-        buf->f_files = le32_to_cpu(sbi->s_es->s_inodes_count);
+        buf->f_files = le32_to_cpu(es->s_inodes_count);
-        buf->f_ffree = ext2_count_free_inodes (sb);
+        buf->f_ffree = ext2_count_free_inodes(sb);
        buf->f_namelen = EXT2_NAME_LEN;
+        fsid = le64_to_cpup((void *)es->s_uuid) ^
+               le64_to_cpup((void *)es->s_uuid + sizeof(u64));
+        buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
+        buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
        return 0;
 }
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index af52a7f8b291..247efd0b51d6 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -342,12 +342,9 @@ static void ext2_xattr_update_super_block(struct super_block *sb)
        if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR))
                return;
-        lock_super(sb);
+        EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
-        EXT2_SB(sb)->s_es->s_feature_compat |=
-                cpu_to_le32(EXT2_FEATURE_COMPAT_EXT_ATTR);
        sb->s_dirt = 1;
        mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
-        unlock_super(sb);
 }
 /*
diff --git a/fs/ext3/Makefile b/fs/ext3/Makefile
index 704cd44a40c2..e77766a8b3f0 100644
--- a/fs/ext3/Makefile
+++ b/fs/ext3/Makefile
@@ -5,7 +5,7 @@
 obj-$(CONFIG_EXT3_FS) += ext3.o
 ext3-y  := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
-           ioctl.o namei.o super.o symlink.o hash.o resize.o
+           ioctl.o namei.o super.o symlink.o hash.o resize.o ext3_jbd.o
 ext3-$(CONFIG_EXT3_FS_XATTR)     += xattr.o xattr_user.o xattr_trusted.o
 ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index b41a7d7e20f0..22161740ba29 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -144,7 +144,7 @@ restart:
        printk("Block Allocation Reservation Windows Map (%s):\n", fn);
        while (n) {
-                rsv = list_entry(n, struct ext3_reserve_window_node, rsv_node);
+                rsv = rb_entry(n, struct ext3_reserve_window_node, rsv_node);
                if (verbose)
                        printk("reservation window 0x%p "
                               "start:  %lu, end:  %lu\n",
@@ -730,7 +730,7 @@ find_next_usable_block(ext3_grpblk_t start, struct buffer_head *bh,
                here = 0;
        p = ((char *)bh->b_data) + (here >> 3);
-        r = memscan(p, 0, (maxblocks - here + 7) >> 3);
+        r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
        next = (r - ((char *)bh->b_data)) << 3;
        if (next < maxblocks && next >= start && ext3_test_allocatable(next, bh))
@@ -949,7 +949,7 @@ static int find_next_reservable_window(
                prev = rsv;
                next = rb_next(&rsv->rsv_node);
-                rsv = list_entry(next,struct ext3_reserve_window_node,rsv_node);
+                rsv = rb_entry(next,struct ext3_reserve_window_node,rsv_node);
                /*
                 * Reached the last reservation, we can just append to the
@@ -1148,7 +1148,7 @@ retry:
         * check if the first free block is within the
         * free space we just reserved
         */
-        if (start_block >= my_rsv->rsv_start && start_block < my_rsv->rsv_end)
+        if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
                return 0;               /* success */
        /*
         * if the first free bit we found is out of the reservable space
@@ -1193,7 +1193,7 @@ static void try_to_extend_reservation(struct ext3_reserve_window_node *my_rsv,
        if (!next)
                my_rsv->rsv_end += size;
        else {
-                next_rsv = list_entry(next, struct ext3_reserve_window_node, rsv_node);
+                next_rsv = rb_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;
@@ -1271,7 +1271,7 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
        }
        /*
         * grp_goal is a group relative block number (if there is a goal)
-         * 0 < grp_goal < EXT3_BLOCKS_PER_GROUP(sb)
+         * 0 <= grp_goal < EXT3_BLOCKS_PER_GROUP(sb)
         * first block is a filesystem wide block number
         * first block is the block number of the first block in this group
         */
@@ -1307,10 +1307,14 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
                        if (!goal_in_my_reservation(&my_rsv->rsv_window,
                                                        grp_goal, group, sb))
                                grp_goal = -1;
-                } else if (grp_goal > 0 &&
+                } else if (grp_goal >= 0) {
-                          (my_rsv->rsv_end-grp_goal+1) < *count)
+                        int curr = my_rsv->rsv_end -
-                        try_to_extend_reservation(my_rsv, sb,
+                                        (grp_goal + group_first_block) + 1;
-                                        *count-my_rsv->rsv_end + grp_goal - 1);
+                        if (curr < *count)
+                                try_to_extend_reservation(my_rsv, sb,
+                                                        *count - curr);
+                }
                if ((my_rsv->rsv_start > group_last_block) ||
                                (my_rsv->rsv_end < group_first_block)) {
@@ -1511,10 +1515,8 @@ retry_alloc:
                if (group_no >= ngroups)
                        group_no = 0;
                gdp = ext3_get_group_desc(sb, group_no, &gdp_bh);
-                if (!gdp) {
+                if (!gdp)
-                        *errp = -EIO;
+                        goto io_error;
-                        goto out;
-                }
                free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
                /*
                 * skip this group if the number of
@@ -1548,6 +1550,7 @@ retry_alloc:
         */
        if (my_rsv) {
                my_rsv = NULL;
+                windowsz = 0;
                group_no = goal_group;
                goto retry_alloc;
        }
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index d0b54f30b914..5a9313ecd4ef 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -154,6 +154,9 @@ static int ext3_readdir(struct file * filp,
                        ext3_error (sb, "ext3_readdir",
                                "directory #%lu contains a hole at offset %lu",
                                inode->i_ino, (unsigned long)filp->f_pos);
+                        /* corrupt size?  Maybe no more blocks to read */
+                        if (filp->f_pos > inode->i_blocks << 9)
+                                break;
                        filp->f_pos += sb->s_blocksize - offset;
                        continue;
                }
diff --git a/fs/ext3/ext3_jbd.c b/fs/ext3/ext3_jbd.c
new file mode 100644
index 000000000000..e1f91fd26a93
--- /dev/null
+++ b/fs/ext3/ext3_jbd.c
@@ -0,0 +1,59 @@
+/*
+ * Interface between ext3 and JBD
+ */
+#include <linux/ext3_jbd.h>
+int __ext3_journal_get_undo_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = journal_get_undo_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext3_journal_get_write_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = journal_get_write_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext3_journal_forget(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = journal_forget(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext3_journal_revoke(const char *where, handle_t *handle,
+                                unsigned long blocknr, struct buffer_head *bh)
+{
+        int err = journal_revoke(handle, blocknr, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext3_journal_get_create_access(const char *where,
+                                handle_t *handle, struct buffer_head *bh)
+{
+        int err = journal_get_create_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext3_journal_dirty_metadata(const char *where,
+                                handle_t *handle, struct buffer_head *bh)
+{
+        int err = journal_dirty_metadata(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 03ba5bcab186..beaf25f5112f 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1148,37 +1148,102 @@ static int do_journal_get_write_access(handle_t *handle,
        return ext3_journal_get_write_access(handle, bh);
 }
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext3_prepare_failure(struct file *file, struct page *page,
+                                unsigned from, unsigned to)
+{
+        struct address_space *mapping;
+        struct buffer_head *bh, *head, *next;
+        unsigned block_start, block_end;
+        unsigned blocksize;
+        int ret;
+        handle_t *handle = ext3_journal_current_handle();
+        mapping = page->mapping;
+        if (ext3_should_writeback_data(mapping->host)) {
+                /* optimization: no constraints about data */
+skip:
+                return ext3_journal_stop(handle);
+        }
+        head = page_buffers(page);
+        blocksize = head->b_size;
+        for (   bh = head, block_start = 0;
+                bh != head || !block_start;
+                block_start = block_end, bh = next)
+        {
+                next = bh->b_this_page;
+                block_end = block_start + blocksize;
+                if (block_end <= from)
+                        continue;
+                if (block_start >= to) {
+                        block_start = to;
+                        break;
+                }
+                if (!buffer_mapped(bh))
+                /* prepare_write failed on this bh */
+                        break;
+                if (ext3_should_journal_data(mapping->host)) {
+                        ret = do_journal_get_write_access(handle, bh);
+                        if (ret) {
+                                ext3_journal_stop(handle);
+                                return ret;
+                        }
+                }
+        /*
+         * block_start here becomes the first block where the current iteration
+         * of prepare_write failed.
+         */
+        }
+        if (block_start <= from)
+                goto skip;
+        /* commit allocated and zeroed buffers */
+        return mapping->a_ops->commit_write(file, page, from, block_start);
+}
 static int ext3_prepare_write(struct file *file, struct page *page,
                              unsigned from, unsigned to)
 {
        struct inode *inode = page->mapping->host;
-        int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+        int ret, ret2;
+        int needed_blocks = ext3_writepage_trans_blocks(inode);
        handle_t *handle;
        int retries = 0;
 retry:
        handle = ext3_journal_start(inode, needed_blocks);
-        if (IS_ERR(handle)) {
+        if (IS_ERR(handle))
-                ret = PTR_ERR(handle);
+                return PTR_ERR(handle);
-                goto out;
-        }
        if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
                ret = nobh_prepare_write(page, from, to, ext3_get_block);
        else
                ret = block_prepare_write(page, from, to, ext3_get_block);
        if (ret)
-                goto prepare_write_failed;
+                goto failure;
        if (ext3_should_journal_data(inode)) {
                ret = walk_page_buffers(handle, page_buffers(page),
                                from, to, NULL, do_journal_get_write_access);
+                if (ret)
+                        /* fatal error, just put the handle and return */
+                        journal_stop(handle);
        }
-prepare_write_failed:
+        return ret;
-        if (ret)
-                ext3_journal_stop(handle);
+failure:
+        ret2 = ext3_prepare_failure(file, page, from, to);
+        if (ret2 < 0)
+                return ret2;
        if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
                goto retry;
-out:
+        /* retry number exceeded, or other error like -EDQUOT */
        return ret;
 }
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 906731a20f1a..60d2f9dbdb00 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -552,6 +552,15 @@ static int htree_dirblock_to_tree(struct file *dir_file,
                                           dir->i_sb->s_blocksize -
                                           EXT3_DIR_REC_LEN(0));
        for (; de < top; de = ext3_next_entry(de)) {
+                if (!ext3_check_dir_entry("htree_dirblock_to_tree", dir, de, bh,
+                                        (block<<EXT3_BLOCK_SIZE_BITS(dir->i_sb))
+                                                +((char *)de - bh->b_data))) {
+                        /* On error, skip the f_pos to the next block. */
+                        dir_file->f_pos = (dir_file->f_pos |
+                                        (dir->i_sb->s_blocksize - 1)) + 1;
+                        brelse (bh);
+                        return count;
+                }
                ext3fs_dirhash(de->name, de->name_len, hinfo);
                if ((hinfo->hash < start_hash) ||
                    ((hinfo->hash == start_hash) &&
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index afc2d4f42d77..580b8a6ca979 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -436,7 +436,7 @@ static void ext3_put_super (struct super_block * sb)
        return;
 }
-static kmem_cache_t *ext3_inode_cachep;
+static struct kmem_cache *ext3_inode_cachep;
 /*
 * Called inside transaction, so use GFP_NOFS
@@ -445,7 +445,7 @@ static struct inode *ext3_alloc_inode(struct super_block *sb)
 {
        struct ext3_inode_info *ei;
-        ei = kmem_cache_alloc(ext3_inode_cachep, SLAB_NOFS);
+        ei = kmem_cache_alloc(ext3_inode_cachep, GFP_NOFS);
        if (!ei)
                return NULL;
 #ifdef CONFIG_EXT3_FS_POSIX_ACL
@@ -462,7 +462,7 @@ static void ext3_destroy_inode(struct inode *inode)
        kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
@@ -1264,6 +1264,12 @@ static void ext3_orphan_cleanup (struct super_block * sb,
                return;
        }
+        if (bdev_read_only(sb->s_bdev)) {
+                printk(KERN_ERR "EXT3-fs: write access "
+                        "unavailable, skipping orphan cleanup.\n");
+                return;
+        }
        if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
                if (es->s_last_orphan)
                        jbd_debug(1, "Errors on filesystem, "
@@ -2387,6 +2393,7 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
        struct ext3_super_block *es = sbi->s_es;
        ext3_fsblk_t overhead;
        int i;
+        u64 fsid;
        if (test_opt (sb, MINIX_DF))
                overhead = 0;
@@ -2433,6 +2440,10 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
        buf->f_files = le32_to_cpu(es->s_inodes_count);
        buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
        buf->f_namelen = EXT3_NAME_LEN;
+        fsid = le64_to_cpup((void *)es->s_uuid) ^
+               le64_to_cpup((void *)es->s_uuid + sizeof(u64));
+        buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
+        buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
        return 0;
 }
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index f86f2482f01d..99857a400f4b 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -459,14 +459,11 @@ static void ext3_xattr_update_super_block(handle_t *handle,
        if (EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_EXT_ATTR))
                return;
-        lock_super(sb);
        if (ext3_journal_get_write_access(handle, EXT3_SB(sb)->s_sbh) == 0) {
-                EXT3_SB(sb)->s_es->s_feature_compat |=
+                EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_EXT_ATTR);
-                        cpu_to_le32(EXT3_FEATURE_COMPAT_EXT_ATTR);
                sb->s_dirt = 1;
                ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
        }
-        unlock_super(sb);
 }
 /*
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
index a6acb96ebeb9..ae6e7e502ac9 100644
--- a/fs/ext4/Makefile
+++ b/fs/ext4/Makefile
@@ -5,7 +5,8 @@
 obj-$(CONFIG_EXT4DEV_FS) += ext4dev.o
 ext4dev-y       := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
-           ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o
+                   ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
+                   ext4_jbd2.o
 ext4dev-$(CONFIG_EXT4DEV_FS_XATTR)      += xattr.o xattr_user.o xattr_trusted.o
 ext4dev-$(CONFIG_EXT4DEV_FS_POSIX_ACL)  += acl.o
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 5d45582f9517..c4dd1103ccf1 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -165,7 +165,7 @@ restart:
        printk("Block Allocation Reservation Windows Map (%s):\n", fn);
        while (n) {
-                rsv = list_entry(n, struct ext4_reserve_window_node, rsv_node);
+                rsv = rb_entry(n, struct ext4_reserve_window_node, rsv_node);
                if (verbose)
                        printk("reservation window 0x%p "
                               "start:  %llu, end:  %llu\n",
@@ -747,7 +747,7 @@ find_next_usable_block(ext4_grpblk_t start, struct buffer_head *bh,
                here = 0;
        p = ((char *)bh->b_data) + (here >> 3);
-        r = memscan(p, 0, (maxblocks - here + 7) >> 3);
+        r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
        next = (r - ((char *)bh->b_data)) << 3;
        if (next < maxblocks && next >= start && ext4_test_allocatable(next, bh))
@@ -966,7 +966,7 @@ static int find_next_reservable_window(
                prev = rsv;
                next = rb_next(&rsv->rsv_node);
-                rsv = list_entry(next,struct ext4_reserve_window_node,rsv_node);
+                rsv = rb_entry(next,struct ext4_reserve_window_node,rsv_node);
                /*
                 * Reached the last reservation, we can just append to the
@@ -1165,7 +1165,7 @@ retry:
         * check if the first free block is within the
         * free space we just reserved
         */
-        if (start_block >= my_rsv->rsv_start && start_block < my_rsv->rsv_end)
+        if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
                return 0;               /* success */
        /*
         * if the first free bit we found is out of the reservable space
@@ -1210,7 +1210,7 @@ static void try_to_extend_reservation(struct ext4_reserve_window_node *my_rsv,
        if (!next)
                my_rsv->rsv_end += size;
        else {
-                next_rsv = list_entry(next, struct ext4_reserve_window_node, rsv_node);
+                next_rsv = rb_entry(next, struct ext4_reserve_window_node, rsv_node);
                if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
                        my_rsv->rsv_end += size;
@@ -1288,7 +1288,7 @@ ext4_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
        }
        /*
         * grp_goal is a group relative block number (if there is a goal)
-         * 0 < grp_goal < EXT4_BLOCKS_PER_GROUP(sb)
+         * 0 <= grp_goal < EXT4_BLOCKS_PER_GROUP(sb)
         * first block is a filesystem wide block number
         * first block is the block number of the first block in this group
         */
@@ -1324,10 +1324,14 @@ ext4_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
                        if (!goal_in_my_reservation(&my_rsv->rsv_window,
                                                        grp_goal, group, sb))
                                grp_goal = -1;
-                } else if (grp_goal > 0 &&
+                } else if (grp_goal >= 0) {
-                          (my_rsv->rsv_end-grp_goal+1) < *count)
+                        int curr = my_rsv->rsv_end -
-                        try_to_extend_reservation(my_rsv, sb,
+                                        (grp_goal + group_first_block) + 1;
-                                        *count-my_rsv->rsv_end + grp_goal - 1);
+                        if (curr < *count)
+                                try_to_extend_reservation(my_rsv, sb,
+                                                        *count - curr);
+                }
                if ((my_rsv->rsv_start > group_last_block) ||
                                (my_rsv->rsv_end < group_first_block)) {
@@ -1525,10 +1529,8 @@ retry_alloc:
                if (group_no >= ngroups)
                        group_no = 0;
                gdp = ext4_get_group_desc(sb, group_no, &gdp_bh);
-                if (!gdp) {
+                if (!gdp)
-                        *errp = -EIO;
+                        goto io_error;
-                        goto out;
-                }
                free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
                /*
                 * skip this group if the number of
@@ -1562,6 +1564,7 @@ retry_alloc:
         */
        if (my_rsv) {
                my_rsv = NULL;
+                windowsz = 0;
                group_no = goal_group;
                goto retry_alloc;
        }
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index f8595787a70e..f2ed3e7fb9f5 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -153,6 +153,9 @@ static int ext4_readdir(struct file * filp,
                        ext4_error (sb, "ext4_readdir",
                                "directory #%lu contains a hole at offset %lu",
                                inode->i_ino, (unsigned long)filp->f_pos);
+                        /* corrupt size?  Maybe no more blocks to read */
+                        if (filp->f_pos > inode->i_blocks << 9)
+                                break;
                        filp->f_pos += sb->s_blocksize - offset;
                        continue;
                }
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
new file mode 100644
index 000000000000..d6afe4e27340
--- /dev/null
+++ b/fs/ext4/ext4_jbd2.c
@@ -0,0 +1,59 @@
+/*
+ * Interface between ext4 and JBD
+ */
+#include <linux/ext4_jbd2.h>
+int __ext4_journal_get_undo_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = jbd2_journal_get_undo_access(handle, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext4_journal_get_write_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = jbd2_journal_get_write_access(handle, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext4_journal_forget(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = jbd2_journal_forget(handle, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext4_journal_revoke(const char *where, handle_t *handle,
+                                ext4_fsblk_t blocknr, struct buffer_head *bh)
+{
+        int err = jbd2_journal_revoke(handle, blocknr, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext4_journal_get_create_access(const char *where,
+                                handle_t *handle, struct buffer_head *bh)
+{
+        int err = jbd2_journal_get_create_access(handle, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+int __ext4_journal_dirty_metadata(const char *where,
+                                handle_t *handle, struct buffer_head *bh)
+{
+        int err = jbd2_journal_dirty_metadata(handle, bh);
+        if (err)
+                ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 2608dce18f3e..dc2724fa7622 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -48,7 +48,7 @@
 * ext_pblock:
 * combine low and high parts of physical block number into ext4_fsblk_t
 */
-static inline ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
+static ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
 {
        ext4_fsblk_t block;
@@ -61,7 +61,7 @@ static inline ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
 * idx_pblock:
 * combine low and high parts of a leaf physical block number into ext4_fsblk_t
 */
-static inline ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
+static ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
 {
        ext4_fsblk_t block;
@@ -75,7 +75,7 @@ static inline ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
 * stores a large physical block number into an extent struct,
 * breaking it into parts
 */
-static inline void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
+static void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
 {
        ex->ee_start = cpu_to_le32((unsigned long) (pb & 0xffffffff));
        ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
@@ -86,7 +86,7 @@ static inline void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb
 * stores a large physical block number into an index struct,
 * breaking it into parts
 */
-static inline void ext4_idx_store_pblock(struct ext4_extent_idx *ix, ext4_fsblk_t pb)
+static void ext4_idx_store_pblock(struct ext4_extent_idx *ix, ext4_fsblk_t pb)
 {
        ix->ei_leaf = cpu_to_le32((unsigned long) (pb & 0xffffffff));
        ix->ei_leaf_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
@@ -186,7 +186,8 @@ static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
                depth = path->p_depth;
                /* try to predict block placement */
-                if ((ex = path[depth].p_ext))
+                ex = path[depth].p_ext;
+                if (ex)
                        return ext_pblock(ex)+(block-le32_to_cpu(ex->ee_block));
                /* it looks like index is empty;
@@ -215,7 +216,7 @@ ext4_ext_new_block(handle_t *handle, struct inode *inode,
        return newblock;
 }
-static inline int ext4_ext_space_block(struct inode *inode)
+static int ext4_ext_space_block(struct inode *inode)
 {
        int size;
@@ -228,7 +229,7 @@ static inline int ext4_ext_space_block(struct inode *inode)
        return size;
 }
-static inline int ext4_ext_space_block_idx(struct inode *inode)
+static int ext4_ext_space_block_idx(struct inode *inode)
 {
        int size;
@@ -241,7 +242,7 @@ static inline int ext4_ext_space_block_idx(struct inode *inode)
        return size;
 }
-static inline int ext4_ext_space_root(struct inode *inode)
+static int ext4_ext_space_root(struct inode *inode)
 {
        int size;
@@ -255,7 +256,7 @@ static inline int ext4_ext_space_root(struct inode *inode)
        return size;
 }
-static inline int ext4_ext_space_root_idx(struct inode *inode)
+static int ext4_ext_space_root_idx(struct inode *inode)
 {
        int size;
@@ -476,13 +477,12 @@ ext4_ext_find_extent(struct inode *inode, int block, struct ext4_ext_path *path)
        /* account possible depth increase */
        if (!path) {
-                path = kmalloc(sizeof(struct ext4_ext_path) * (depth + 2),
+                path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2),
                                GFP_NOFS);
                if (!path)
                        return ERR_PTR(-ENOMEM);
                alloc = 1;
        }
-        memset(path, 0, sizeof(struct ext4_ext_path) * (depth + 1));
        path[0].p_hdr = eh;
        /* walk through the tree */
@@ -543,7 +543,8 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
        struct ext4_extent_idx *ix;
        int len, err;
-        if ((err = ext4_ext_get_access(handle, inode, curp)))
+        err = ext4_ext_get_access(handle, inode, curp);
+        if (err)
                return err;
        BUG_ON(logical == le32_to_cpu(curp->p_idx->ei_block));
@@ -641,10 +642,9 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
         * We need this to handle errors and free blocks
         * upon them.
         */
-        ablocks = kmalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);
+        ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);
        if (!ablocks)
                return -ENOMEM;
-        memset(ablocks, 0, sizeof(ext4_fsblk_t) * depth);
        /* allocate all needed blocks */
        ext_debug("allocate %d blocks for indexes/leaf\n", depth - at);
@@ -665,7 +665,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
        }
        lock_buffer(bh);
-        if ((err = ext4_journal_get_create_access(handle, bh)))
+        err = ext4_journal_get_create_access(handle, bh);
+        if (err)
                goto cleanup;
        neh = ext_block_hdr(bh);
@@ -702,18 +703,21 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
        set_buffer_uptodate(bh);
        unlock_buffer(bh);
-        if ((err = ext4_journal_dirty_metadata(handle, bh)))
+        err = ext4_journal_dirty_metadata(handle, bh);
+        if (err)
                goto cleanup;
        brelse(bh);
        bh = NULL;
        /* correct old leaf */
        if (m) {
-                if ((err = ext4_ext_get_access(handle, inode, path + depth)))
+                err = ext4_ext_get_access(handle, inode, path + depth);
+                if (err)
                        goto cleanup;
                path[depth].p_hdr->eh_entries =
                     cpu_to_le16(le16_to_cpu(path[depth].p_hdr->eh_entries)-m);
-                if ((err = ext4_ext_dirty(handle, inode, path + depth)))
+                err = ext4_ext_dirty(handle, inode, path + depth);
+                if (err)
                        goto cleanup;
        }
@@ -736,7 +740,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                }
                lock_buffer(bh);
-                if ((err = ext4_journal_get_create_access(handle, bh)))
+                err = ext4_journal_get_create_access(handle, bh);
+                if (err)
                        goto cleanup;
                neh = ext_block_hdr(bh);
@@ -780,7 +785,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                set_buffer_uptodate(bh);
                unlock_buffer(bh);
-                if ((err = ext4_journal_dirty_metadata(handle, bh)))
+                err = ext4_journal_dirty_metadata(handle, bh);
+                if (err)
                        goto cleanup;
                brelse(bh);
                bh = NULL;
@@ -800,9 +806,6 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
        }
        /* insert new index */
-        if (err)
-                goto cleanup;
        err = ext4_ext_insert_index(handle, inode, path + at,
                                    le32_to_cpu(border), newblock);
@@ -857,7 +860,8 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
        }
        lock_buffer(bh);
-        if ((err = ext4_journal_get_create_access(handle, bh))) {
+        err = ext4_journal_get_create_access(handle, bh);
+        if (err) {
                unlock_buffer(bh);
                goto out;
        }
@@ -877,11 +881,13 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
        set_buffer_uptodate(bh);
        unlock_buffer(bh);
-        if ((err = ext4_journal_dirty_metadata(handle, bh)))
+        err = ext4_journal_dirty_metadata(handle, bh);
+        if (err)
                goto out;
        /* create index in new top-level index: num,max,pointer */
-        if ((err = ext4_ext_get_access(handle, inode, curp)))
+        err = ext4_ext_get_access(handle, inode, curp);
+        if (err)
                goto out;
        curp->p_hdr->eh_magic = EXT4_EXT_MAGIC;
@@ -1073,27 +1079,31 @@ int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
         */
        k = depth - 1;
        border = path[depth].p_ext->ee_block;
-        if ((err = ext4_ext_get_access(handle, inode, path + k)))
+        err = ext4_ext_get_access(handle, inode, path + k);
+        if (err)
                return err;
        path[k].p_idx->ei_block = border;
-        if ((err = ext4_ext_dirty(handle, inode, path + k)))
+        err = ext4_ext_dirty(handle, inode, path + k);
+        if (err)
                return err;
        while (k--) {
                /* change all left-side indexes */
                if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
                        break;
-                if ((err = ext4_ext_get_access(handle, inode, path + k)))
+                err = ext4_ext_get_access(handle, inode, path + k);
+                if (err)
                        break;
                path[k].p_idx->ei_block = border;
-                if ((err = ext4_ext_dirty(handle, inode, path + k)))
+                err = ext4_ext_dirty(handle, inode, path + k);
+                if (err)
                        break;
        }
        return err;
 }
-static int inline
+static int
 ext4_can_extents_be_merged(struct inode *inode, struct ext4_extent *ex1,
                                struct ext4_extent *ex2)
 {
@@ -1145,7 +1155,8 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
                                le16_to_cpu(newext->ee_len),
                                le32_to_cpu(ex->ee_block),
                                le16_to_cpu(ex->ee_len), ext_pblock(ex));
-                if ((err = ext4_ext_get_access(handle, inode, path + depth)))
+                err = ext4_ext_get_access(handle, inode, path + depth);
+                if (err)
                        return err;
                ex->ee_len = cpu_to_le16(le16_to_cpu(ex->ee_len)
                                         + le16_to_cpu(newext->ee_len));
@@ -1195,7 +1206,8 @@ repeat:
 has_space:
        nearex = path[depth].p_ext;
-        if ((err = ext4_ext_get_access(handle, inode, path + depth)))
+        err = ext4_ext_get_access(handle, inode, path + depth);
+        if (err)
                goto cleanup;
        if (!nearex) {
@@ -1383,7 +1395,7 @@ int ext4_ext_walk_space(struct inode *inode, unsigned long block,
        return err;
 }
-static inline void
+static void
 ext4_ext_put_in_cache(struct inode *inode, __u32 block,
                        __u32 len, __u32 start, int type)
 {
@@ -1401,7 +1413,7 @@ ext4_ext_put_in_cache(struct inode *inode, __u32 block,
 * calculate boundaries of the gap that the requested block fits into
 * and cache this gap
 */
-static inline void
+static void
 ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                unsigned long block)
 {
@@ -1442,7 +1454,7 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
        ext4_ext_put_in_cache(inode, lblock, len, 0, EXT4_EXT_CACHE_GAP);
 }
-static inline int
+static int
 ext4_ext_in_cache(struct inode *inode, unsigned long block,
                        struct ext4_extent *ex)
 {
@@ -1489,10 +1501,12 @@ int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
        path--;
        leaf = idx_pblock(path->p_idx);
        BUG_ON(path->p_hdr->eh_entries == 0);
-        if ((err = ext4_ext_get_access(handle, inode, path)))
+        err = ext4_ext_get_access(handle, inode, path);
+        if (err)
                return err;
        path->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path->p_hdr->eh_entries)-1);
-        if ((err = ext4_ext_dirty(handle, inode, path)))
+        err = ext4_ext_dirty(handle, inode, path);
+        if (err)
                return err;
        ext_debug("index is empty, remove it, free block %llu\n", leaf);
        bh = sb_find_get_block(inode->i_sb, leaf);
@@ -1509,7 +1523,7 @@ int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
 * the caller should calculate credits under truncate_mutex and
 * pass the actual path.
 */
-int inline ext4_ext_calc_credits_for_insert(struct inode *inode,
+int ext4_ext_calc_credits_for_insert(struct inode *inode,
                                                struct ext4_ext_path *path)
 {
        int depth, needed;
@@ -1534,16 +1548,17 @@ int inline ext4_ext_calc_credits_for_insert(struct inode *inode,
        /*
         * tree can be full, so it would need to grow in depth:
-         * allocation + old root + new root
+         * we need one credit to modify old root, credits for
+         * new root will be added in split accounting
         */
-        needed += 2 + 1 + 1;
+        needed += 1;
        /*
         * Index split can happen, we would need:
         *    allocate intermediate indexes (bitmap + group)
         *  + change two blocks at each level, but root (already included)
         */
-        needed = (depth * 2) + (depth * 2);
+        needed += (depth * 2) + (depth * 2);
        /* any allocation modifies superblock */
        needed += 1;
@@ -1718,7 +1733,7 @@ out:
 * ext4_ext_more_to_rm:
 * returns 1 if current index has to be freed (even partial)
 */
-static int inline
+static int
 ext4_ext_more_to_rm(struct ext4_ext_path *path)
 {
        BUG_ON(path->p_idx == NULL);
@@ -1756,12 +1771,11 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
         * We start scanning from right side, freeing all the blocks
         * after i_size and walking into the tree depth-wise.
         */
-        path = kmalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_KERNEL);
+        path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_KERNEL);
        if (path == NULL) {
                ext4_journal_stop(handle);
                return -ENOMEM;
        }
-        memset(path, 0, sizeof(struct ext4_ext_path) * (depth + 1));
        path[0].p_hdr = ext_inode_hdr(inode);
        if (ext4_ext_check_header(__FUNCTION__, inode, path[0].p_hdr)) {
                err = -EIO;
@@ -1932,7 +1946,8 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
        mutex_lock(&EXT4_I(inode)->truncate_mutex);
        /* check in cache */
-        if ((goal = ext4_ext_in_cache(inode, iblock, &newex))) {
+        goal = ext4_ext_in_cache(inode, iblock, &newex);
+        if (goal) {
                if (goal == EXT4_EXT_CACHE_GAP) {
                        if (!create) {
                                /* block isn't allocated yet and
@@ -1971,7 +1986,8 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
         */
        BUG_ON(path[depth].p_ext == NULL && depth != 0);
-        if ((ex = path[depth].p_ext)) {
+        ex = path[depth].p_ext;
+        if (ex) {
                unsigned long ee_block = le32_to_cpu(ex->ee_block);
                ext4_fsblk_t ee_start = ext_pblock(ex);
                unsigned short ee_len  = le16_to_cpu(ex->ee_len);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 0a60ec5a16db..1d85d4ec9598 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1147,37 +1147,102 @@ static int do_journal_get_write_access(handle_t *handle,
        return ext4_journal_get_write_access(handle, bh);
 }
+/*
+ * The idea of this helper function is following:
+ * if prepare_write has allocated some blocks, but not all of them, the
+ * transaction must include the content of the newly allocated blocks.
+ * This content is expected to be set to zeroes by block_prepare_write().
+ * 2006/10/14  SAW
+ */
+static int ext4_prepare_failure(struct file *file, struct page *page,
+                                unsigned from, unsigned to)
+{
+        struct address_space *mapping;
+        struct buffer_head *bh, *head, *next;
+        unsigned block_start, block_end;
+        unsigned blocksize;
+        int ret;
+        handle_t *handle = ext4_journal_current_handle();
+        mapping = page->mapping;
+        if (ext4_should_writeback_data(mapping->host)) {
+                /* optimization: no constraints about data */
+skip:
+                return ext4_journal_stop(handle);
+        }
+        head = page_buffers(page);
+        blocksize = head->b_size;
+        for (   bh = head, block_start = 0;
+                bh != head || !block_start;
+                block_start = block_end, bh = next)
+        {
+                next = bh->b_this_page;
+                block_end = block_start + blocksize;
+                if (block_end <= from)
+                        continue;
+                if (block_start >= to) {
+                        block_start = to;
+                        break;
+                }
+                if (!buffer_mapped(bh))
+                /* prepare_write failed on this bh */
+                        break;
+                if (ext4_should_journal_data(mapping->host)) {
+                        ret = do_journal_get_write_access(handle, bh);
+                        if (ret) {
+                                ext4_journal_stop(handle);
+                                return ret;
+                        }
+                }
+        /*
+         * block_start here becomes the first block where the current iteration
+         * of prepare_write failed.
+         */
+        }
+        if (block_start <= from)
+                goto skip;
+        /* commit allocated and zeroed buffers */
+        return mapping->a_ops->commit_write(file, page, from, block_start);
+}
 static int ext4_prepare_write(struct file *file, struct page *page,
                              unsigned from, unsigned to)
 {
        struct inode *inode = page->mapping->host;
-        int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
+        int ret, ret2;
+        int needed_blocks = ext4_writepage_trans_blocks(inode);
        handle_t *handle;
        int retries = 0;
 retry:
        handle = ext4_journal_start(inode, needed_blocks);
-        if (IS_ERR(handle)) {
+        if (IS_ERR(handle))
-                ret = PTR_ERR(handle);
+                return PTR_ERR(handle);
-                goto out;
-        }
        if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
                ret = nobh_prepare_write(page, from, to, ext4_get_block);
        else
                ret = block_prepare_write(page, from, to, ext4_get_block);
        if (ret)
-                goto prepare_write_failed;
+                goto failure;
        if (ext4_should_journal_data(inode)) {
                ret = walk_page_buffers(handle, page_buffers(page),
                                from, to, NULL, do_journal_get_write_access);
+                if (ret)
+                        /* fatal error, just put the handle and return */
+                        journal_stop(handle);
        }
-prepare_write_failed:
+        return ret;
-        if (ret)
-                ext4_journal_stop(handle);
+failure:
+        ret2 = ext4_prepare_failure(file, page, from, to);
+        if (ret2 < 0)
+                return ret2;
        if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
                goto retry;
-out:
+        /* retry number exceeded, or other error like -EDQUOT */
        return ret;
 }
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 8b1bd03d20f5..859990eac504 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -552,6 +552,15 @@ static int htree_dirblock_to_tree(struct file *dir_file,
                                           dir->i_sb->s_blocksize -
                                           EXT4_DIR_REC_LEN(0));
        for (; de < top; de = ext4_next_entry(de)) {
+                if (!ext4_check_dir_entry("htree_dirblock_to_tree", dir, de, bh,
+                                        (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
+                                                +((char *)de - bh->b_data))) {
+                        /* On error, skip the f_pos to the next block. */
+                        dir_file->f_pos = (dir_file->f_pos |
+                                        (dir->i_sb->s_blocksize - 1)) + 1;
+                        brelse (bh);
+                        return count;
+                }
                ext4fs_dirhash(de->name, de->name_len, hinfo);
                if ((hinfo->hash < start_hash) ||
                    ((hinfo->hash == start_hash) &&
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index b4b022aa2bc2..486a641ca71b 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -486,7 +486,7 @@ static void ext4_put_super (struct super_block * sb)
        return;
 }
-static kmem_cache_t *ext4_inode_cachep;
+static struct kmem_cache *ext4_inode_cachep;
 /*
 * Called inside transaction, so use GFP_NOFS
@@ -495,7 +495,7 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
 {
        struct ext4_inode_info *ei;
-        ei = kmem_cache_alloc(ext4_inode_cachep, SLAB_NOFS);
+        ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
        if (!ei)
                return NULL;
 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
@@ -513,7 +513,7 @@ static void ext4_destroy_inode(struct inode *inode)
        kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
@@ -1321,6 +1321,12 @@ static void ext4_orphan_cleanup (struct super_block * sb,
                return;
        }
+        if (bdev_read_only(sb->s_bdev)) {
+                printk(KERN_ERR "EXT4-fs: write access "
+                        "unavailable, skipping orphan cleanup.\n");
+                return;
+        }
        if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
                if (es->s_last_orphan)
                        jbd_debug(1, "Errors on filesystem, "
@@ -2460,6 +2466,7 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
        struct ext4_super_block *es = sbi->s_es;
        ext4_fsblk_t overhead;
        int i;
+        u64 fsid;
        if (test_opt (sb, MINIX_DF))
                overhead = 0;
@@ -2506,6 +2513,10 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
        buf->f_files = le32_to_cpu(es->s_inodes_count);
        buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
        buf->f_namelen = EXT4_NAME_LEN;
+        fsid = le64_to_cpup((void *)es->s_uuid) ^
+               le64_to_cpup((void *)es->s_uuid + sizeof(u64));
+        buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
+        buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
        return 0;
 }
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 63233cd946a7..dc969c357aa1 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -459,14 +459,11 @@ static void ext4_xattr_update_super_block(handle_t *handle,
        if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR))
                return;
-        lock_super(sb);
        if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
-                EXT4_SB(sb)->s_es->s_feature_compat |=
+                EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR);
-                        cpu_to_le32(EXT4_FEATURE_COMPAT_EXT_ATTR);
                sb->s_dirt = 1;
                ext4_journal_dirty_metadata(handle, EXT4_SB(sb)->s_sbh);
        }
-        unlock_super(sb);
 }
 /*
diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index 82cc4f59e3ba..05c2941c74f2 100644
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -34,9 +34,9 @@ static inline int fat_max_cache(struct inode *inode)
        return FAT_MAX_CACHE;
 }
-static kmem_cache_t *fat_cache_cachep;
+static struct kmem_cache *fat_cache_cachep;
-static void init_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct fat_cache *cache = (struct fat_cache *)foo;
@@ -63,7 +63,7 @@ void fat_cache_destroy(void)
 static inline struct fat_cache *fat_cache_alloc(struct inode *inode)
 {
-        return kmem_cache_alloc(fat_cache_cachep, SLAB_KERNEL);
+        return kmem_cache_alloc(fat_cache_cachep, GFP_KERNEL);
 }
 static inline void fat_cache_free(struct fat_cache *cache)
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 78945b53b0f8..a9e4688582a2 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -477,12 +477,12 @@ static void fat_put_super(struct super_block *sb)
        kfree(sbi);
 }
-static kmem_cache_t *fat_inode_cachep;
+static struct kmem_cache *fat_inode_cachep;
 static struct inode *fat_alloc_inode(struct super_block *sb)
 {
        struct msdos_inode_info *ei;
-        ei = kmem_cache_alloc(fat_inode_cachep, SLAB_KERNEL);
+        ei = kmem_cache_alloc(fat_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -493,7 +493,7 @@ static void fat_destroy_inode(struct inode *inode)
        kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
diff --git a/fs/fcntl.c b/fs/fcntl.c
index e4f26165f12a..4740d35e52cd 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -553,7 +553,7 @@ int send_sigurg(struct fown_struct *fown)
 }
 static DEFINE_RWLOCK(fasync_lock);
-static kmem_cache_t *fasync_cache __read_mostly;
+static struct kmem_cache *fasync_cache __read_mostly;
 /*
 * fasync_helper() is used by some character device drivers (mainly mice)
@@ -567,7 +567,7 @@ int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fap
        int result = 0;
        if (on) {
-                new = kmem_cache_alloc(fasync_cache, SLAB_KERNEL);
+                new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
                if (!new)
                        return -ENOMEM;
        }
diff --git a/fs/file.c b/fs/file.c
index 8e81775c5dc8..51aef675470f 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -21,7 +21,6 @@
 struct fdtable_defer {
        spinlock_t lock;
        struct work_struct wq;
-        struct timer_list timer;
        struct fdtable *next;
 };
@@ -75,24 +74,10 @@ static void __free_fdtable(struct fdtable *fdt)
        kfree(fdt);
 }
-static void fdtable_timer(unsigned long data)
+static void free_fdtable_work(struct work_struct *work)
-{
-        struct fdtable_defer *fddef = (struct fdtable_defer *)data;
-        spin_lock(&fddef->lock);
-        /*
-         * If someone already emptied the queue return.
-         */
-        if (!fddef->next)
-                goto out;
-        if (!schedule_work(&fddef->wq))
-                mod_timer(&fddef->timer, 5);
-out:
-        spin_unlock(&fddef->lock);
-}
-static void free_fdtable_work(struct fdtable_defer *f)
 {
+        struct fdtable_defer *f =
+                container_of(work, struct fdtable_defer, wq);
        struct fdtable *fdt;
        spin_lock_bh(&f->lock);
@@ -142,13 +127,8 @@ static void free_fdtable_rcu(struct rcu_head *rcu)
                spin_lock(&fddef->lock);
                fdt->next = fddef->next;
                fddef->next = fdt;
-                /*
+                /* vmallocs are handled from the workqueue context */
-                 * vmallocs are handled from the workqueue context.
+                schedule_work(&fddef->wq);
-                 * If the per-cpu workqueue is running, then we
-                 * defer work scheduling through a timer.
-                 */
-                if (!schedule_work(&fddef->wq))
-                        mod_timer(&fddef->timer, 5);
                spin_unlock(&fddef->lock);
                put_cpu_var(fdtable_defer_list);
        }
@@ -351,10 +331,7 @@ static void __devinit fdtable_defer_list_init(int cpu)
 {
        struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu);
        spin_lock_init(&fddef->lock);
-        INIT_WORK(&fddef->wq, (void (*)(void *))free_fdtable_work, fddef);
+        INIT_WORK(&fddef->wq, free_fdtable_work);
-        init_timer(&fddef->timer);
-        fddef->timer.data = (unsigned long)fddef;
-        fddef->timer.function = fdtable_timer;
        fddef->next = NULL;
 }
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index 4786d51ad3bd..0b7ae897cb78 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -46,7 +46,7 @@ extern const struct address_space_operations vxfs_immed_aops;
 extern struct inode_operations vxfs_immed_symlink_iops;
-kmem_cache_t            *vxfs_inode_cachep;
+struct kmem_cache               *vxfs_inode_cachep;
 #ifdef DIAGNOSTIC
@@ -103,7 +103,7 @@ vxfs_blkiget(struct super_block *sbp, u_long extent, ino_t ino)
                struct vxfs_inode_info  *vip;
                struct vxfs_dinode      *dip;
-                if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, SLAB_KERNEL)))
+                if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
                        goto fail;
                dip = (struct vxfs_dinode *)(bp->b_data + offset);
                memcpy(vip, dip, sizeof(*vip));
@@ -145,7 +145,7 @@ __vxfs_iget(ino_t ino, struct inode *ilistp)
                struct vxfs_dinode      *dip;
                caddr_t                 kaddr = (char *)page_address(pp);
-                if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, SLAB_KERNEL)))
+                if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
                        goto fail;
                dip = (struct vxfs_dinode *)(kaddr + offset);
                memcpy(vip, dip, sizeof(*vip));
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 66571eafbb1e..357764d85ff1 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -19,7 +19,7 @@
 MODULE_ALIAS_MISCDEV(FUSE_MINOR);
-static kmem_cache_t *fuse_req_cachep;
+static struct kmem_cache *fuse_req_cachep;
 static struct fuse_conn *fuse_get_conn(struct file *file)
 {
@@ -41,7 +41,7 @@ static void fuse_request_init(struct fuse_req *req)
 struct fuse_req *fuse_request_alloc(void)
 {
-        struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
+        struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);
        if (req)
                fuse_request_init(req);
        return req;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index c71a6c092ad9..1cabdb229adb 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -141,9 +141,6 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                struct fuse_req *forget_req;
                struct dentry *parent;
-                /* Doesn't hurt to "reset" the validity timeout */
-                fuse_invalidate_entry_cache(entry);
                /* For negative dentries, always do a fresh lookup */
                if (!inode)
                        return 0;
@@ -1027,6 +1024,8 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
        if (attr->ia_valid & ATTR_SIZE) {
                unsigned long limit;
                is_truncate = 1;
+                if (IS_SWAPFILE(inode))
+                        return -ETXTBSY;
                limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
                if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
                        send_sig(SIGXFSZ, current, 0);
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 763a50daf1c0..128f79c40803 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -754,6 +754,42 @@ static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
        return err;
 }
+static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
+{
+        struct inode *inode = mapping->host;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        struct fuse_req *req;
+        struct fuse_bmap_in inarg;
+        struct fuse_bmap_out outarg;
+        int err;
+        if (!inode->i_sb->s_bdev || fc->no_bmap)
+                return 0;
+        req = fuse_get_req(fc);
+        if (IS_ERR(req))
+                return 0;
+        memset(&inarg, 0, sizeof(inarg));
+        inarg.block = block;
+        inarg.blocksize = inode->i_sb->s_blocksize;
+        req->in.h.opcode = FUSE_BMAP;
+        req->in.h.nodeid = get_node_id(inode);
+        req->in.numargs = 1;
+        req->in.args[0].size = sizeof(inarg);
+        req->in.args[0].value = &inarg;
+        req->out.numargs = 1;
+        req->out.args[0].size = sizeof(outarg);
+        req->out.args[0].value = &outarg;
+        request_send(fc, req);
+        err = req->out.h.error;
+        fuse_put_request(fc, req);
+        if (err == -ENOSYS)
+                fc->no_bmap = 1;
+        return err ? 0 : outarg.block;
+}
 static const struct file_operations fuse_file_operations = {
        .llseek         = generic_file_llseek,
        .read           = do_sync_read,
@@ -787,6 +823,7 @@ static const struct address_space_operations fuse_file_aops  = {
        .commit_write   = fuse_commit_write,
        .readpages      = fuse_readpages,
        .set_page_dirty = fuse_set_page_dirty,
+        .bmap           = fuse_bmap,
 };
 void fuse_init_file_inode(struct inode *inode)
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 91edb8932d90..b98b20de7405 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -298,6 +298,9 @@ struct fuse_conn {
            reply, before any other request, and never cleared */
        unsigned conn_error : 1;
+        /** Connection successful.  Only set in INIT */
+        unsigned conn_init : 1;
        /** Do readpages asynchronously?  Only set in INIT */
        unsigned async_read : 1;
@@ -339,6 +342,9 @@ struct fuse_conn {
        /** Is interrupt not implemented by fs? */
        unsigned no_interrupt : 1;
+        /** Is bmap not implemented by fs? */
+        unsigned no_bmap : 1;
        /** The number of requests waiting for completion */
        atomic_t num_waiting;
@@ -365,6 +371,9 @@ struct fuse_conn {
        /** Key for lock owner ID scrambling */
        u32 scramble_key[4];
+        /** Reserved request for the DESTROY message */
+        struct fuse_req *destroy_req;
 };
 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index fc4203570370..12450d2b320e 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -22,7 +22,7 @@ MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
 MODULE_DESCRIPTION("Filesystem in Userspace");
 MODULE_LICENSE("GPL");
-static kmem_cache_t *fuse_inode_cachep;
+static struct kmem_cache *fuse_inode_cachep;
 struct list_head fuse_conn_list;
 DEFINE_MUTEX(fuse_mutex);
@@ -39,6 +39,7 @@ struct fuse_mount_data {
        unsigned group_id_present : 1;
        unsigned flags;
        unsigned max_read;
+        unsigned blksize;
 };
 static struct inode *fuse_alloc_inode(struct super_block *sb)
@@ -46,7 +47,7 @@ static struct inode *fuse_alloc_inode(struct super_block *sb)
        struct inode *inode;
        struct fuse_inode *fi;
-        inode = kmem_cache_alloc(fuse_inode_cachep, SLAB_KERNEL);
+        inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
        if (!inode)
                return NULL;
@@ -205,10 +206,23 @@ static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
                fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
 }
+static void fuse_send_destroy(struct fuse_conn *fc)
+{
+        struct fuse_req *req = fc->destroy_req;
+        if (req && fc->conn_init) {
+                fc->destroy_req = NULL;
+                req->in.h.opcode = FUSE_DESTROY;
+                req->force = 1;
+                request_send(fc, req);
+                fuse_put_request(fc, req);
+        }
+}
 static void fuse_put_super(struct super_block *sb)
 {
        struct fuse_conn *fc = get_fuse_conn_super(sb);
+        fuse_send_destroy(fc);
        spin_lock(&fc->lock);
        fc->connected = 0;
        fc->blocked = 0;
@@ -274,6 +288,7 @@ enum {
        OPT_DEFAULT_PERMISSIONS,
        OPT_ALLOW_OTHER,
        OPT_MAX_READ,
+        OPT_BLKSIZE,
        OPT_ERR
 };
@@ -285,14 +300,16 @@ static match_table_t tokens = {
        {OPT_DEFAULT_PERMISSIONS,       "default_permissions"},
        {OPT_ALLOW_OTHER,               "allow_other"},
        {OPT_MAX_READ,                  "max_read=%u"},
+        {OPT_BLKSIZE,                   "blksize=%u"},
        {OPT_ERR,                       NULL}
 };
-static int parse_fuse_opt(char *opt, struct fuse_mount_data *d)
+static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
 {
        char *p;
        memset(d, 0, sizeof(struct fuse_mount_data));
        d->max_read = ~0;
+        d->blksize = 512;
        while ((p = strsep(&opt, ",")) != NULL) {
                int token;
@@ -345,6 +362,12 @@ static int parse_fuse_opt(char *opt, struct fuse_mount_data *d)
                        d->max_read = value;
                        break;
+                case OPT_BLKSIZE:
+                        if (!is_bdev || match_int(&args[0], &value))
+                                return 0;
+                        d->blksize = value;
+                        break;
                default:
                        return 0;
                }
@@ -400,6 +423,8 @@ static struct fuse_conn *new_conn(void)
 void fuse_conn_put(struct fuse_conn *fc)
 {
        if (atomic_dec_and_test(&fc->count)) {
+                if (fc->destroy_req)
+                        fuse_request_free(fc->destroy_req);
                mutex_destroy(&fc->inst_mutex);
                kfree(fc);
        }
@@ -456,6 +481,7 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
                fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
                fc->minor = arg->minor;
                fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
+                fc->conn_init = 1;
        }
        fuse_put_request(fc, req);
        fc->blocked = 0;
@@ -500,15 +526,23 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
        struct dentry *root_dentry;
        struct fuse_req *init_req;
        int err;
+        int is_bdev = sb->s_bdev != NULL;
        if (sb->s_flags & MS_MANDLOCK)
                return -EINVAL;
-        if (!parse_fuse_opt((char *) data, &d))
+        if (!parse_fuse_opt((char *) data, &d, is_bdev))
                return -EINVAL;
-        sb->s_blocksize = PAGE_CACHE_SIZE;
+        if (is_bdev) {
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+#ifdef CONFIG_BLOCK
+                if (!sb_set_blocksize(sb, d.blksize))
+                        return -EINVAL;
+#endif
+        } else {
+                sb->s_blocksize = PAGE_CACHE_SIZE;
+                sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        }
        sb->s_magic = FUSE_SUPER_MAGIC;
        sb->s_op = &fuse_super_operations;
        sb->s_maxbytes = MAX_LFS_FILESIZE;
@@ -547,6 +581,12 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
        if (!init_req)
                goto err_put_root;
+        if (is_bdev) {
+                fc->destroy_req = fuse_request_alloc();
+                if (!fc->destroy_req)
+                        goto err_put_root;
+        }
        mutex_lock(&fuse_mutex);
        err = -EINVAL;
        if (file->private_data)
@@ -598,10 +638,47 @@ static struct file_system_type fuse_fs_type = {
        .kill_sb        = kill_anon_super,
 };
+#ifdef CONFIG_BLOCK
+static int fuse_get_sb_blk(struct file_system_type *fs_type,
+                           int flags, const char *dev_name,
+                           void *raw_data, struct vfsmount *mnt)
+{
+        return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
+                           mnt);
+}
+static struct file_system_type fuseblk_fs_type = {
+        .owner          = THIS_MODULE,
+        .name           = "fuseblk",
+        .get_sb         = fuse_get_sb_blk,
+        .kill_sb        = kill_block_super,
+        .fs_flags       = FS_REQUIRES_DEV,
+};
+static inline int register_fuseblk(void)
+{
+        return register_filesystem(&fuseblk_fs_type);
+}
+static inline void unregister_fuseblk(void)
+{
+        unregister_filesystem(&fuseblk_fs_type);
+}
+#else
+static inline int register_fuseblk(void)
+{
+        return 0;
+}
+static inline void unregister_fuseblk(void)
+{
+}
+#endif
 static decl_subsys(fuse, NULL, NULL);
 static decl_subsys(connections, NULL, NULL);
-static void fuse_inode_init_once(void *foo, kmem_cache_t *cachep,
+static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
                                 unsigned long flags)
 {
        struct inode * inode = foo;
@@ -617,24 +694,34 @@ static int __init fuse_fs_init(void)
        err = register_filesystem(&fuse_fs_type);
        if (err)
-                printk("fuse: failed to register filesystem\n");
+                goto out;
-        else {
-                fuse_inode_cachep = kmem_cache_create("fuse_inode",
-                                                      sizeof(struct fuse_inode),
-                                                      0, SLAB_HWCACHE_ALIGN,
-                                                      fuse_inode_init_once, NULL);
-                if (!fuse_inode_cachep) {
-                        unregister_filesystem(&fuse_fs_type);
-                        err = -ENOMEM;
-                }
-        }
+        err = register_fuseblk();
+        if (err)
+                goto out_unreg;
+        fuse_inode_cachep = kmem_cache_create("fuse_inode",
+                                              sizeof(struct fuse_inode),
+                                              0, SLAB_HWCACHE_ALIGN,
+                                              fuse_inode_init_once, NULL);
+        err = -ENOMEM;
+        if (!fuse_inode_cachep)
+                goto out_unreg2;
+        return 0;
+ out_unreg2:
+        unregister_fuseblk();
+ out_unreg:
+        unregister_filesystem(&fuse_fs_type);
+ out:
        return err;
 }
 static void fuse_fs_cleanup(void)
 {
        unregister_filesystem(&fuse_fs_type);
+        unregister_fuseblk();
        kmem_cache_destroy(fuse_inode_cachep);
 }
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index f130f9894bda..438146904b58 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -35,7 +35,7 @@
 struct greedy {
        struct gfs2_holder gr_gh;
-        struct work_struct gr_work;
+        struct delayed_work gr_work;
 };
 struct gfs2_gl_hash_bucket {
@@ -1350,9 +1350,9 @@ static void gfs2_glock_prefetch(struct gfs2_glock *gl, unsigned int state,
        glops->go_xmote_th(gl, state, flags);
 }
-static void greedy_work(void *data)
+static void greedy_work(struct work_struct *work)
 {
-        struct greedy *gr = data;
+        struct greedy *gr = container_of(work, struct greedy, gr_work.work);
        struct gfs2_holder *gh = &gr->gr_gh;
        struct gfs2_glock *gl = gh->gh_gl;
        const struct gfs2_glock_operations *glops = gl->gl_ops;
@@ -1404,7 +1404,7 @@ int gfs2_glock_be_greedy(struct gfs2_glock *gl, unsigned int time)
        gfs2_holder_init(gl, 0, 0, gh);
        set_bit(HIF_GREEDY, &gh->gh_iflags);
-        INIT_WORK(&gr->gr_work, greedy_work, gr);
+        INIT_DELAYED_WORK(&gr->gr_work, greedy_work);
        set_bit(GLF_SKIP_WAITERS2, &gl->gl_flags);
        schedule_delayed_work(&gr->gr_work, time);
diff --git a/fs/gfs2/locking/dlm/plock.c b/fs/gfs2/locking/dlm/plock.c
index 7365aec9511b..3799f19b282f 100644
--- a/fs/gfs2/locking/dlm/plock.c
+++ b/fs/gfs2/locking/dlm/plock.c
@@ -8,6 +8,7 @@
 #include <linux/miscdevice.h>
 #include <linux/lock_dlm_plock.h>
+#include <linux/poll.h>
 #include "lock_dlm.h"
diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index 9889c1eacec1..7c1a9e22a526 100644
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -25,7 +25,7 @@
 #include "util.h"
 #include "glock.h"
-static void gfs2_init_inode_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void gfs2_init_inode_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct gfs2_inode *ip = foo;
        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
@@ -37,7 +37,7 @@ static void gfs2_init_inode_once(void *foo, kmem_cache_t *cachep, unsigned long
        }
 }
-static void gfs2_init_glock_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void gfs2_init_glock_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct gfs2_glock *gl = foo;
        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
index 196c604faadc..e5707a9f78c2 100644
--- a/fs/gfs2/util.c
+++ b/fs/gfs2/util.c
@@ -23,9 +23,9 @@
 #include "lm.h"
 #include "util.h"
-kmem_cache_t *gfs2_glock_cachep __read_mostly;
+struct kmem_cache *gfs2_glock_cachep __read_mostly;
-kmem_cache_t *gfs2_inode_cachep __read_mostly;
+struct kmem_cache *gfs2_inode_cachep __read_mostly;
-kmem_cache_t *gfs2_bufdata_cachep __read_mostly;
+struct kmem_cache *gfs2_bufdata_cachep __read_mostly;
 void gfs2_assert_i(struct gfs2_sbd *sdp)
 {
diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h
index ca8667c3ed07..28938a46cf47 100644
--- a/fs/gfs2/util.h
+++ b/fs/gfs2/util.h
@@ -144,9 +144,9 @@ int gfs2_io_error_bh_i(struct gfs2_sbd *sdp, struct buffer_head *bh,
 gfs2_io_error_bh_i((sdp), (bh), __FUNCTION__, __FILE__, __LINE__);
-extern kmem_cache_t *gfs2_glock_cachep;
+extern struct kmem_cache *gfs2_glock_cachep;
-extern kmem_cache_t *gfs2_inode_cachep;
+extern struct kmem_cache *gfs2_inode_cachep;
-extern kmem_cache_t *gfs2_bufdata_cachep;
+extern struct kmem_cache *gfs2_bufdata_cachep;
 static inline unsigned int gfs2_tune_get_i(struct gfs2_tune *gt,
                                           unsigned int *p)
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 85b17b3fa4a0..a36987966004 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -24,7 +24,7 @@
 #include "hfs_fs.h"
 #include "btree.h"
-static kmem_cache_t *hfs_inode_cachep;
+static struct kmem_cache *hfs_inode_cachep;
 MODULE_LICENSE("GPL");
@@ -145,7 +145,7 @@ static struct inode *hfs_alloc_inode(struct super_block *sb)
 {
        struct hfs_inode_info *i;
-        i = kmem_cache_alloc(hfs_inode_cachep, SLAB_KERNEL);
+        i = kmem_cache_alloc(hfs_inode_cachep, GFP_KERNEL);
        return i ? &i->vfs_inode : NULL;
 }
@@ -430,7 +430,7 @@ static struct file_system_type hfs_fs_type = {
        .fs_flags       = FS_REQUIRES_DEV,
 };
-static void hfs_init_once(void *p, kmem_cache_t *cachep, unsigned long flags)
+static void hfs_init_once(void *p, struct kmem_cache *cachep, unsigned long flags)
 {
        struct hfs_inode_info *i = p;
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index 194eede52fa4..0f513c6bf843 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -434,13 +434,13 @@ MODULE_AUTHOR("Brad Boyer");
 MODULE_DESCRIPTION("Extended Macintosh Filesystem");
 MODULE_LICENSE("GPL");
-static kmem_cache_t *hfsplus_inode_cachep;
+static struct kmem_cache *hfsplus_inode_cachep;
 static struct inode *hfsplus_alloc_inode(struct super_block *sb)
 {
        struct hfsplus_inode_info *i;
-        i = kmem_cache_alloc(hfsplus_inode_cachep, SLAB_KERNEL);
+        i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL);
        return i ? &i->vfs_inode : NULL;
 }
@@ -467,7 +467,7 @@ static struct file_system_type hfsplus_fs_type = {
        .fs_flags       = FS_REQUIRES_DEV,
 };
-static void hfsplus_init_once(void *p, kmem_cache_t *cachep, unsigned long flags)
+static void hfsplus_init_once(void *p, struct kmem_cache *cachep, unsigned long flags)
 {
        struct hfsplus_inode_info *i = p;
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index ecc9180645ae..594f9c428fc2 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -84,7 +84,8 @@ static int hpfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                }
                if (!fno->dirflag) {
                        e = 1;
-                        hpfs_error(inode->i_sb, "not a directory, fnode %08x",inode->i_ino);
+                        hpfs_error(inode->i_sb, "not a directory, fnode %08lx",
+                                        (unsigned long)inode->i_ino);
                }
                if (hpfs_inode->i_dno != fno->u.external[0].disk_secno) {
                        e = 1;
@@ -144,8 +145,11 @@ static int hpfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                }
                if (de->first || de->last) {
                        if (hpfs_sb(inode->i_sb)->sb_chk) {
-                                if (de->first && !de->last && (de->namelen != 2 || de ->name[0] != 1 || de->name[1] != 1)) hpfs_error(inode->i_sb, "hpfs_readdir: bad ^A^A entry; pos = %08x", old_pos);
+                                if (de->first && !de->last && (de->namelen != 2
-                                if (de->last && (de->namelen != 1 || de ->name[0] != 255)) hpfs_error(inode->i_sb, "hpfs_readdir: bad \\377 entry; pos = %08x", old_pos);
+                                    || de ->name[0] != 1 || de->name[1] != 1))
+                                        hpfs_error(inode->i_sb, "hpfs_readdir: bad ^A^A entry; pos = %08lx", old_pos);
+                                if (de->last && (de->namelen != 1 || de ->name[0] != 255))
+                                        hpfs_error(inode->i_sb, "hpfs_readdir: bad \\377 entry; pos = %08lx", old_pos);
                        }
                        hpfs_brelse4(&qbh);
                        goto again;
diff --git a/fs/hpfs/dnode.c b/fs/hpfs/dnode.c
index 229ff2fb1809..fe83c2b7d2d8 100644
--- a/fs/hpfs/dnode.c
+++ b/fs/hpfs/dnode.c
@@ -533,10 +533,13 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                        struct buffer_head *bh;
                        struct dnode *d1;
                        struct quad_buffer_head qbh1;
-                        if (hpfs_sb(i->i_sb)->sb_chk) if (up != i->i_ino) {
+                        if (hpfs_sb(i->i_sb)->sb_chk)
-                                hpfs_error(i->i_sb, "bad pointer to fnode, dnode %08x, pointing to %08x, should be %08x", dno, up, i->i_ino);
+                            if (up != i->i_ino) {
+                                hpfs_error(i->i_sb,
+                                        "bad pointer to fnode, dnode %08x, pointing to %08x, should be %08lx",
+                                        dno, up, (unsigned long)i->i_ino);
                                return;
-                        }
+                            }
                        if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) {
                                d1->up = up;
                                d1->root_dnode = 1;
@@ -851,7 +854,9 @@ struct hpfs_dirent *map_pos_dirent(struct inode *inode, loff_t *posp,
        /* Going to the next dirent */
        if ((d = de_next_de(de)) < dnode_end_de(dnode)) {
                if (!(++*posp & 077)) {
-                        hpfs_error(inode->i_sb, "map_pos_dirent: pos crossed dnode boundary; pos = %08x", *posp);
+                        hpfs_error(inode->i_sb,
+                                "map_pos_dirent: pos crossed dnode boundary; pos = %08llx",
+                                (unsigned long long)*posp);
                        goto bail;
                }
                /* We're going down the tree */
diff --git a/fs/hpfs/ea.c b/fs/hpfs/ea.c
index 66339dc030e4..547a8384571f 100644
--- a/fs/hpfs/ea.c
+++ b/fs/hpfs/ea.c
@@ -243,8 +243,9 @@ void hpfs_set_ea(struct inode *inode, struct fnode *fnode, char *key, char *data
                fnode->ea_offs = 0xc4;
        }
        if (fnode->ea_offs < 0xc4 || fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s > 0x200) {
-                hpfs_error(s, "fnode %08x: ea_offs == %03x, ea_size_s == %03x",
+                hpfs_error(s, "fnode %08lx: ea_offs == %03x, ea_size_s == %03x",
-                        inode->i_ino, fnode->ea_offs, fnode->ea_size_s);
+                        (unsigned long)inode->i_ino,
+                        fnode->ea_offs, fnode->ea_size_s);
                return;
        }
        if ((fnode->ea_size_s || !fnode->ea_size_l) &&
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index 32ab51e42b96..1c07aa82d327 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -317,7 +317,8 @@ static inline struct hpfs_sb_info *hpfs_sb(struct super_block *sb)
 /* super.c */
-void hpfs_error(struct super_block *, char *, ...);
+void hpfs_error(struct super_block *, const char *, ...)
+        __attribute__((format (printf, 2, 3)));
 int hpfs_stop_cycles(struct super_block *, int, int *, int *, char *);
 unsigned hpfs_count_one_bitmap(struct super_block *, secno);
diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index 7faef8544f32..85d3e1d9ac00 100644
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -251,7 +251,10 @@ void hpfs_write_inode_nolock(struct inode *i)
                        de->file_size = 0;
                        hpfs_mark_4buffers_dirty(&qbh);
                        hpfs_brelse4(&qbh);
-                } else hpfs_error(i->i_sb, "directory %08x doesn't have '.' entry", i->i_ino);
+                } else
+                        hpfs_error(i->i_sb,
+                                "directory %08lx doesn't have '.' entry",
+                                (unsigned long)i->i_ino);
        }
        mark_buffer_dirty(bh);
        brelse(bh);
diff --git a/fs/hpfs/map.c b/fs/hpfs/map.c
index 0fecdac22e4e..c4724589b2eb 100644
--- a/fs/hpfs/map.c
+++ b/fs/hpfs/map.c
@@ -126,32 +126,40 @@ struct fnode *hpfs_map_fnode(struct super_block *s, ino_t ino, struct buffer_hea
                        struct extended_attribute *ea;
                        struct extended_attribute *ea_end;
                        if (fnode->magic != FNODE_MAGIC) {
-                                hpfs_error(s, "bad magic on fnode %08x", ino);
+                                hpfs_error(s, "bad magic on fnode %08lx",
+                                        (unsigned long)ino);
                                goto bail;
                        }
                        if (!fnode->dirflag) {
                                if ((unsigned)fnode->btree.n_used_nodes + (unsigned)fnode->btree.n_free_nodes !=
                                    (fnode->btree.internal ? 12 : 8)) {
-                                        hpfs_error(s, "bad number of nodes in fnode %08x", ino);
+                                        hpfs_error(s,
+                                           "bad number of nodes in fnode %08lx",
+                                            (unsigned long)ino);
                                        goto bail;
                                }
                                if (fnode->btree.first_free !=
                                    8 + fnode->btree.n_used_nodes * (fnode->btree.internal ? 8 : 12)) {
-                                        hpfs_error(s, "bad first_free pointer in fnode %08x", ino);
+                                        hpfs_error(s,
+                                            "bad first_free pointer in fnode %08lx",
+                                            (unsigned long)ino);
                                        goto bail;
                                }
                        }
                        if (fnode->ea_size_s && ((signed int)fnode->ea_offs < 0xc4 ||
                           (signed int)fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s > 0x200)) {
-                                hpfs_error(s, "bad EA info in fnode %08x: ea_offs == %04x ea_size_s == %04x",
+                                hpfs_error(s,
-                                        ino, fnode->ea_offs, fnode->ea_size_s);
+                                        "bad EA info in fnode %08lx: ea_offs == %04x ea_size_s == %04x",
+                                        (unsigned long)ino,
+                                        fnode->ea_offs, fnode->ea_size_s);
                                goto bail;
                        }
                        ea = fnode_ea(fnode);
                        ea_end = fnode_end_ea(fnode);
                        while (ea != ea_end) {
                                if (ea > ea_end) {
-                                        hpfs_error(s, "bad EA in fnode %08x", ino);
+                                        hpfs_error(s, "bad EA in fnode %08lx",
+                                                (unsigned long)ino);
                                        goto bail;
                                }
                                ea = next_ea(ea);
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 450b5e0b4785..d4abc1a1d566 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -46,21 +46,17 @@ static void unmark_dirty(struct super_block *s)
 }
 /* Filesystem error... */
+static char err_buf[1024];
-#define ERR_BUF_SIZE 1024
+void hpfs_error(struct super_block *s, const char *fmt, ...)
-void hpfs_error(struct super_block *s, char *m,...)
 {
-        char *buf;
+        va_list args;
-        va_list l;
-        va_start(l, m);
+        va_start(args, fmt);
-        if (!(buf = kmalloc(ERR_BUF_SIZE, GFP_KERNEL)))
+        vsnprintf(err_buf, sizeof(err_buf), fmt, args);
-                printk("HPFS: No memory for error message '%s'\n",m);
+        va_end(args);
-        else if (vsprintf(buf, m, l) >= ERR_BUF_SIZE)
-                printk("HPFS: Grrrr... Kernel memory corrupted ... going on, but it'll crash very soon :-(\n");
+        printk("HPFS: filesystem error: %s", err_buf);
-        printk("HPFS: filesystem error: ");
-        if (buf) printk("%s", buf);
-        else printk("%s\n",m);
        if (!hpfs_sb(s)->sb_was_error) {
                if (hpfs_sb(s)->sb_err == 2) {
                        printk("; crashing the system because you wanted it\n");
@@ -76,7 +72,6 @@ void hpfs_error(struct super_block *s, char *m,...)
                } else if (s->s_flags & MS_RDONLY) printk("; going on - but anything won't be destroyed because it's read-only\n");
                else printk("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
        } else printk("\n");
-        kfree(buf);
        hpfs_sb(s)->sb_was_error = 1;
 }
@@ -160,12 +155,12 @@ static int hpfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        return 0;
 }
-static kmem_cache_t * hpfs_inode_cachep;
+static struct kmem_cache * hpfs_inode_cachep;
 static struct inode *hpfs_alloc_inode(struct super_block *sb)
 {
        struct hpfs_inode_info *ei;
-        ei = (struct hpfs_inode_info *)kmem_cache_alloc(hpfs_inode_cachep, SLAB_NOFS);
+        ei = (struct hpfs_inode_info *)kmem_cache_alloc(hpfs_inode_cachep, GFP_NOFS);
        if (!ei)
                return NULL;
        ei->vfs_inode.i_version = 1;
@@ -177,7 +172,7 @@ static void hpfs_destroy_inode(struct inode *inode)
        kmem_cache_free(hpfs_inode_cachep, hpfs_i(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 7f4756963d05..0706f5aac6a2 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -513,7 +513,7 @@ static void hugetlbfs_inc_free_inodes(struct hugetlbfs_sb_info *sbinfo)
 }
-static kmem_cache_t *hugetlbfs_inode_cachep;
+static struct kmem_cache *hugetlbfs_inode_cachep;
 static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
 {
@@ -522,7 +522,7 @@ static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
        if (unlikely(!hugetlbfs_dec_free_inodes(sbinfo)))
                return NULL;
-        p = kmem_cache_alloc(hugetlbfs_inode_cachep, SLAB_KERNEL);
+        p = kmem_cache_alloc(hugetlbfs_inode_cachep, GFP_KERNEL);
        if (unlikely(!p)) {
                hugetlbfs_inc_free_inodes(sbinfo);
                return NULL;
@@ -545,7 +545,7 @@ static const struct address_space_operations hugetlbfs_aops = {
 };
-static void init_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct hugetlbfs_inode_info *ei = (struct hugetlbfs_inode_info *)foo;
diff --git a/fs/inode.c b/fs/inode.c
index 26cdb115ce67..9ecccab7326d 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -97,7 +97,7 @@ static DEFINE_MUTEX(iprune_mutex);
 */
 struct inodes_stat_t inodes_stat;
-static kmem_cache_t * inode_cachep __read_mostly;
+static struct kmem_cache * inode_cachep __read_mostly;
 static struct inode *alloc_inode(struct super_block *sb)
 {
@@ -109,7 +109,7 @@ static struct inode *alloc_inode(struct super_block *sb)
        if (sb->s_op->alloc_inode)
                inode = sb->s_op->alloc_inode(sb);
        else
-                inode = (struct inode *) kmem_cache_alloc(inode_cachep, SLAB_KERNEL);
+                inode = (struct inode *) kmem_cache_alloc(inode_cachep, GFP_KERNEL);
        if (inode) {
                struct address_space * const mapping = &inode->i_data;
@@ -209,7 +209,7 @@ void inode_init_once(struct inode *inode)
 EXPORT_SYMBOL(inode_init_once);
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct inode * inode = (struct inode *) foo;
@@ -1242,9 +1242,6 @@ EXPORT_SYMBOL(inode_needs_sync);
 */
 #ifdef CONFIG_QUOTA
-/* Function back in dquot.c */
-int remove_inode_dquot_ref(struct inode *, int, struct list_head *);
 void remove_dquot_ref(struct super_block *sb, int type,
                        struct list_head *tofree_head)
 {
diff --git a/fs/inotify.c b/fs/inotify.c
index 723836a1f718..f5099d86fd91 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -27,6 +27,7 @@
 #include <linux/idr.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/writeback.h>
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index 017cb0f134d6..e1956e6f116c 100644
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -34,8 +34,8 @@
 #include <asm/ioctls.h>
-static kmem_cache_t *watch_cachep __read_mostly;
+static struct kmem_cache *watch_cachep __read_mostly;
-static kmem_cache_t *event_cachep __read_mostly;
+static struct kmem_cache *event_cachep __read_mostly;
 static struct vfsmount *inotify_mnt __read_mostly;
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index c34b862cdbf2..ea55b6c469ec 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -57,12 +57,12 @@ static void isofs_put_super(struct super_block *sb)
 static void isofs_read_inode(struct inode *);
 static int isofs_statfs (struct dentry *, struct kstatfs *);
-static kmem_cache_t *isofs_inode_cachep;
+static struct kmem_cache *isofs_inode_cachep;
 static struct inode *isofs_alloc_inode(struct super_block *sb)
 {
        struct iso_inode_info *ei;
-        ei = kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
+        ei = kmem_cache_alloc(isofs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -73,7 +73,7 @@ static void isofs_destroy_inode(struct inode *inode)
        kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
 }
-static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct iso_inode_info *ei = foo;
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index b85c686b60db..10fff9443938 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -31,7 +31,7 @@
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mm.h>
-#include <linux/suspend.h>
+#include <linux/freezer.h>
 #include <linux/pagemap.h>
 #include <linux/kthread.h>
 #include <linux/poison.h>
@@ -1630,7 +1630,7 @@ void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry)
 #define JBD_MAX_SLABS 5
 #define JBD_SLAB_INDEX(size)  (size >> 11)
-static kmem_cache_t *jbd_slab[JBD_MAX_SLABS];
+static struct kmem_cache *jbd_slab[JBD_MAX_SLABS];
 static const char *jbd_slab_names[JBD_MAX_SLABS] = {
        "jbd_1k", "jbd_2k", "jbd_4k", NULL, "jbd_8k"
 };
@@ -1693,7 +1693,7 @@ void jbd_slab_free(void *ptr,  size_t size)
 /*
 * Journal_head storage management
 */
-static kmem_cache_t *journal_head_cache;
+static struct kmem_cache *journal_head_cache;
 #ifdef CONFIG_JBD_DEBUG
 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
 #endif
@@ -1996,7 +1996,7 @@ static void __exit remove_jbd_proc_entry(void)
 #endif
-kmem_cache_t *jbd_handle_cache;
+struct kmem_cache *jbd_handle_cache;
 static int __init journal_init_handle_cache(void)
 {
diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index c532429d8d9b..d204ab394f36 100644
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -70,8 +70,8 @@
 #include <linux/init.h>
 #endif
-static kmem_cache_t *revoke_record_cache;
+static struct kmem_cache *revoke_record_cache;
-static kmem_cache_t *revoke_table_cache;
+static struct kmem_cache *revoke_table_cache;
 /* Each revoke record represents one single revoked block.  During
   journal replay, this involves recording the transaction ID of the
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index 4f82bcd63e48..d38e0d575e48 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -27,6 +27,8 @@
 #include <linux/mm.h>
 #include <linux/highmem.h>
+static void __journal_temp_unlink_buffer(struct journal_head *jh);
 /*
 * get_transaction: obtain a new transaction_t object.
 *
@@ -1499,7 +1501,7 @@ __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
 *
 * Called under j_list_lock.  The journal may not be locked.
 */
-void __journal_temp_unlink_buffer(struct journal_head *jh)
+static void __journal_temp_unlink_buffer(struct journal_head *jh)
 {
        struct journal_head **list = NULL;
        transaction_t *transaction;
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 70b2ae1ef281..6bd8005e3d34 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -248,8 +248,12 @@ write_out_data:
                                bufs = 0;
                                goto write_out_data;
                        }
-                }
+                } else if (!locked && buffer_locked(bh)) {
-                else {
+                        __jbd2_journal_file_buffer(jh, commit_transaction,
+                                                BJ_Locked);
+                        jbd_unlock_bh_state(bh);
+                        put_bh(bh);
+                } else {
                        BUFFER_TRACE(bh, "writeout complete: unfile");
                        __jbd2_journal_unfile_buffer(jh);
                        jbd_unlock_bh_state(bh);
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index c60f378b0f76..44fc32bfd7f1 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -31,7 +31,7 @@
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mm.h>
-#include <linux/suspend.h>
+#include <linux/freezer.h>
 #include <linux/pagemap.h>
 #include <linux/kthread.h>
 #include <linux/poison.h>
@@ -1641,7 +1641,7 @@ void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry)
 #define JBD_MAX_SLABS 5
 #define JBD_SLAB_INDEX(size)  (size >> 11)
-static kmem_cache_t *jbd_slab[JBD_MAX_SLABS];
+static struct kmem_cache *jbd_slab[JBD_MAX_SLABS];
 static const char *jbd_slab_names[JBD_MAX_SLABS] = {
        "jbd2_1k", "jbd2_2k", "jbd2_4k", NULL, "jbd2_8k"
 };
@@ -1704,7 +1704,7 @@ void jbd2_slab_free(void *ptr,  size_t size)
 /*
 * Journal_head storage management
 */
-static kmem_cache_t *jbd2_journal_head_cache;
+static struct kmem_cache *jbd2_journal_head_cache;
 #ifdef CONFIG_JBD_DEBUG
 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
 #endif
@@ -2007,7 +2007,7 @@ static void __exit jbd2_remove_jbd_proc_entry(void)
 #endif
-kmem_cache_t *jbd2_handle_cache;
+struct kmem_cache *jbd2_handle_cache;
 static int __init journal_init_handle_cache(void)
 {
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index 380d19917f37..f506646ad0ff 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -70,8 +70,8 @@
 #include <linux/init.h>
 #endif
-static kmem_cache_t *jbd2_revoke_record_cache;
+static struct kmem_cache *jbd2_revoke_record_cache;
-static kmem_cache_t *jbd2_revoke_table_cache;
+static struct kmem_cache *jbd2_revoke_table_cache;
 /* Each revoke record represents one single revoked block.  During
   journal replay, this involves recording the transaction ID of the
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index c051a94c8a97..3a8700153cb0 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -27,6 +27,8 @@
 #include <linux/mm.h>
 #include <linux/highmem.h>
+static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
 /*
 * jbd2_get_transaction: obtain a new transaction_t object.
 *
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 3f7899ea4cba..9f15bce92022 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -61,8 +61,8 @@ static const struct file_operations jffs_dir_operations;
 static struct inode_operations jffs_dir_inode_operations;
 static const struct address_space_operations jffs_address_operations;
-kmem_cache_t     *node_cache = NULL;
+struct kmem_cache     *node_cache = NULL;
-kmem_cache_t     *fm_cache = NULL;
+struct kmem_cache     *fm_cache = NULL;
 /* Called by the VFS at mount time to initialize the whole file system.  */
 static int jffs_fill_super(struct super_block *sb, void *data, int silent)
diff --git a/fs/jffs/intrep.c b/fs/jffs/intrep.c
index 4a543e114970..d0e783f199ea 100644
--- a/fs/jffs/intrep.c
+++ b/fs/jffs/intrep.c
@@ -66,6 +66,7 @@
 #include <linux/smp_lock.h>
 #include <linux/time.h>
 #include <linux/ctype.h>
+#include <linux/freezer.h>
 #include "intrep.h"
 #include "jffs_fm.h"
@@ -591,7 +592,7 @@ jffs_add_virtual_root(struct jffs_control *c)
        D2(printk("jffs_add_virtual_root(): "
                  "Creating a virtual root directory.\n"));
-        if (!(root = kmalloc(sizeof(struct jffs_file), GFP_KERNEL))) {
+        if (!(root = kzalloc(sizeof(struct jffs_file), GFP_KERNEL))) {
                return -ENOMEM;
        }
        no_jffs_file++;
@@ -603,7 +604,6 @@ jffs_add_virtual_root(struct jffs_control *c)
        DJM(no_jffs_node++);
        memset(node, 0, sizeof(struct jffs_node));
        node->ino = JFFS_MIN_INO;
-        memset(root, 0, sizeof(struct jffs_file));
        root->ino = JFFS_MIN_INO;
        root->mode = S_IFDIR | S_IRWXU | S_IRGRP
                     | S_IXGRP | S_IROTH | S_IXOTH;
diff --git a/fs/jffs/jffs_fm.c b/fs/jffs/jffs_fm.c
index 29b68d939bd9..077258b2103e 100644
--- a/fs/jffs/jffs_fm.c
+++ b/fs/jffs/jffs_fm.c
@@ -29,8 +29,8 @@ static int jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset);
 static struct jffs_fm *jffs_alloc_fm(void);
 static void jffs_free_fm(struct jffs_fm *n);
-extern kmem_cache_t     *fm_cache;
+extern struct kmem_cache     *fm_cache;
-extern kmem_cache_t     *node_cache;
+extern struct kmem_cache     *node_cache;
 #if CONFIG_JFFS_FS_VERBOSE > 0
 void
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 0ae3cd10702c..73f0d60f73a5 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/time.h>
 #include <linux/crc32.h>
 #include <linux/jffs2.h>
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index ff2a872e80e7..6eb3daebd563 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -16,6 +16,7 @@
 #include <linux/mtd/mtd.h>
 #include <linux/completion.h>
 #include <linux/sched.h>
+#include <linux/freezer.h>
 #include "nodelist.h"
diff --git a/fs/jffs2/malloc.c b/fs/jffs2/malloc.c
index 33f291005012..83f9881ec4cc 100644
--- a/fs/jffs2/malloc.c
+++ b/fs/jffs2/malloc.c
@@ -19,16 +19,16 @@
 /* These are initialised to NULL in the kernel startup code.
   If you're porting to other operating systems, beware */
-static kmem_cache_t *full_dnode_slab;
+static struct kmem_cache *full_dnode_slab;
-static kmem_cache_t *raw_dirent_slab;
+static struct kmem_cache *raw_dirent_slab;
-static kmem_cache_t *raw_inode_slab;
+static struct kmem_cache *raw_inode_slab;
-static kmem_cache_t *tmp_dnode_info_slab;
+static struct kmem_cache *tmp_dnode_info_slab;
-static kmem_cache_t *raw_node_ref_slab;
+static struct kmem_cache *raw_node_ref_slab;
-static kmem_cache_t *node_frag_slab;
+static struct kmem_cache *node_frag_slab;
-static kmem_cache_t *inode_cache_slab;
+static struct kmem_cache *inode_cache_slab;
 #ifdef CONFIG_JFFS2_FS_XATTR
-static kmem_cache_t *xattr_datum_cache;
+static struct kmem_cache *xattr_datum_cache;
-static kmem_cache_t *xattr_ref_cache;
+static struct kmem_cache *xattr_ref_cache;
 #endif
 int __init jffs2_create_slab_caches(void)
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index bc4b8106a490..7deb78254021 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -28,12 +28,12 @@
 static void jffs2_put_super(struct super_block *);
-static kmem_cache_t *jffs2_inode_cachep;
+static struct kmem_cache *jffs2_inode_cachep;
 static struct inode *jffs2_alloc_inode(struct super_block *sb)
 {
        struct jffs2_inode_info *ei;
-        ei = (struct jffs2_inode_info *)kmem_cache_alloc(jffs2_inode_cachep, SLAB_KERNEL);
+        ei = (struct jffs2_inode_info *)kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -44,7 +44,7 @@ static void jffs2_destroy_inode(struct inode *inode)
        kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
 }
-static void jffs2_i_init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void jffs2_i_init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct jffs2_inode_info *ei = (struct jffs2_inode_info *) foo;
diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index b9b700730dfe..70707309dfa1 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -19,6 +19,7 @@
 #include <linux/crc32.h>
 #include <linux/mtd/nand.h>
 #include <linux/jiffies.h>
+#include <linux/sched.h>
 #include "nodelist.h"
diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c
index 37db52488262..ed814b1ff4d9 100644
--- a/fs/jfs/ioctl.c
+++ b/fs/jfs/ioctl.c
@@ -9,6 +9,7 @@
 #include <linux/ctype.h>
 #include <linux/capability.h>
 #include <linux/time.h>
+#include <linux/sched.h>
 #include <asm/current.h>
 #include <asm/uaccess.h>
diff --git a/fs/jfs/jfs_filsys.h b/fs/jfs/jfs_filsys.h
index 9901928668cf..eb550b339bb8 100644
--- a/fs/jfs/jfs_filsys.h
+++ b/fs/jfs/jfs_filsys.h
@@ -81,7 +81,7 @@
 #define JFS_SWAP_BYTES          0x00100000      /* running on big endian computer */
 /* Directory index */
-#define JFS_DIR_INDEX           0x00200000      /* Persistant index for */
+#define JFS_DIR_INDEX           0x00200000      /* Persistent index for */
                                                /* directory entries    */
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index b89c9aba0466..5065baa530b6 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -67,7 +67,7 @@
 #include <linux/kthread.h>
 #include <linux/buffer_head.h>          /* for sync_blockdev() */
 #include <linux/bio.h>
-#include <linux/suspend.h>
+#include <linux/freezer.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
 #include "jfs_incore.h"
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 0cccd1c39d75..b1a1c7296014 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -74,7 +74,7 @@ static inline void lock_metapage(struct metapage *mp)
 }
 #define METAPOOL_MIN_PAGES 32
-static kmem_cache_t *metapage_cache;
+static struct kmem_cache *metapage_cache;
 static mempool_t *metapage_mempool;
 #define MPS_PER_PAGE (PAGE_CACHE_SIZE >> L2PSIZE)
@@ -180,7 +180,7 @@ static inline void remove_metapage(struct page *page, struct metapage *mp)
 #endif
-static void init_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
        struct metapage *mp = (struct metapage *)foo;
diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index 81f6f04af192..d558e51b0df8 100644
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -46,7 +46,7 @@
 #include <linux/vmalloc.h>
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
-#include <linux/suspend.h>
+#include <linux/freezer.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kthread.h>
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 9c1c6e0e633d..846ac8f34513 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -44,7 +44,7 @@ MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
 MODULE_LICENSE("GPL");
-static kmem_cache_t * jfs_inode_cachep;
+static struct kmem_cache * jfs_inode_cachep;
 static struct super_operations jfs_super_operations;
 static struct export_operations jfs_export_operations;
@@ -93,7 +93,7 @@ void jfs_error(struct super_block *sb, const char * function, ...)
        va_list args;
        va_start(args, function);
-        vsprintf(error_buf, function, args);
+        vsnprintf(error_buf, sizeof(error_buf), function, args);
        va_end(args);
        printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);
@@ -748,7 +748,7 @@ static struct file_system_type jfs_fs_type = {
        .fs_flags       = FS_REQUIRES_DEV,
 };
-static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index 3d84f600b633..50643b6a5556 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -13,6 +13,7 @@
 #include <linux/nfs_fs.h>
 #include <linux/utsname.h>
 #include <linux/smp_lock.h>
+#include <linux/freezer.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/svc.h>
 #include <linux/lockd/lockd.h>
diff --git a/fs/lockd/host.c b/fs/lockd/host.c
index fb24a9730345..3d4610c2a266 100644
--- a/fs/lockd/host.c
+++ b/fs/lockd/host.c
@@ -36,34 +36,14 @@ static DEFINE_MUTEX(nlm_host_mutex);
 static void                     nlm_gc_hosts(void);
 static struct nsm_handle *      __nsm_find(const struct sockaddr_in *,
                                        const char *, int, int);
+static struct nsm_handle *      nsm_find(const struct sockaddr_in *sin,
-/*
+                                         const char *hostname,
- * Find an NLM server handle in the cache. If there is none, create it.
+                                         int hostname_len);
- */
-struct nlm_host *
-nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
-                        const char *hostname, int hostname_len)
-{
-        return nlm_lookup_host(0, sin, proto, version,
-                               hostname, hostname_len);
-}
-/*
- * Find an NLM client handle in the cache. If there is none, create it.
- */
-struct nlm_host *
-nlmsvc_lookup_host(struct svc_rqst *rqstp,
-                        const char *hostname, int hostname_len)
-{
-        return nlm_lookup_host(1, &rqstp->rq_addr,
-                               rqstp->rq_prot, rqstp->rq_vers,
-                               hostname, hostname_len);
-}
 /*
 * Common host lookup routine for server & client
 */
-struct nlm_host *
+static struct nlm_host *
 nlm_lookup_host(int server, const struct sockaddr_in *sin,
                                        int proto, int version,
                                        const char *hostname,
@@ -195,6 +175,29 @@ nlm_destroy_host(struct nlm_host *host)
 }
 /*
+ * Find an NLM server handle in the cache. If there is none, create it.
+ */
+struct nlm_host *
+nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
+                        const char *hostname, int hostname_len)
+{
+        return nlm_lookup_host(0, sin, proto, version,
+                               hostname, hostname_len);
+}
+/*
+ * Find an NLM client handle in the cache. If there is none, create it.
+ */
+struct nlm_host *
+nlmsvc_lookup_host(struct svc_rqst *rqstp,
+                        const char *hostname, int hostname_len)
+{
+        return nlm_lookup_host(1, &rqstp->rq_addr,
+                               rqstp->rq_prot, rqstp->rq_vers,
+                               hostname, hostname_len);
+}
+/*
 * Create the NLM RPC client for an NLM peer
 */
 struct rpc_clnt *
@@ -495,7 +498,7 @@ out:
        return nsm;
 }
-struct nsm_handle *
+static struct nsm_handle *
 nsm_find(const struct sockaddr_in *sin, const char *hostname, int hostname_len)
 {
        return __nsm_find(sin, hostname, hostname_len, 1);
diff --git a/fs/locks.c b/fs/locks.c
index e0b6a80649a0..1cb0c57fedbd 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -142,12 +142,12 @@ int lease_break_time = 45;
 static LIST_HEAD(file_lock_list);
 static LIST_HEAD(blocked_list);
-static kmem_cache_t *filelock_cache __read_mostly;
+static struct kmem_cache *filelock_cache __read_mostly;
 /* Allocate an empty lock structure. */
 static struct file_lock *locks_alloc_lock(void)
 {
-        return kmem_cache_alloc(filelock_cache, SLAB_KERNEL);
+        return kmem_cache_alloc(filelock_cache, GFP_KERNEL);
 }
 static void locks_release_private(struct file_lock *fl)
@@ -199,7 +199,7 @@ EXPORT_SYMBOL(locks_init_lock);
 * Initialises the fields of the file lock which are invariant for
 * free file_locks.
 */
-static void init_once(void *foo, kmem_cache_t *cache, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags)
 {
        struct file_lock *lock = (struct file_lock *) foo;
diff --git a/fs/mbcache.c b/fs/mbcache.c
index 0ff71256e65b..deeb9dc062d9 100644
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -85,7 +85,7 @@ struct mb_cache {
 #ifndef MB_CACHE_INDEXES_COUNT
        int                             c_indexes_count;
 #endif
-        kmem_cache_t                    *c_entry_cache;
+        struct kmem_cache                       *c_entry_cache;
        struct list_head                *c_block_hash;
        struct list_head                *c_indexes_hash[0];
 };
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 1e36bae4d0eb..629e09b38c5c 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -51,12 +51,12 @@ static void minix_put_super(struct super_block *sb)
        return;
 }
-static kmem_cache_t * minix_inode_cachep;
+static struct kmem_cache * minix_inode_cachep;
 static struct inode *minix_alloc_inode(struct super_block *sb)
 {
        struct minix_inode_info *ei;
-        ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, SLAB_KERNEL);
+        ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -67,7 +67,7 @@ static void minix_destroy_inode(struct inode *inode)
        kmem_cache_free(minix_inode_cachep, minix_i(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct minix_inode_info *ei = (struct minix_inode_info *) foo;
diff --git a/fs/namei.c b/fs/namei.c
index 28d49b301d55..db1bca26d88c 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -249,9 +249,11 @@ int permission(struct inode *inode, int mask, struct nameidata *nd)
        /*
         * MAY_EXEC on regular files requires special handling: We override
-         * filesystem execute permissions if the mode bits aren't set.
+         * filesystem execute permissions if the mode bits aren't set or
+         * the fs is mounted with the "noexec" flag.
         */
-        if ((mask & MAY_EXEC) && S_ISREG(mode) && !(mode & S_IXUGO))
+        if ((mask & MAY_EXEC) && S_ISREG(mode) && (!(mode & S_IXUGO) ||
+                        (nd && nd->mnt && (nd->mnt->mnt_flags & MNT_NOEXEC))))
                return -EACCES;
        /* Ordinary permission routines do not understand MAY_APPEND. */
@@ -1996,8 +1998,7 @@ asmlinkage long sys_mkdir(const char __user *pathname, int mode)
 void dentry_unhash(struct dentry *dentry)
 {
        dget(dentry);
-        if (atomic_read(&dentry->d_count))
+        shrink_dcache_parent(dentry);
-                shrink_dcache_parent(dentry);
        spin_lock(&dcache_lock);
        spin_lock(&dentry->d_lock);
        if (atomic_read(&dentry->d_count) == 2)
diff --git a/fs/namespace.c b/fs/namespace.c
index 55442a6cf221..b00ac84ebbdd 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -36,7 +36,7 @@ static int event;
 static struct list_head *mount_hashtable __read_mostly;
 static int hash_mask __read_mostly, hash_bits __read_mostly;
-static kmem_cache_t *mnt_cache __read_mostly;
+static struct kmem_cache *mnt_cache __read_mostly;
 static struct rw_semaphore namespace_sem;
 /* /sys/fs */
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 42e3bef270c9..fae53243bb92 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -40,12 +40,12 @@ static void ncp_delete_inode(struct inode *);
 static void ncp_put_super(struct super_block *);
 static int  ncp_statfs(struct dentry *, struct kstatfs *);
-static kmem_cache_t * ncp_inode_cachep;
+static struct kmem_cache * ncp_inode_cachep;
 static struct inode *ncp_alloc_inode(struct super_block *sb)
 {
        struct ncp_inode_info *ei;
-        ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, SLAB_KERNEL);
+        ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -56,7 +56,7 @@ static void ncp_destroy_inode(struct inode *inode)
        kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
@@ -577,12 +577,12 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
                server->rcv.ptr = (unsigned char*)&server->rcv.buf;
                server->rcv.len = 10;
                server->rcv.state = 0;
-                INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc, server);
+                INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc);
-                INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc, server);
+                INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc);
                sock->sk->sk_write_space = ncp_tcp_write_space;
        } else {
-                INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc, server);
+                INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc);
-                INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc, server);
+                INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc);
                server->timeout_tm.data = (unsigned long)server;
                server->timeout_tm.function = ncpdgram_timeout_call;
        }
diff --git a/fs/ncpfs/sock.c b/fs/ncpfs/sock.c
index 11c2b252ebed..e496d8b65e92 100644
--- a/fs/ncpfs/sock.c
+++ b/fs/ncpfs/sock.c
@@ -350,9 +350,10 @@ static void info_server(struct ncp_server *server, unsigned int id, const void *
        }
 }
-void ncpdgram_rcv_proc(void *s)
+void ncpdgram_rcv_proc(struct work_struct *work)
 {
-        struct ncp_server *server = s;
+        struct ncp_server *server =
+                container_of(work, struct ncp_server, rcv.tq);
        struct socket* sock;
        
        sock = server->ncp_sock;
@@ -468,9 +469,10 @@ static void __ncpdgram_timeout_proc(struct ncp_server *server)
        }
 }
-void ncpdgram_timeout_proc(void *s)
+void ncpdgram_timeout_proc(struct work_struct *work)
 {
-        struct ncp_server *server = s;
+        struct ncp_server *server =
+                container_of(work, struct ncp_server, timeout_tq);
        mutex_lock(&server->rcv.creq_mutex);
        __ncpdgram_timeout_proc(server);
        mutex_unlock(&server->rcv.creq_mutex);
@@ -652,18 +654,20 @@ skipdata:;
        }
 }
-void ncp_tcp_rcv_proc(void *s)
+void ncp_tcp_rcv_proc(struct work_struct *work)
 {
-        struct ncp_server *server = s;
+        struct ncp_server *server =
+                container_of(work, struct ncp_server, rcv.tq);
        mutex_lock(&server->rcv.creq_mutex);
        __ncptcp_rcv_proc(server);
        mutex_unlock(&server->rcv.creq_mutex);
 }
-void ncp_tcp_tx_proc(void *s)
+void ncp_tcp_tx_proc(struct work_struct *work)
 {
-        struct ncp_server *server = s;
+        struct ncp_server *server =
+                container_of(work, struct ncp_server, tx.tq);
        
        mutex_lock(&server->rcv.creq_mutex);
        __ncptcp_try_send(server);
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 5fea638743e4..23ab145daa2d 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -143,7 +143,7 @@ static struct nfs_client *nfs_alloc_client(const char *hostname,
        INIT_LIST_HEAD(&clp->cl_state_owners);
        INIT_LIST_HEAD(&clp->cl_unused);
        spin_lock_init(&clp->cl_lock);
-        INIT_WORK(&clp->cl_renewd, nfs4_renew_state, clp);
+        INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
        rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
        clp->cl_boot_time = CURRENT_TIME;
        clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index bdfabf854a51..2f488e1d9b6c 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -58,7 +58,7 @@
 #define NFSDBG_FACILITY         NFSDBG_VFS
-static kmem_cache_t *nfs_direct_cachep;
+static struct kmem_cache *nfs_direct_cachep;
 /*
 * This represents a set of asynchronous requests that we're waiting on
@@ -143,7 +143,7 @@ static inline struct nfs_direct_req *nfs_direct_req_alloc(void)
 {
        struct nfs_direct_req *dreq;
-        dreq = kmem_cache_alloc(nfs_direct_cachep, SLAB_KERNEL);
+        dreq = kmem_cache_alloc(nfs_direct_cachep, GFP_KERNEL);
        if (!dreq)
                return NULL;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 08cc4c5919ab..15afa460e629 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -55,7 +55,7 @@ static int nfs_update_inode(struct inode *, struct nfs_fattr *);
 static void nfs_zap_acl_cache(struct inode *);
-static kmem_cache_t * nfs_inode_cachep;
+static struct kmem_cache * nfs_inode_cachep;
 static inline unsigned long
 nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
@@ -1080,7 +1080,7 @@ void nfs4_clear_inode(struct inode *inode)
 struct inode *nfs_alloc_inode(struct super_block *sb)
 {
        struct nfs_inode *nfsi;
-        nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL);
+        nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
        if (!nfsi)
                return NULL;
        nfsi->flags = 0UL;
@@ -1111,7 +1111,7 @@ static inline void nfs4_init_once(struct nfs_inode *nfsi)
 #endif
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct nfs_inode *nfsi = (struct nfs_inode *) foo;
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index ec1114b33d89..371b804e7cc8 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -18,10 +18,10 @@
 #define NFSDBG_FACILITY         NFSDBG_VFS
-static void nfs_expire_automounts(void *list);
+static void nfs_expire_automounts(struct work_struct *work);
 LIST_HEAD(nfs_automount_list);
-static DECLARE_WORK(nfs_automount_task, nfs_expire_automounts, &nfs_automount_list);
+static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts);
 int nfs_mountpoint_expiry_timeout = 500 * HZ;
 static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
@@ -164,9 +164,9 @@ struct inode_operations nfs_referral_inode_operations = {
        .follow_link    = nfs_follow_mountpoint,
 };
-static void nfs_expire_automounts(void *data)
+static void nfs_expire_automounts(struct work_struct *work)
 {
-        struct list_head *list = (struct list_head *)data;
+        struct list_head *list = &nfs_automount_list;
        mark_mounts_for_expiry(list);
        if (!list_empty(list))
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 6f346677332d..c26cd978c7cc 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -185,7 +185,7 @@ extern const u32 nfs4_fs_locations_bitmap[2];
 extern void nfs4_schedule_state_renewal(struct nfs_client *);
 extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
 extern void nfs4_kill_renewd(struct nfs_client *);
-extern void nfs4_renew_state(void *);
+extern void nfs4_renew_state(struct work_struct *);
 /* nfs4state.c */
 struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp);
diff --git a/fs/nfs/nfs4renewd.c b/fs/nfs/nfs4renewd.c
index 7b6df1852e75..823298561c0a 100644
--- a/fs/nfs/nfs4renewd.c
+++ b/fs/nfs/nfs4renewd.c
@@ -59,9 +59,10 @@
 #define NFSDBG_FACILITY NFSDBG_PROC
 void
-nfs4_renew_state(void *data)
+nfs4_renew_state(struct work_struct *work)
 {
-        struct nfs_client *clp = (struct nfs_client *)data;
+        struct nfs_client *clp =
+                container_of(work, struct nfs_client, cl_renewd.work);
        struct rpc_cred *cred;
        long lease, timeout;
        unsigned long last, now;
diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c
index 8dfefe41a8da..75f819dc0255 100644
--- a/fs/nfs/nfsroot.c
+++ b/fs/nfs/nfsroot.c
@@ -98,7 +98,7 @@
 static char nfs_root_name[256] __initdata = "";
 /* Address of NFS server */
-static __u32 servaddr __initdata = 0;
+static __be32 servaddr __initdata = 0;
 /* Name of directory to mount */
 static char nfs_path[NFS_MAXPATHLEN] __initdata = { 0, };
@@ -327,7 +327,7 @@ static int __init root_nfs_name(char *name)
 */
 static int __init root_nfs_addr(void)
 {
-        if ((servaddr = root_server_addr) == INADDR_NONE) {
+        if ((servaddr = root_server_addr) == htonl(INADDR_NONE)) {
                printk(KERN_ERR "Root-NFS: No NFS server available, giving up.\n");
                return -1;
        }
@@ -411,7 +411,7 @@ __setup("nfsroot=", nfs_root_setup);
 *  Construct sockaddr_in from address and port number.
 */
 static inline void
-set_sockaddr(struct sockaddr_in *sin, __u32 addr, __u16 port)
+set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)
 {
        sin->sin_family = AF_INET;
        sin->sin_addr.s_addr = addr;
@@ -468,14 +468,13 @@ static int __init root_nfs_ports(void)
                dprintk("Root-NFS: Portmapper on server returned %d "
                        "as nfsd port\n", port);
        }
-        nfs_port = htons(nfs_port);
        if ((port = root_nfs_getport(NFS_MNT_PROGRAM, mountd_ver, proto)) < 0) {
                printk(KERN_ERR "Root-NFS: Unable to get mountd port "
                                "number from server, using default\n");
                port = mountd_port;
        }
-        mount_port = htons(port);
+        mount_port = port;
        dprintk("Root-NFS: mountd port is %d\n", port);
        return 0;
@@ -496,7 +495,7 @@ static int __init root_nfs_get_handle(void)
        int version = (nfs_data.flags & NFS_MOUNT_VER3) ?
                                        NFS_MNT3_VERSION : NFS_MNT_VERSION;
-        set_sockaddr(&sin, servaddr, mount_port);
+        set_sockaddr(&sin, servaddr, htons(mount_port));
        status = nfsroot_mount(&sin, nfs_path, &fh, version, protocol);
        if (status < 0)
                printk(KERN_ERR "Root-NFS: Server returned error %d "
@@ -519,6 +518,6 @@ void * __init nfs_root_data(void)
         || root_nfs_ports() < 0
         || root_nfs_get_handle() < 0)
                return NULL;
-        set_sockaddr((struct sockaddr_in *) &nfs_data.addr, servaddr, nfs_port);
+        set_sockaddr((struct sockaddr_in *) &nfs_data.addr, servaddr, htons(nfs_port));
        return (void*)&nfs_data;
 }
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 829af323f288..3fbfc2f03307 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -20,13 +20,13 @@
 #define NFS_PARANOIA 1
-static kmem_cache_t *nfs_page_cachep;
+static struct kmem_cache *nfs_page_cachep;
 static inline struct nfs_page *
 nfs_page_alloc(void)
 {
        struct nfs_page *p;
-        p = kmem_cache_alloc(nfs_page_cachep, SLAB_KERNEL);
+        p = kmem_cache_alloc(nfs_page_cachep, GFP_KERNEL);
        if (p) {
                memset(p, 0, sizeof(*p));
                INIT_LIST_HEAD(&p->wb_list);
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index c2e49c397a27..244a8c45b68e 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -38,7 +38,7 @@ static int nfs_pagein_one(struct list_head *, struct inode *);
 static const struct rpc_call_ops nfs_read_partial_ops;
 static const struct rpc_call_ops nfs_read_full_ops;
-static kmem_cache_t *nfs_rdata_cachep;
+static struct kmem_cache *nfs_rdata_cachep;
 static mempool_t *nfs_rdata_mempool;
 #define MIN_POOL_READ   (32)
@@ -46,7 +46,7 @@ static mempool_t *nfs_rdata_mempool;
 struct nfs_read_data *nfs_readdata_alloc(size_t len)
 {
        unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, SLAB_NOFS);
+        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, GFP_NOFS);
        if (p) {
                memset(p, 0, sizeof(*p));
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 883dd4a1c157..41b07288f99e 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -85,7 +85,7 @@ static const struct rpc_call_ops nfs_write_partial_ops;
 static const struct rpc_call_ops nfs_write_full_ops;
 static const struct rpc_call_ops nfs_commit_ops;
-static kmem_cache_t *nfs_wdata_cachep;
+static struct kmem_cache *nfs_wdata_cachep;
 static mempool_t *nfs_wdata_mempool;
 static mempool_t *nfs_commit_mempool;
@@ -93,7 +93,7 @@ static DECLARE_WAIT_QUEUE_HEAD(nfs_write_congestion);
 struct nfs_write_data *nfs_commit_alloc(void)
 {
-        struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, SLAB_NOFS);
+        struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOFS);
        if (p) {
                memset(p, 0, sizeof(*p));
@@ -112,7 +112,7 @@ void nfs_commit_free(struct nfs_write_data *p)
 struct nfs_write_data *nfs_writedata_alloc(size_t len)
 {
        unsigned int pagecount = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, SLAB_NOFS);
+        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, GFP_NOFS);
        if (p) {
                memset(p, 0, sizeof(*p));
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index b4baca3053c3..277df40f098d 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -24,10 +24,6 @@
 #define NFSDDBG_FACILITY                NFSDDBG_XDR
-#ifdef NFSD_OPTIMIZE_SPACE
-# define inline
-#endif
 /*
 * Mapping of S_IF* types to NFS file types
@@ -42,14 +38,14 @@ static u32	nfs3_ftypes[] = {
 /*
 * XDR functions for basic NFS types
 */
-static inline __be32 *
+static __be32 *
 encode_time3(__be32 *p, struct timespec *time)
 {
        *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
        return p;
 }
-static inline __be32 *
+static __be32 *
 decode_time3(__be32 *p, struct timespec *time)
 {
        time->tv_sec = ntohl(*p++);
@@ -57,7 +53,7 @@ decode_time3(__be32 *p, struct timespec *time)
        return p;
 }
-static inline __be32 *
+static __be32 *
 decode_fh(__be32 *p, struct svc_fh *fhp)
 {
        unsigned int size;
@@ -77,7 +73,7 @@ __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
        return decode_fh(p, fhp);
 }
-static inline __be32 *
+static __be32 *
 encode_fh(__be32 *p, struct svc_fh *fhp)
 {
        unsigned int size = fhp->fh_handle.fh_size;
@@ -91,7 +87,7 @@ encode_fh(__be32 *p, struct svc_fh *fhp)
 * Decode a file name and make sure that the path contains
 * no slashes or null bytes.
 */
-static inline __be32 *
+static __be32 *
 decode_filename(__be32 *p, char **namp, int *lenp)
 {
        char            *name;
@@ -107,7 +103,7 @@ decode_filename(__be32 *p, char **namp, int *lenp)
        return p;
 }
-static inline __be32 *
+static __be32 *
 decode_sattr3(__be32 *p, struct iattr *iap)
 {
        u32     tmp;
@@ -153,7 +149,7 @@ decode_sattr3(__be32 *p, struct iattr *iap)
        return p;
 }
-static inline __be32 *
+static __be32 *
 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
              struct kstat *stat)
 {
@@ -186,7 +182,7 @@ encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
        return p;
 }
-static inline __be32 *
+static __be32 *
 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
        struct inode    *inode = fhp->fh_dentry->d_inode;
@@ -776,7 +772,7 @@ nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
                return xdr_ressize_check(rqstp, p);
 }
-static inline __be32 *
+static __be32 *
 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
             int namlen, ino_t ino)
 {
@@ -790,7 +786,7 @@ encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
        return p;
 }
-static inline __be32 *
+static __be32 *
 encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p,
                struct svc_fh *fhp)
 {
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 293b6495829f..640c92b2a9f7 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -84,10 +84,10 @@ static void nfs4_set_recdir(char *recdir);
 */
 static DEFINE_MUTEX(client_mutex);
-static kmem_cache_t *stateowner_slab = NULL;
+static struct kmem_cache *stateowner_slab = NULL;
-static kmem_cache_t *file_slab = NULL;
+static struct kmem_cache *file_slab = NULL;
-static kmem_cache_t *stateid_slab = NULL;
+static struct kmem_cache *stateid_slab = NULL;
-static kmem_cache_t *deleg_slab = NULL;
+static struct kmem_cache *deleg_slab = NULL;
 void
 nfs4_lock_state(void)
@@ -1003,7 +1003,7 @@ alloc_init_file(struct inode *ino)
 }
 static void
-nfsd4_free_slab(kmem_cache_t **slab)
+nfsd4_free_slab(struct kmem_cache **slab)
 {
        if (*slab == NULL)
                return;
@@ -1829,9 +1829,8 @@ out:
 }
 static struct workqueue_struct *laundry_wq;
-static struct work_struct laundromat_work;
+static void laundromat_main(struct work_struct *);
-static void laundromat_main(void *);
+static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
-static DECLARE_WORK(laundromat_work, laundromat_main, NULL);
 __be32
 nfsd4_renew(clientid_t *clid)
@@ -1940,7 +1939,7 @@ nfs4_laundromat(void)
 }
 void
-laundromat_main(void *not_used)
+laundromat_main(struct work_struct *not_used)
 {
        time_t t;
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 56ebb1443e0e..f5243f943996 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -18,11 +18,6 @@
 #define NFSDDBG_FACILITY                NFSDDBG_XDR
-#ifdef NFSD_OPTIMIZE_SPACE
-# define inline
-#endif
 /*
 * Mapping of S_IF* types to NFS file types
 */
@@ -55,7 +50,7 @@ __be32 *nfs2svc_decode_fh(__be32 *p, struct svc_fh *fhp)
        return decode_fh(p, fhp);
 }
-static inline __be32 *
+static __be32 *
 encode_fh(__be32 *p, struct svc_fh *fhp)
 {
        memcpy(p, &fhp->fh_handle.fh_base, NFS_FHSIZE);
@@ -66,7 +61,7 @@ encode_fh(__be32 *p, struct svc_fh *fhp)
 * Decode a file name and make sure that the path contains
 * no slashes or null bytes.
 */
-static inline __be32 *
+static __be32 *
 decode_filename(__be32 *p, char **namp, int *lenp)
 {
        char            *name;
@@ -82,7 +77,7 @@ decode_filename(__be32 *p, char **namp, int *lenp)
        return p;
 }
-static inline __be32 *
+static __be32 *
 decode_pathname(__be32 *p, char **namp, int *lenp)
 {
        char            *name;
@@ -98,7 +93,7 @@ decode_pathname(__be32 *p, char **namp, int *lenp)
        return p;
 }
-static inline __be32 *
+static __be32 *
 decode_sattr(__be32 *p, struct iattr *iap)
 {
        u32     tmp, tmp1;
diff --git a/fs/nls/nls_cp936.c b/fs/nls/nls_cp936.c
index 046fde8170ea..65e640c61c8b 100644
--- a/fs/nls/nls_cp936.c
+++ b/fs/nls/nls_cp936.c
@@ -4421,6 +4421,73 @@ static wchar_t *page_charset2uni[256] = {
        c2u_F8, c2u_F9, c2u_FA, c2u_FB, c2u_FC, c2u_FD, c2u_FE, NULL,   
 };
+static unsigned char u2c_00[512] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00-0x03 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x04-0x07 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x08-0x0B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x0C-0x0F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x10-0x13 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x14-0x17 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x18-0x1B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x1C-0x1F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x20-0x23 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x24-0x27 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x28-0x2B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2C-0x2F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x30-0x33 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x34-0x37 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x38-0x3B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x3C-0x3F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x40-0x43 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x44-0x47 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x48-0x4B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x4C-0x4F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x50-0x53 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x54-0x57 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x58-0x5B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x5C-0x5F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x60-0x63 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x64-0x67 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x68-0x6B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x6C-0x6F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x70-0x73 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x74-0x77 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x78-0x7B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x7C-0x7F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x80-0x83 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x84-0x87 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x88-0x8B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x8C-0x8F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x90-0x93 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x94-0x97 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x98-0x9B */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9C-0x9F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xA0-0xA3 */
+        0xA1, 0xE8, 0x00, 0x00, 0x00, 0x00, 0xA1, 0xEC, /* 0xA4-0xA7 */
+        0xA1, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xA8-0xAB */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xAC-0xAF */
+        0xA1, 0xE3, 0xA1, 0xC0, 0x00, 0x00, 0x00, 0x00, /* 0xB0-0xB3 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA1, 0xA4, /* 0xB4-0xB7 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xB8-0xBB */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xBC-0xBF */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xC0-0xC3 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xC4-0xC7 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xC8-0xCB */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xCC-0xCF */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xD0-0xD3 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA1, 0xC1, /* 0xD4-0xD7 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xD8-0xDB */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xDC-0xDF */
+        0xA8, 0xA4, 0xA8, 0xA2, 0x00, 0x00, 0x00, 0x00, /* 0xE0-0xE3 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xE4-0xE7 */
+        0xA8, 0xA8, 0xA8, 0xA6, 0xA8, 0xBA, 0x00, 0x00, /* 0xE8-0xEB */
+        0xA8, 0xAC, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, /* 0xEC-0xEF */
+        0x00, 0x00, 0x00, 0x00, 0xA8, 0xB0, 0xA8, 0xAE, /* 0xF0-0xF3 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA1, 0xC2, /* 0xF4-0xF7 */
+        0x00, 0x00, 0xA8, 0xB4, 0xA8, 0xB2, 0x00, 0x00, /* 0xF8-0xFB */
+        0xA8, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xFC-0xFF */
+};
 static unsigned char u2c_01[512] = {
        0xA8, 0xA1, 0xA8, 0xA1, 0x00, 0x00, 0x00, 0x00, /* 0x00-0x03 */
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x04-0x07 */
@@ -10825,7 +10892,7 @@ static unsigned char u2c_FF[512] = {
 };
 static unsigned char *page_uni2charset[256] = {
-        NULL,   u2c_01, u2c_02, u2c_03, u2c_04, NULL,   NULL,   NULL,   
+        u2c_00, u2c_01, u2c_02, u2c_03, u2c_04, NULL,   NULL,   NULL,
        NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   
        NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   
        NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   
@@ -10936,11 +11003,34 @@ static int uni2char(const wchar_t uni,
        unsigned char *uni2charset;
        unsigned char cl = uni&0xFF;
        unsigned char ch = (uni>>8)&0xFF;
-        int n;
+        unsigned char out0,out1;
        if (boundlen <= 0)
                return -ENAMETOOLONG;
+        if (uni == 0x20ac) {/* Euro symbol.The only exception with a non-ascii unicode */
+                out[0] = 0x80;
+                return 1;
+        }
+        if (ch == 0) { /* handle the U00 plane*/
+                /* if (cl == 0) return -EINVAL;*/ /*U0000 is legal in cp936*/
+                out0 = u2c_00[cl*2];
+                out1 = u2c_00[cl*2+1];
+                if (out0 == 0x00 && out1 == 0x00) {
+                        if (cl<0x80) {
+                                out[0] = cl;
+                                return 1;
+                        }
+                        return -EINVAL;
+                } else {
+                        if (boundlen <= 1)
+                                return -ENAMETOOLONG;
+                        out[0] = out0;
+                        out[1] = out1;
+                        return 2;
+                }
+        }
        uni2charset = page_uni2charset[ch];
        if (uni2charset) {
@@ -10950,15 +11040,10 @@ static int uni2char(const wchar_t uni,
                out[1] = uni2charset[cl*2+1];
                if (out[0] == 0x00 && out[1] == 0x00)
                        return -EINVAL;
-                n = 2;
+                return 2;
-        } else if (ch==0 && cl) {
-                out[0] = cl;
-                n = 1;
        }
        else
                return -EINVAL;
-        return n;
 }
 static int char2uni(const unsigned char *rawstring, int boundlen,
@@ -10972,7 +11057,11 @@ static int char2uni(const unsigned char *rawstring, int boundlen,
                return -ENAMETOOLONG;
        if (boundlen == 1) {
-                *uni = rawstring[0];
+                if (rawstring[0]==0x80) { /* Euro symbol.The only exception with a non-ascii unicode */
+                        *uni = 0x20ac;
+                } else {
+                        *uni = rawstring[0];
+                }
                return 1;
        }
@@ -10986,7 +11075,11 @@ static int char2uni(const unsigned char *rawstring, int boundlen,
                        return -EINVAL;
                n = 2;
        } else{
-                *uni = ch;
+                if (ch==0x80) {/* Euro symbol.The only exception with a non-ascii unicode */
+                        *uni = 0x20ac;
+                } else {
+                        *uni = ch;
+                }
                n = 1;
        }
        return n;
diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
index 9f08e851cfb6..c577d8e1bd95 100644
--- a/fs/ntfs/attrib.c
+++ b/fs/ntfs/attrib.c
@@ -1272,7 +1272,7 @@ ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni, MFT_RECORD *mrec)
 {
        ntfs_attr_search_ctx *ctx;
-        ctx = kmem_cache_alloc(ntfs_attr_ctx_cache, SLAB_NOFS);
+        ctx = kmem_cache_alloc(ntfs_attr_ctx_cache, GFP_NOFS);
        if (ctx)
                ntfs_attr_init_search_ctx(ctx, ni, mrec);
        return ctx;
diff --git a/fs/ntfs/index.c b/fs/ntfs/index.c
index e32cde486362..2194eff49743 100644
--- a/fs/ntfs/index.c
+++ b/fs/ntfs/index.c
@@ -38,7 +38,7 @@ ntfs_index_context *ntfs_index_ctx_get(ntfs_inode *idx_ni)
 {
        ntfs_index_context *ictx;
-        ictx = kmem_cache_alloc(ntfs_index_ctx_cache, SLAB_NOFS);
+        ictx = kmem_cache_alloc(ntfs_index_ctx_cache, GFP_NOFS);
        if (ictx)
                *ictx = (ntfs_index_context){ .idx_ni = idx_ni };
        return ictx;
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 2d3de9c89818..247989891b4b 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -324,7 +324,7 @@ struct inode *ntfs_alloc_big_inode(struct super_block *sb)
        ntfs_inode *ni;
        ntfs_debug("Entering.");
-        ni = kmem_cache_alloc(ntfs_big_inode_cache, SLAB_NOFS);
+        ni = kmem_cache_alloc(ntfs_big_inode_cache, GFP_NOFS);
        if (likely(ni != NULL)) {
                ni->state = 0;
                return VFS_I(ni);
@@ -349,7 +349,7 @@ static inline ntfs_inode *ntfs_alloc_extent_inode(void)
        ntfs_inode *ni;
        ntfs_debug("Entering.");
-        ni = kmem_cache_alloc(ntfs_inode_cache, SLAB_NOFS);
+        ni = kmem_cache_alloc(ntfs_inode_cache, GFP_NOFS);
        if (likely(ni != NULL)) {
                ni->state = 0;
                return ni;
diff --git a/fs/ntfs/unistr.c b/fs/ntfs/unistr.c
index 6a495f7369f9..005ca4b0f132 100644
--- a/fs/ntfs/unistr.c
+++ b/fs/ntfs/unistr.c
@@ -266,7 +266,7 @@ int ntfs_nlstoucs(const ntfs_volume *vol, const char *ins,
        /* We do not trust outside sources. */
        if (likely(ins)) {
-                ucs = kmem_cache_alloc(ntfs_name_cache, SLAB_NOFS);
+                ucs = kmem_cache_alloc(ntfs_name_cache, GFP_NOFS);
                if (likely(ucs)) {
                        for (i = o = 0; i < ins_len; i += wc_len) {
                                wc_len = nls->char2uni(ins + i, ins_len - i,
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index f43bc5f18a35..edc91ca3792a 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -52,14 +52,14 @@ static int ocfs2_extent_contig(struct inode *inode,
                               u64 blkno);
 static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
-                                     struct ocfs2_journal_handle *handle,
+                                     handle_t *handle,
                                     struct inode *inode,
                                     int wanted,
                                     struct ocfs2_alloc_context *meta_ac,
                                     struct buffer_head *bhs[]);
 static int ocfs2_add_branch(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
+                            handle_t *handle,
                            struct inode *inode,
                            struct buffer_head *fe_bh,
                            struct buffer_head *eb_bh,
@@ -67,14 +67,14 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
                            struct ocfs2_alloc_context *meta_ac);
 static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
-                                  struct ocfs2_journal_handle *handle,
+                                  handle_t *handle,
                                  struct inode *inode,
                                  struct buffer_head *fe_bh,
                                  struct ocfs2_alloc_context *meta_ac,
                                  struct buffer_head **ret_new_eb_bh);
 static int ocfs2_do_insert_extent(struct ocfs2_super *osb,
-                                  struct ocfs2_journal_handle *handle,
+                                  handle_t *handle,
                                  struct inode *inode,
                                  struct buffer_head *fe_bh,
                                  u64 blkno,
@@ -152,7 +152,7 @@ bail:
 * l_count for you
 */
 static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
-                                     struct ocfs2_journal_handle *handle,
+                                     handle_t *handle,
                                     struct inode *inode,
                                     int wanted,
                                     struct ocfs2_alloc_context *meta_ac,
@@ -253,7 +253,7 @@ bail:
 * contain a single record with e_clusters == 0.
 */
 static int ocfs2_add_branch(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
+                            handle_t *handle,
                            struct inode *inode,
                            struct buffer_head *fe_bh,
                            struct buffer_head *eb_bh,
@@ -418,7 +418,7 @@ bail:
 * after this call.
 */
 static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
-                                  struct ocfs2_journal_handle *handle,
+                                  handle_t *handle,
                                  struct inode *inode,
                                  struct buffer_head *fe_bh,
                                  struct ocfs2_alloc_context *meta_ac,
@@ -520,7 +520,7 @@ bail:
 * down.
 */
 static int ocfs2_do_insert_extent(struct ocfs2_super *osb,
-                                  struct ocfs2_journal_handle *handle,
+                                  handle_t *handle,
                                  struct inode *inode,
                                  struct buffer_head *fe_bh,
                                  u64 start_blk,
@@ -809,7 +809,7 @@ bail:
 /* the caller needs to update fe->i_clusters */
 int ocfs2_insert_extent(struct ocfs2_super *osb,
-                        struct ocfs2_journal_handle *handle,
+                        handle_t *handle,
                        struct inode *inode,
                        struct buffer_head *fe_bh,
                        u64 start_blk,
@@ -951,7 +951,7 @@ static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
 }
 static int ocfs2_truncate_log_append(struct ocfs2_super *osb,
-                                     struct ocfs2_journal_handle *handle,
+                                     handle_t *handle,
                                     u64 start_blk,
                                     unsigned int num_clusters)
 {
@@ -1034,7 +1034,7 @@ bail:
 }
 static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
-                                         struct ocfs2_journal_handle *handle,
+                                         handle_t *handle,
                                         struct inode *data_alloc_inode,
                                         struct buffer_head *data_alloc_bh)
 {
@@ -1113,7 +1113,7 @@ static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
 {
        int status;
        unsigned int num_to_flush;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle;
        struct inode *tl_inode = osb->osb_tl_inode;
        struct inode *data_alloc_inode = NULL;
        struct buffer_head *tl_bh = osb->osb_tl_bh;
@@ -1130,7 +1130,7 @@ static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
        if (!OCFS2_IS_VALID_DINODE(di)) {
                OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
                status = -EIO;
-                goto bail;
+                goto out;
        }
        num_to_flush = le16_to_cpu(tl->tl_used);
@@ -1138,14 +1138,7 @@ static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
             num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno);
        if (!num_to_flush) {
                status = 0;
-                goto bail;
+                goto out;
-        }
-        handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
        }
        data_alloc_inode = ocfs2_get_system_file_inode(osb,
@@ -1154,41 +1147,40 @@ static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
        if (!data_alloc_inode) {
                status = -EINVAL;
                mlog(ML_ERROR, "Could not get bitmap inode!\n");
-                goto bail;
+                goto out;
        }
-        ocfs2_handle_add_inode(handle, data_alloc_inode);
+        mutex_lock(&data_alloc_inode->i_mutex);
-        status = ocfs2_meta_lock(data_alloc_inode, handle, &data_alloc_bh, 1);
+        status = ocfs2_meta_lock(data_alloc_inode, &data_alloc_bh, 1);
        if (status < 0) {
                mlog_errno(status);
-                goto bail;
+                goto out_mutex;
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_TRUNCATE_LOG_UPDATE);
+        handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
-                handle = NULL;
                mlog_errno(status);
-                goto bail;
+                goto out_unlock;
        }
        status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
                                               data_alloc_bh);
-        if (status < 0) {
+        if (status < 0)
                mlog_errno(status);
-                goto bail;
-        }
-bail:
+        ocfs2_commit_trans(osb, handle);
-        if (handle)
-                ocfs2_commit_trans(handle);
-        if (data_alloc_inode)
+out_unlock:
-                iput(data_alloc_inode);
+        brelse(data_alloc_bh);
+        ocfs2_meta_unlock(data_alloc_inode, 1);
-        if (data_alloc_bh)
+out_mutex:
-                brelse(data_alloc_bh);
+        mutex_unlock(&data_alloc_inode->i_mutex);
+        iput(data_alloc_inode);
+out:
        mlog_exit(status);
        return status;
 }
@@ -1205,10 +1197,12 @@ int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
        return status;
 }
-static void ocfs2_truncate_log_worker(void *data)
+static void ocfs2_truncate_log_worker(struct work_struct *work)
 {
        int status;
-        struct ocfs2_super *osb = data;
+        struct ocfs2_super *osb =
+                container_of(work, struct ocfs2_super,
+                             osb_truncate_log_wq.work);
        mlog_entry_void();
@@ -1347,7 +1341,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
        int i;
        unsigned int clusters, num_recs, start_cluster;
        u64 start_blk;
-        struct ocfs2_journal_handle *handle;
+        handle_t *handle;
        struct inode *tl_inode = osb->osb_tl_inode;
        struct ocfs2_truncate_log *tl;
@@ -1373,8 +1367,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
                        }
                }
-                handle = ocfs2_start_trans(osb, NULL,
+                handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
-                                           OCFS2_TRUNCATE_LOG_UPDATE);
                if (IS_ERR(handle)) {
                        status = PTR_ERR(handle);
                        mlog_errno(status);
@@ -1387,7 +1380,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
                status = ocfs2_truncate_log_append(osb, handle,
                                                   start_blk, clusters);
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail_up;
@@ -1441,7 +1434,8 @@ int ocfs2_truncate_log_init(struct ocfs2_super *osb)
        /* ocfs2_truncate_log_shutdown keys on the existence of
         * osb->osb_tl_inode so we don't set any of the osb variables
         * until we're sure all is well. */
-        INIT_WORK(&osb->osb_truncate_log_wq, ocfs2_truncate_log_worker, osb);
+        INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
+                          ocfs2_truncate_log_worker);
        osb->osb_tl_bh    = tl_bh;
        osb->osb_tl_inode = tl_inode;
@@ -1543,7 +1537,7 @@ static int ocfs2_do_truncate(struct ocfs2_super *osb,
                             struct inode *inode,
                             struct buffer_head *fe_bh,
                             struct buffer_head *old_last_eb_bh,
-                             struct ocfs2_journal_handle *handle,
+                             handle_t *handle,
                             struct ocfs2_truncate_context *tc)
 {
        int status, i, depth;
@@ -1782,7 +1776,7 @@ int ocfs2_commit_truncate(struct ocfs2_super *osb,
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list *el;
        struct buffer_head *last_eb_bh;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct inode *tl_inode = osb->osb_tl_inode;
        mlog_entry_void();
@@ -1868,7 +1862,7 @@ start:
        credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del,
                                                fe, el);
-        handle = ocfs2_start_trans(osb, NULL, credits);
+        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -1891,7 +1885,7 @@ start:
        mutex_unlock(&tl_inode->i_mutex);
        tl_sem = 0;
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
        handle = NULL;
        BUG_ON(le32_to_cpu(fe->i_clusters) < target_i_clusters);
@@ -1906,7 +1900,7 @@ bail:
                mutex_unlock(&tl_inode->i_mutex);
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
        if (last_eb_bh)
                brelse(last_eb_bh);
@@ -2011,10 +2005,7 @@ int ocfs2_prepare_truncate(struct ocfs2_super *osb,
                mutex_lock(&ext_alloc_inode->i_mutex);
                (*tc)->tc_ext_alloc_inode = ext_alloc_inode;
-                status = ocfs2_meta_lock(ext_alloc_inode,
+                status = ocfs2_meta_lock(ext_alloc_inode, &ext_alloc_bh, 1);
-                                         NULL,
-                                         &ext_alloc_bh,
-                                         1);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
diff --git a/fs/ocfs2/alloc.h b/fs/ocfs2/alloc.h
index 12ba897743f4..0b82e8044325 100644
--- a/fs/ocfs2/alloc.h
+++ b/fs/ocfs2/alloc.h
@@ -28,7 +28,7 @@
 struct ocfs2_alloc_context;
 int ocfs2_insert_extent(struct ocfs2_super *osb,
-                        struct ocfs2_journal_handle *handle,
+                        handle_t *handle,
                        struct inode *inode,
                        struct buffer_head *fe_bh,
                        u64 blkno,
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 3d7c082a8f58..2f7268e81520 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -200,7 +200,7 @@ static int ocfs2_readpage(struct file *file, struct page *page)
        mlog_entry("(0x%p, %lu)\n", file, (page ? page->index : 0));
-        ret = ocfs2_meta_lock_with_page(inode, NULL, NULL, 0, page);
+        ret = ocfs2_meta_lock_with_page(inode, NULL, 0, page);
        if (ret != 0) {
                if (ret == AOP_TRUNCATED_PAGE)
                        unlock = 0;
@@ -305,7 +305,7 @@ static int ocfs2_prepare_write(struct file *file, struct page *page,
        mlog_entry("(0x%p, 0x%p, %u, %u)\n", file, page, from, to);
-        ret = ocfs2_meta_lock_with_page(inode, NULL, NULL, 0, page);
+        ret = ocfs2_meta_lock_with_page(inode, NULL, 0, page);
        if (ret != 0) {
                mlog_errno(ret);
                goto out;
@@ -355,16 +355,16 @@ static int walk_page_buffers(	handle_t *handle,
        return ret;
 }
-struct ocfs2_journal_handle *ocfs2_start_walk_page_trans(struct inode *inode,
+handle_t *ocfs2_start_walk_page_trans(struct inode *inode,
                                                         struct page *page,
                                                         unsigned from,
                                                         unsigned to)
 {
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        int ret = 0;
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (!handle) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -372,7 +372,7 @@ struct ocfs2_journal_handle *ocfs2_start_walk_page_trans(struct inode *inode,
        }
        if (ocfs2_should_order_data(inode)) {
-                ret = walk_page_buffers(handle->k_handle,
+                ret = walk_page_buffers(handle,
                                        page_buffers(page),
                                        from, to, NULL,
                                        ocfs2_journal_dirty_data);
@@ -382,7 +382,7 @@ struct ocfs2_journal_handle *ocfs2_start_walk_page_trans(struct inode *inode,
 out:
        if (ret) {
                if (handle)
-                        ocfs2_commit_trans(handle);
+                        ocfs2_commit_trans(osb, handle);
                handle = ERR_PTR(ret);
        }
        return handle;
@@ -394,7 +394,7 @@ static int ocfs2_commit_write(struct file *file, struct page *page,
        int ret;
        struct buffer_head *di_bh = NULL;
        struct inode *inode = page->mapping->host;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_dinode *di;
        mlog_entry("(0x%p, 0x%p, %u, %u)\n", file, page, from, to);
@@ -412,7 +412,7 @@ static int ocfs2_commit_write(struct file *file, struct page *page,
         *    stale inode allocation image (i_size, i_clusters, etc).
         */
-        ret = ocfs2_meta_lock_with_page(inode, NULL, &di_bh, 1, page);
+        ret = ocfs2_meta_lock_with_page(inode, &di_bh, 1, page);
        if (ret != 0) {
                mlog_errno(ret);
                goto out;
@@ -464,7 +464,7 @@ static int ocfs2_commit_write(struct file *file, struct page *page,
        }
 out_commit:
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out_unlock_data:
        ocfs2_data_unlock(inode, 1);
 out_unlock_meta:
@@ -490,7 +490,7 @@ static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
         * accessed concurrently from multiple nodes.
         */
        if (!INODE_JOURNAL(inode)) {
-                err = ocfs2_meta_lock(inode, NULL, NULL, 0);
+                err = ocfs2_meta_lock(inode, NULL, 0);
                if (err) {
                        if (err != -ENOENT)
                                mlog_errno(err);
diff --git a/fs/ocfs2/aops.h b/fs/ocfs2/aops.h
index e88c3f0b8fa9..f446a15eab88 100644
--- a/fs/ocfs2/aops.h
+++ b/fs/ocfs2/aops.h
@@ -25,7 +25,7 @@
 int ocfs2_prepare_write_nolock(struct inode *inode, struct page *page,
                               unsigned from, unsigned to);
-struct ocfs2_journal_handle *ocfs2_start_walk_page_trans(struct inode *inode,
+handle_t *ocfs2_start_walk_page_trans(struct inode *inode,
                                                         struct page *page,
                                                         unsigned from,
                                                         unsigned to);
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 305cba3681fe..4cd9a9580456 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -141,7 +141,7 @@ struct o2hb_region {
         * recognizes a node going up and down in one iteration */
        u64                     hr_generation;
-        struct work_struct      hr_write_timeout_work;
+        struct delayed_work     hr_write_timeout_work;
        unsigned long           hr_last_timeout_start;
        /* Used during o2hb_check_slot to hold a copy of the block
@@ -156,9 +156,11 @@ struct o2hb_bio_wait_ctxt {
        int               wc_error;
 };
-static void o2hb_write_timeout(void *arg)
+static void o2hb_write_timeout(struct work_struct *work)
 {
-        struct o2hb_region *reg = arg;
+        struct o2hb_region *reg =
+                container_of(work, struct o2hb_region,
+                             hr_write_timeout_work.work);
        mlog(ML_ERROR, "Heartbeat write timeout to device %s after %u "
             "milliseconds\n", reg->hr_dev_name,
@@ -1404,7 +1406,7 @@ static ssize_t o2hb_region_dev_write(struct o2hb_region *reg,
                goto out;
        }
-        INIT_WORK(&reg->hr_write_timeout_work, o2hb_write_timeout, reg);
+        INIT_DELAYED_WORK(&reg->hr_write_timeout_work, o2hb_write_timeout);
        /*
         * A node is considered live after it has beat LIVE_THRESHOLD
diff --git a/fs/ocfs2/cluster/quorum.c b/fs/ocfs2/cluster/quorum.c
index 7bba98fbfc15..4705d659fe57 100644
--- a/fs/ocfs2/cluster/quorum.c
+++ b/fs/ocfs2/cluster/quorum.c
@@ -88,7 +88,7 @@ void o2quo_disk_timeout(void)
        o2quo_fence_self();
 }
-static void o2quo_make_decision(void *arg)
+static void o2quo_make_decision(struct work_struct *work)
 {
        int quorum;
        int lowest_hb, lowest_reachable = 0, fence = 0;
@@ -306,7 +306,7 @@ void o2quo_init(void)
        struct o2quo_state *qs = &o2quo_state;
        spin_lock_init(&qs->qs_lock);
-        INIT_WORK(&qs->qs_work, o2quo_make_decision, NULL);
+        INIT_WORK(&qs->qs_work, o2quo_make_decision);
 }
 void o2quo_exit(void)
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index b650efa8c8be..9b3209dc0b16 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -140,11 +140,11 @@ static int o2net_sys_err_translations[O2NET_ERR_MAX] =
                 [O2NET_ERR_DIED]       = -EHOSTDOWN,};
 /* can't quite avoid *all* internal declarations :/ */
-static void o2net_sc_connect_completed(void *arg);
+static void o2net_sc_connect_completed(struct work_struct *work);
-static void o2net_rx_until_empty(void *arg);
+static void o2net_rx_until_empty(struct work_struct *work);
-static void o2net_shutdown_sc(void *arg);
+static void o2net_shutdown_sc(struct work_struct *work);
 static void o2net_listen_data_ready(struct sock *sk, int bytes);
-static void o2net_sc_send_keep_req(void *arg);
+static void o2net_sc_send_keep_req(struct work_struct *work);
 static void o2net_idle_timer(unsigned long data);
 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
@@ -308,10 +308,10 @@ static struct o2net_sock_container *sc_alloc(struct o2nm_node *node)
        o2nm_node_get(node);
        sc->sc_node = node;
-        INIT_WORK(&sc->sc_connect_work, o2net_sc_connect_completed, sc);
+        INIT_WORK(&sc->sc_connect_work, o2net_sc_connect_completed);
-        INIT_WORK(&sc->sc_rx_work, o2net_rx_until_empty, sc);
+        INIT_WORK(&sc->sc_rx_work, o2net_rx_until_empty);
-        INIT_WORK(&sc->sc_shutdown_work, o2net_shutdown_sc, sc);
+        INIT_WORK(&sc->sc_shutdown_work, o2net_shutdown_sc);
-        INIT_WORK(&sc->sc_keepalive_work, o2net_sc_send_keep_req, sc);
+        INIT_DELAYED_WORK(&sc->sc_keepalive_work, o2net_sc_send_keep_req);
        init_timer(&sc->sc_idle_timeout);
        sc->sc_idle_timeout.function = o2net_idle_timer;
@@ -342,7 +342,7 @@ static void o2net_sc_queue_work(struct o2net_sock_container *sc,
                sc_put(sc);
 }
 static void o2net_sc_queue_delayed_work(struct o2net_sock_container *sc,
-                                        struct work_struct *work,
+                                        struct delayed_work *work,
                                        int delay)
 {
        sc_get(sc);
@@ -350,7 +350,7 @@ static void o2net_sc_queue_delayed_work(struct o2net_sock_container *sc,
                sc_put(sc);
 }
 static void o2net_sc_cancel_delayed_work(struct o2net_sock_container *sc,
-                                         struct work_struct *work)
+                                         struct delayed_work *work)
 {
        if (cancel_delayed_work(work))
                sc_put(sc);
@@ -564,9 +564,11 @@ static void o2net_ensure_shutdown(struct o2net_node *nn,
 * ourselves as state_change couldn't get the nn_lock and call set_nn_state
 * itself.
 */
-static void o2net_shutdown_sc(void *arg)
+static void o2net_shutdown_sc(struct work_struct *work)
 {
-        struct o2net_sock_container *sc = arg;
+        struct o2net_sock_container *sc =
+                container_of(work, struct o2net_sock_container,
+                             sc_shutdown_work);
        struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num);
        sclog(sc, "shutting down\n");
@@ -1201,9 +1203,10 @@ out:
 /* this work func is triggerd by data ready.  it reads until it can read no
 * more.  it interprets 0, eof, as fatal.  if data_ready hits while we're doing
 * our work the work struct will be marked and we'll be called again. */
-static void o2net_rx_until_empty(void *arg)
+static void o2net_rx_until_empty(struct work_struct *work)
 {
-        struct o2net_sock_container *sc = arg;
+        struct o2net_sock_container *sc =
+                container_of(work, struct o2net_sock_container, sc_rx_work);
        int ret;
        do {
@@ -1249,9 +1252,11 @@ static int o2net_set_nodelay(struct socket *sock)
 /* called when a connect completes and after a sock is accepted.  the
 * rx path will see the response and mark the sc valid */
-static void o2net_sc_connect_completed(void *arg)
+static void o2net_sc_connect_completed(struct work_struct *work)
 {
-        struct o2net_sock_container *sc = arg;
+        struct o2net_sock_container *sc =
+                container_of(work, struct o2net_sock_container,
+                             sc_connect_work);
        mlog(ML_MSG, "sc sending handshake with ver %llu id %llx\n",
              (unsigned long long)O2NET_PROTOCOL_VERSION,
@@ -1262,9 +1267,11 @@ static void o2net_sc_connect_completed(void *arg)
 }
 /* this is called as a work_struct func. */
-static void o2net_sc_send_keep_req(void *arg)
+static void o2net_sc_send_keep_req(struct work_struct *work)
 {
-        struct o2net_sock_container *sc = arg;
+        struct o2net_sock_container *sc =
+                container_of(work, struct o2net_sock_container,
+                             sc_keepalive_work.work);
        o2net_sendpage(sc, o2net_keep_req, sizeof(*o2net_keep_req));
        sc_put(sc);
@@ -1314,14 +1321,15 @@ static void o2net_sc_postpone_idle(struct o2net_sock_container *sc)
 * having a connect attempt fail, etc. This centralizes the logic which decides
 * if a connect attempt should be made or if we should give up and all future
 * transmit attempts should fail */
-static void o2net_start_connect(void *arg)
+static void o2net_start_connect(struct work_struct *work)
 {
-        struct o2net_node *nn = arg;
+        struct o2net_node *nn =
+                container_of(work, struct o2net_node, nn_connect_work.work);
        struct o2net_sock_container *sc = NULL;
        struct o2nm_node *node = NULL, *mynode = NULL;
        struct socket *sock = NULL;
        struct sockaddr_in myaddr = {0, }, remoteaddr = {0, };
-        int ret = 0;
+        int ret = 0, stop;
        /* if we're greater we initiate tx, otherwise we accept */
        if (o2nm_this_node() <= o2net_num_from_nn(nn))
@@ -1342,10 +1350,9 @@ static void o2net_start_connect(void *arg)
        spin_lock(&nn->nn_lock);
        /* see if we already have one pending or have given up */
-        if (nn->nn_sc || nn->nn_persistent_error)
+        stop = (nn->nn_sc || nn->nn_persistent_error);
-                arg = NULL;
        spin_unlock(&nn->nn_lock);
-        if (arg == NULL) /* *shrug*, needed some indicator */
+        if (stop)
                goto out;
        nn->nn_last_connect_attempt = jiffies;
@@ -1421,9 +1428,10 @@ out:
        return;
 }
-static void o2net_connect_expired(void *arg)
+static void o2net_connect_expired(struct work_struct *work)
 {
-        struct o2net_node *nn = arg;
+        struct o2net_node *nn =
+                container_of(work, struct o2net_node, nn_connect_expired.work);
        spin_lock(&nn->nn_lock);
        if (!nn->nn_sc_valid) {
@@ -1436,9 +1444,10 @@ static void o2net_connect_expired(void *arg)
        spin_unlock(&nn->nn_lock);
 }
-static void o2net_still_up(void *arg)
+static void o2net_still_up(struct work_struct *work)
 {
-        struct o2net_node *nn = arg;
+        struct o2net_node *nn =
+                container_of(work, struct o2net_node, nn_still_up.work);
        o2quo_hb_still_up(o2net_num_from_nn(nn));
 }
@@ -1644,9 +1653,9 @@ out:
        return ret;
 }
-static void o2net_accept_many(void *arg)
+static void o2net_accept_many(struct work_struct *work)
 {
-        struct socket *sock = arg;
+        struct socket *sock = o2net_listen_sock;
        while (o2net_accept_one(sock) == 0)
                cond_resched();
 }
@@ -1700,7 +1709,7 @@ static int o2net_open_listening_sock(__be16 port)
        write_unlock_bh(&sock->sk->sk_callback_lock);
        o2net_listen_sock = sock;
-        INIT_WORK(&o2net_listen_work, o2net_accept_many, sock);
+        INIT_WORK(&o2net_listen_work, o2net_accept_many);
        sock->sk->sk_reuse = 1;
        ret = sock->ops->bind(sock, (struct sockaddr *)&sin, sizeof(sin));
@@ -1819,9 +1828,10 @@ int o2net_init(void)
                struct o2net_node *nn = o2net_nn_from_num(i);
                spin_lock_init(&nn->nn_lock);
-                INIT_WORK(&nn->nn_connect_work, o2net_start_connect, nn);
+                INIT_DELAYED_WORK(&nn->nn_connect_work, o2net_start_connect);
-                INIT_WORK(&nn->nn_connect_expired, o2net_connect_expired, nn);
+                INIT_DELAYED_WORK(&nn->nn_connect_expired,
-                INIT_WORK(&nn->nn_still_up, o2net_still_up, nn);
+                                  o2net_connect_expired);
+                INIT_DELAYED_WORK(&nn->nn_still_up, o2net_still_up);
                /* until we see hb from a node we'll return einval */
                nn->nn_persistent_error = -ENOTCONN;
                init_waitqueue_head(&nn->nn_sc_wq);
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h
index 4b46aac7d243..daebbd3a2c8c 100644
--- a/fs/ocfs2/cluster/tcp_internal.h
+++ b/fs/ocfs2/cluster/tcp_internal.h
@@ -86,18 +86,18 @@ struct o2net_node {
         * connect attempt fails and so can be self-arming.  shutdown is
         * careful to first mark the nn such that no connects will be attempted
         * before canceling delayed connect work and flushing the queue. */
-        struct work_struct              nn_connect_work;
+        struct delayed_work             nn_connect_work;
        unsigned long                   nn_last_connect_attempt;
        /* this is queued as nodes come up and is canceled when a connection is
         * established.  this expiring gives up on the node and errors out
         * transmits */
-        struct work_struct              nn_connect_expired;
+        struct delayed_work             nn_connect_expired;
        /* after we give up on a socket we wait a while before deciding
         * that it is still heartbeating and that we should do some
         * quorum work */
-        struct work_struct              nn_still_up;
+        struct delayed_work             nn_still_up;
 };
 struct o2net_sock_container {
@@ -129,7 +129,7 @@ struct o2net_sock_container {
        struct work_struct      sc_shutdown_work;
        struct timer_list       sc_idle_timeout;
-        struct work_struct      sc_keepalive_work;
+        struct delayed_work     sc_keepalive_work;
        unsigned                sc_handshake_ok:1;
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 04e01915b86e..baad2aa27c14 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -82,6 +82,7 @@ int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
        struct inode *inode = filp->f_dentry->d_inode;
        struct super_block * sb = inode->i_sb;
        unsigned int ra_sectors = 16;
+        int lock_level = 0;
        mlog_entry("dirino=%llu\n",
                   (unsigned long long)OCFS2_I(inode)->ip_blkno);
@@ -89,7 +90,15 @@ int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
        stored = 0;
        bh = NULL;
-        error = ocfs2_meta_lock(inode, NULL, NULL, 0);
+        error = ocfs2_meta_lock_atime(inode, filp->f_vfsmnt, &lock_level);
+        if (lock_level && error >= 0) {
+                /* We release EX lock which used to update atime
+                 * and get PR lock again to reduce contention
+                 * on commonly accessed directories. */
+                ocfs2_meta_unlock(inode, 1);
+                lock_level = 0;
+                error = ocfs2_meta_lock(inode, NULL, 0);
+        }
        if (error < 0) {
                if (error != -ENOENT)
                        mlog_errno(error);
@@ -198,7 +207,7 @@ revalidate:
        stored = 0;
 bail:
-        ocfs2_meta_unlock(inode, 0);
+        ocfs2_meta_unlock(inode, lock_level);
 bail_nolock:
        mlog_exit(stored);
@@ -340,7 +349,7 @@ int ocfs2_empty_dir(struct inode *inode)
 /* returns a bh of the 1st new block in the allocation. */
 int ocfs2_do_extend_dir(struct super_block *sb,
-                        struct ocfs2_journal_handle *handle,
+                        handle_t *handle,
                        struct inode *dir,
                        struct buffer_head *parent_fe_bh,
                        struct ocfs2_alloc_context *data_ac,
@@ -398,7 +407,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
        struct ocfs2_alloc_context *data_ac = NULL;
        struct ocfs2_alloc_context *meta_ac = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct buffer_head *new_bh = NULL;
        struct ocfs2_dir_entry * de;
        struct super_block *sb = osb->sb;
@@ -409,13 +418,6 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        mlog(0, "extending dir %llu (i_size = %lld)\n",
             (unsigned long long)OCFS2_I(dir)->ip_blkno, dir_i_size);
-        handle = ocfs2_alloc_handle(osb);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        /* dir->i_size is always block aligned. */
        spin_lock(&OCFS2_I(dir)->ip_lock);
        if (dir_i_size == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters)) {
@@ -428,8 +430,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                }
                if (!num_free_extents) {
-                        status = ocfs2_reserve_new_metadata(osb, handle,
+                        status = ocfs2_reserve_new_metadata(osb, fe, &meta_ac);
-                                                            fe, &meta_ac);
                        if (status < 0) {
                                if (status != -ENOSPC)
                                        mlog_errno(status);
@@ -437,7 +438,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                        }
                }
-                status = ocfs2_reserve_clusters(osb, handle, 1, &data_ac);
+                status = ocfs2_reserve_clusters(osb, 1, &data_ac);
                if (status < 0) {
                        if (status != -ENOSPC)
                                mlog_errno(status);
@@ -450,7 +451,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
        }
-        handle = ocfs2_start_trans(osb, handle, credits);
+        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -496,7 +497,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        get_bh(*new_de_bh);
 bail:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
        if (data_ac)
                ocfs2_free_alloc_context(data_ac);
diff --git a/fs/ocfs2/dir.h b/fs/ocfs2/dir.h
index 5f614ec9649c..3f67e146864a 100644
--- a/fs/ocfs2/dir.h
+++ b/fs/ocfs2/dir.h
@@ -45,7 +45,7 @@ int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
                                 struct buffer_head **ret_de_bh);
 struct ocfs2_alloc_context;
 int ocfs2_do_extend_dir(struct super_block *sb,
-                        struct ocfs2_journal_handle *handle,
+                        handle_t *handle,
                        struct inode *dir,
                        struct buffer_head *parent_fe_bh,
                        struct ocfs2_alloc_context *data_ac,
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index fa968180b072..6b6ff76538c5 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -153,7 +153,7 @@ static inline struct hlist_head *dlm_lockres_hash(struct dlm_ctxt *dlm, unsigned
 * called functions that cannot be directly called from the
 * net message handlers for some reason, usually because
 * they need to send net messages of their own. */
-void dlm_dispatch_work(void *data);
+void dlm_dispatch_work(struct work_struct *work);
 struct dlm_lock_resource;
 struct dlm_work_item;
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index 8d1065f8b3bd..420a375a3949 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -68,7 +68,8 @@ static void **dlm_alloc_pagevec(int pages)
                        goto out_free;
        mlog(0, "Allocated DLM hash pagevec; %d pages (%lu expected), %lu buckets per page\n",
-             pages, DLM_HASH_PAGES, (unsigned long)DLM_BUCKETS_PER_PAGE);
+             pages, (unsigned long)DLM_HASH_PAGES,
+             (unsigned long)DLM_BUCKETS_PER_PAGE);
        return vec;
 out_free:
        dlm_free_pagevec(vec, i);
@@ -1296,7 +1297,7 @@ static struct dlm_ctxt *dlm_alloc_ctxt(const char *domain,
        spin_lock_init(&dlm->work_lock);
        INIT_LIST_HEAD(&dlm->work_list);
-        INIT_WORK(&dlm->dispatched_work, dlm_dispatch_work, dlm);
+        INIT_WORK(&dlm->dispatched_work, dlm_dispatch_work);
        kref_init(&dlm->dlm_refs);
        dlm->dlm_state = DLM_CTXT_NEW;
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 16b8d1ba7066..941acf14e61f 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -66,7 +66,7 @@ static struct file_operations dlmfs_file_operations;
 static struct inode_operations dlmfs_dir_inode_operations;
 static struct inode_operations dlmfs_root_inode_operations;
 static struct inode_operations dlmfs_file_inode_operations;
-static kmem_cache_t *dlmfs_inode_cache;
+static struct kmem_cache *dlmfs_inode_cache;
 struct workqueue_struct *user_dlm_worker;
@@ -257,7 +257,7 @@ static ssize_t dlmfs_file_write(struct file *filp,
 }
 static void dlmfs_init_once(void *foo,
-                            kmem_cache_t *cachep,
+                            struct kmem_cache *cachep,
                            unsigned long flags)
 {
        struct dlmfs_inode_private *ip =
@@ -276,7 +276,7 @@ static struct inode *dlmfs_alloc_inode(struct super_block *sb)
 {
        struct dlmfs_inode_private *ip;
-        ip = kmem_cache_alloc(dlmfs_inode_cache, SLAB_NOFS);
+        ip = kmem_cache_alloc(dlmfs_inode_cache, GFP_NOFS);
        if (!ip)
                return NULL;
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index f784177b6241..856012b4fa49 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -221,7 +221,7 @@ EXPORT_SYMBOL_GPL(dlm_dump_all_mles);
 #endif  /*  0  */
-static kmem_cache_t *dlm_mle_cache = NULL;
+static struct kmem_cache *dlm_mle_cache = NULL;
 static void dlm_mle_release(struct kref *kref);
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 9d950d7cea38..fb3e2b0817f1 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -153,9 +153,10 @@ static inline void dlm_reset_recovery(struct dlm_ctxt *dlm)
 }
 /* Worker function used during recovery. */
-void dlm_dispatch_work(void *data)
+void dlm_dispatch_work(struct work_struct *work)
 {
-        struct dlm_ctxt *dlm = (struct dlm_ctxt *)data;
+        struct dlm_ctxt *dlm =
+                container_of(work, struct dlm_ctxt, dispatched_work);
        LIST_HEAD(tmp_list);
        struct list_head *iter, *iter2;
        struct dlm_work_item *item;
diff --git a/fs/ocfs2/dlm/userdlm.c b/fs/ocfs2/dlm/userdlm.c
index eead48bbfac6..7d2f578b267d 100644
--- a/fs/ocfs2/dlm/userdlm.c
+++ b/fs/ocfs2/dlm/userdlm.c
@@ -171,15 +171,14 @@ static inline void user_dlm_grab_inode_ref(struct user_lock_res *lockres)
                BUG();
 }
-static void user_dlm_unblock_lock(void *opaque);
+static void user_dlm_unblock_lock(struct work_struct *work);
 static void __user_dlm_queue_lockres(struct user_lock_res *lockres)
 {
        if (!(lockres->l_flags & USER_LOCK_QUEUED)) {
                user_dlm_grab_inode_ref(lockres);
-                INIT_WORK(&lockres->l_work, user_dlm_unblock_lock,
+                INIT_WORK(&lockres->l_work, user_dlm_unblock_lock);
-                          lockres);
                queue_work(user_dlm_worker, &lockres->l_work);
                lockres->l_flags |= USER_LOCK_QUEUED;
@@ -279,10 +278,11 @@ static inline void user_dlm_drop_inode_ref(struct user_lock_res *lockres)
        iput(inode);
 }
-static void user_dlm_unblock_lock(void *opaque)
+static void user_dlm_unblock_lock(struct work_struct *work)
 {
        int new_level, status;
-        struct user_lock_res *lockres = (struct user_lock_res *) opaque;
+        struct user_lock_res *lockres =
+                container_of(work, struct user_lock_res, l_work);
        struct dlm_ctxt *dlm = dlm_ctxt_from_user_lockres(lockres);
        mlog(0, "processing lockres %.*s\n", lockres->l_namelen,
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 8801e41afe80..69fba16efbd1 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -49,6 +49,7 @@
 #include "dcache.h"
 #include "dlmglue.h"
 #include "extent_map.h"
+#include "file.h"
 #include "heartbeat.h"
 #include "inode.h"
 #include "journal.h"
@@ -1063,10 +1064,10 @@ static void ocfs2_cluster_unlock(struct ocfs2_super *osb,
        mlog_exit_void();
 }
-int ocfs2_create_new_lock(struct ocfs2_super *osb,
+static int ocfs2_create_new_lock(struct ocfs2_super *osb,
-                          struct ocfs2_lock_res *lockres,
+                                 struct ocfs2_lock_res *lockres,
-                          int ex,
+                                 int ex,
-                          int local)
+                                 int local)
 {
        int level =  ex ? LKM_EXMODE : LKM_PRMODE;
        unsigned long flags;
@@ -1579,7 +1580,6 @@ static int ocfs2_assign_bh(struct inode *inode,
 * the result of the lock will be communicated via the callback.
 */
 int ocfs2_meta_lock_full(struct inode *inode,
-                         struct ocfs2_journal_handle *handle,
                         struct buffer_head **ret_bh,
                         int ex,
                         int arg_flags)
@@ -1668,12 +1668,6 @@ int ocfs2_meta_lock_full(struct inode *inode,
                }
        }
-        if (handle) {
-                status = ocfs2_handle_add_lock(handle, inode);
-                if (status < 0)
-                        mlog_errno(status);
-        }
 bail:
        if (status < 0) {
                if (ret_bh && (*ret_bh)) {
@@ -1713,18 +1707,16 @@ bail:
 * the lock inversion simply.
 */
 int ocfs2_meta_lock_with_page(struct inode *inode,
-                              struct ocfs2_journal_handle *handle,
                              struct buffer_head **ret_bh,
                              int ex,
                              struct page *page)
 {
        int ret;
-        ret = ocfs2_meta_lock_full(inode, handle, ret_bh, ex,
+        ret = ocfs2_meta_lock_full(inode, ret_bh, ex, OCFS2_LOCK_NONBLOCK);
-                                   OCFS2_LOCK_NONBLOCK);
        if (ret == -EAGAIN) {
                unlock_page(page);
-                if (ocfs2_meta_lock(inode, handle, ret_bh, ex) == 0)
+                if (ocfs2_meta_lock(inode, ret_bh, ex) == 0)
                        ocfs2_meta_unlock(inode, ex);
                ret = AOP_TRUNCATED_PAGE;
        }
@@ -1732,6 +1724,44 @@ int ocfs2_meta_lock_with_page(struct inode *inode,
        return ret;
 }
+int ocfs2_meta_lock_atime(struct inode *inode,
+                          struct vfsmount *vfsmnt,
+                          int *level)
+{
+        int ret;
+        mlog_entry_void();
+        ret = ocfs2_meta_lock(inode, NULL, 0);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        /*
+         * If we should update atime, we will get EX lock,
+         * otherwise we just get PR lock.
+         */
+        if (ocfs2_should_update_atime(inode, vfsmnt)) {
+                struct buffer_head *bh = NULL;
+                ocfs2_meta_unlock(inode, 0);
+                ret = ocfs2_meta_lock(inode, &bh, 1);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        return ret;
+                }
+                *level = 1;
+                if (ocfs2_should_update_atime(inode, vfsmnt))
+                        ocfs2_update_inode_atime(inode, bh);
+                if (bh)
+                        brelse(bh);
+        } else
+                *level = 0;
+        mlog_exit(ret);
+        return ret;
+}
 void ocfs2_meta_unlock(struct inode *inode,
                       int ex)
 {
diff --git a/fs/ocfs2/dlmglue.h b/fs/ocfs2/dlmglue.h
index 4a2769387229..c343fca68cf1 100644
--- a/fs/ocfs2/dlmglue.h
+++ b/fs/ocfs2/dlmglue.h
@@ -68,8 +68,6 @@ void ocfs2_dentry_lock_res_init(struct ocfs2_dentry_lock *dl,
                                u64 parent, struct inode *inode);
 void ocfs2_lock_res_free(struct ocfs2_lock_res *res);
 int ocfs2_create_new_inode_locks(struct inode *inode);
-int ocfs2_create_new_lock(struct ocfs2_super *osb,
-                          struct ocfs2_lock_res *lockres, int ex, int local);
 int ocfs2_drop_inode_locks(struct inode *inode);
 int ocfs2_data_lock_full(struct inode *inode,
                         int write,
@@ -82,19 +80,20 @@ void ocfs2_data_unlock(struct inode *inode,
                       int write);
 int ocfs2_rw_lock(struct inode *inode, int write);
 void ocfs2_rw_unlock(struct inode *inode, int write);
+int ocfs2_meta_lock_atime(struct inode *inode,
+                          struct vfsmount *vfsmnt,
+                          int *level);
 int ocfs2_meta_lock_full(struct inode *inode,
-                         struct ocfs2_journal_handle *handle,
                         struct buffer_head **ret_bh,
                         int ex,
                         int arg_flags);
 int ocfs2_meta_lock_with_page(struct inode *inode,
-                              struct ocfs2_journal_handle *handle,
                              struct buffer_head **ret_bh,
                              int ex,
                              struct page *page);
 /* 99% of the time we don't want to supply any additional flags --
 * those are for very specific cases only. */
-#define ocfs2_meta_lock(i, h, b, e) ocfs2_meta_lock_full(i, h, b, e, 0)
+#define ocfs2_meta_lock(i, b, e) ocfs2_meta_lock_full(i, b, e, 0)
 void ocfs2_meta_unlock(struct inode *inode,
                       int ex);
 int ocfs2_super_lock(struct ocfs2_super *osb,
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index fb91089a60a7..06be6e774cf9 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -100,7 +100,7 @@ static struct dentry *ocfs2_get_parent(struct dentry *child)
        mlog(0, "find parent of directory %llu\n",
             (unsigned long long)OCFS2_I(dir)->ip_blkno);
-        status = ocfs2_meta_lock(dir, NULL, NULL, 0);
+        status = ocfs2_meta_lock(dir, NULL, 0);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index fcd4475d1f89..80ac69f11d9f 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -61,7 +61,7 @@ struct ocfs2_em_insert_context {
        struct ocfs2_extent_map_entry *right_ent;
 };
-static kmem_cache_t *ocfs2_em_ent_cachep = NULL;
+static struct kmem_cache *ocfs2_em_ent_cachep = NULL;
 static struct ocfs2_extent_map_entry *
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 1be74c4e7814..8786b3c490aa 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -31,6 +31,8 @@
 #include <linux/pagemap.h>
 #include <linux/uio.h>
 #include <linux/sched.h>
+#include <linux/pipe_fs_i.h>
+#include <linux/mount.h>
 #define MLOG_MASK_PREFIX ML_INODE
 #include <cluster/masklog.h>
@@ -134,7 +136,58 @@ bail:
        return (err < 0) ? -EIO : 0;
 }
-int ocfs2_set_inode_size(struct ocfs2_journal_handle *handle,
+int ocfs2_should_update_atime(struct inode *inode,
+                              struct vfsmount *vfsmnt)
+{
+        struct timespec now;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
+                return 0;
+        if ((inode->i_flags & S_NOATIME) ||
+            ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)))
+                return 0;
+        if ((vfsmnt->mnt_flags & MNT_NOATIME) ||
+            ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
+                return 0;
+        now = CURRENT_TIME;
+        if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
+                return 0;
+        else
+                return 1;
+}
+int ocfs2_update_inode_atime(struct inode *inode,
+                             struct buffer_head *bh)
+{
+        int ret;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        handle_t *handle;
+        mlog_entry_void();
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
+        if (handle == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+        inode->i_atime = CURRENT_TIME;
+        ret = ocfs2_mark_inode_dirty(handle, inode, bh);
+        if (ret < 0)
+                mlog_errno(ret);
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        mlog_exit(ret);
+        return ret;
+}
+int ocfs2_set_inode_size(handle_t *handle,
                         struct inode *inode,
                         struct buffer_head *fe_bh,
                         u64 new_i_size)
@@ -163,10 +216,9 @@ static int ocfs2_simple_size_update(struct inode *inode,
 {
        int ret;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
-        handle = ocfs2_start_trans(osb, NULL,
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
-                                   OCFS2_INODE_UPDATE_CREDITS);
        if (handle == NULL) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -178,7 +230,7 @@ static int ocfs2_simple_size_update(struct inode *inode,
        if (ret < 0)
                mlog_errno(ret);
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 out:
        return ret;
 }
@@ -189,14 +241,14 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
                                     u64 new_i_size)
 {
        int status;
-        struct ocfs2_journal_handle *handle;
+        handle_t *handle;
        mlog_entry_void();
        /* TODO: This needs to actually orphan the inode in this
         * transaction. */
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                mlog_errno(status);
@@ -207,7 +259,7 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
        if (status < 0)
                mlog_errno(status);
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 out:
        mlog_exit(status);
        return status;
@@ -328,7 +380,7 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
                               struct inode *inode,
                               u32 clusters_to_add,
                               struct buffer_head *fe_bh,
-                               struct ocfs2_journal_handle *handle,
+                               handle_t *handle,
                               struct ocfs2_alloc_context *data_ac,
                               struct ocfs2_alloc_context *meta_ac,
                               enum ocfs2_alloc_restarted *reason_ret)
@@ -433,7 +485,7 @@ static int ocfs2_extend_allocation(struct inode *inode,
        u32 prev_clusters;
        struct buffer_head *bh = NULL;
        struct ocfs2_dinode *fe = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_alloc_context *data_ac = NULL;
        struct ocfs2_alloc_context *meta_ac = NULL;
        enum ocfs2_alloc_restarted why;
@@ -463,13 +515,6 @@ restart_all:
             (unsigned long long)OCFS2_I(inode)->ip_blkno, i_size_read(inode),
             fe->i_clusters, clusters_to_add);
-        handle = ocfs2_alloc_handle(osb);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto leave;
-        }
        num_free_extents = ocfs2_num_free_extents(osb,
                                                  inode,
                                                  fe);
@@ -480,10 +525,7 @@ restart_all:
        }
        if (!num_free_extents) {
-                status = ocfs2_reserve_new_metadata(osb,
+                status = ocfs2_reserve_new_metadata(osb, fe, &meta_ac);
-                                                    handle,
-                                                    fe,
-                                                    &meta_ac);
                if (status < 0) {
                        if (status != -ENOSPC)
                                mlog_errno(status);
@@ -491,10 +533,7 @@ restart_all:
                }
        }
-        status = ocfs2_reserve_clusters(osb,
+        status = ocfs2_reserve_clusters(osb, clusters_to_add, &data_ac);
-                                        handle,
-                                        clusters_to_add,
-                                        &data_ac);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -509,7 +548,7 @@ restart_all:
        drop_alloc_sem = 1;
        credits = ocfs2_calc_extend_credits(osb->sb, fe, clusters_to_add);
-        handle = ocfs2_start_trans(osb, handle, credits);
+        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -589,7 +628,7 @@ leave:
                drop_alloc_sem = 0;
        }
        if (handle) {
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
                handle = NULL;
        }
        if (data_ac) {
@@ -624,7 +663,7 @@ static int ocfs2_write_zero_page(struct inode *inode,
        struct page *page;
        unsigned long index;
        unsigned int offset;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        int ret;
        offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */
@@ -668,7 +707,7 @@ static int ocfs2_write_zero_page(struct inode *inode,
                ret = 0;
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
 out_unlock:
        unlock_page(page);
        page_cache_release(page);
@@ -789,7 +828,7 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
        struct super_block *sb = inode->i_sb;
        struct ocfs2_super *osb = OCFS2_SB(sb);
        struct buffer_head *bh = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        mlog_entry("(0x%p, '%.*s')\n", dentry,
                   dentry->d_name.len, dentry->d_name.name);
@@ -825,7 +864,7 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                }
        }
-        status = ocfs2_meta_lock(inode, NULL, &bh, 1);
+        status = ocfs2_meta_lock(inode, &bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
@@ -845,7 +884,7 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                }
        }
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                mlog_errno(status);
@@ -863,7 +902,7 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                mlog_errno(status);
 bail_commit:
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 bail_unlock:
        ocfs2_meta_unlock(inode, 1);
 bail_unlock_rw:
@@ -906,19 +945,41 @@ bail:
        return err;
 }
+int ocfs2_permission(struct inode *inode, int mask, struct nameidata *nd)
+{
+        int ret;
+        mlog_entry_void();
+        ret = ocfs2_meta_lock(inode, NULL, 0);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = generic_permission(inode, mask, NULL);
+        if (ret)
+                mlog_errno(ret);
+        ocfs2_meta_unlock(inode, 0);
+out:
+        mlog_exit(ret);
+        return ret;
+}
 static int ocfs2_write_remove_suid(struct inode *inode)
 {
        int ret;
        struct buffer_head *bh = NULL;
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
-        struct ocfs2_journal_handle *handle;
+        handle_t *handle;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct ocfs2_dinode *di;
        mlog_entry("(Inode %llu, mode 0%o)\n",
                   (unsigned long long)oi->ip_blkno, inode->i_mode);
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (handle == NULL) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -951,75 +1012,29 @@ static int ocfs2_write_remove_suid(struct inode *inode)
 out_bh:
        brelse(bh);
 out_trans:
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 out:
        mlog_exit(ret);
        return ret;
 }
-static inline int ocfs2_write_should_remove_suid(struct inode *inode)
+static int ocfs2_prepare_inode_for_write(struct dentry *dentry,
-{
+                                         loff_t *ppos,
-        mode_t mode = inode->i_mode;
+                                         size_t count,
+                                         int appending)
-        if (!capable(CAP_FSETID)) {
-                if (unlikely(mode & S_ISUID))
-                        return 1;
-                if (unlikely((mode & S_ISGID) && (mode & S_IXGRP)))
-                        return 1;
-        }
-        return 0;
-}
-static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
-                                    const struct iovec *iov,
-                                    unsigned long nr_segs,
-                                    loff_t pos)
 {
-        int ret, rw_level = -1, meta_level = -1, have_alloc_sem = 0;
+        int ret = 0, meta_level = appending;
+        struct inode *inode = dentry->d_inode;
        u32 clusters;
-        struct file *filp = iocb->ki_filp;
-        struct inode *inode = filp->f_dentry->d_inode;
        loff_t newsize, saved_pos;
-        mlog_entry("(0x%p, %u, '%.*s')\n", filp,
-                   (unsigned int)nr_segs,
-                   filp->f_dentry->d_name.len,
-                   filp->f_dentry->d_name.name);
-        /* happy write of zero bytes */
-        if (iocb->ki_left == 0)
-                return 0;
-        if (!inode) {
-                mlog(0, "bad inode\n");
-                return -EIO;
-        }
-        mutex_lock(&inode->i_mutex);
-        /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
-        if (filp->f_flags & O_DIRECT) {
-                have_alloc_sem = 1;
-                down_read(&inode->i_alloc_sem);
-        }
-        /* concurrent O_DIRECT writes are allowed */
-        rw_level = (filp->f_flags & O_DIRECT) ? 0 : 1;
-        ret = ocfs2_rw_lock(inode, rw_level);
-        if (ret < 0) {
-                rw_level = -1;
-                mlog_errno(ret);
-                goto out;
-        }
        /* 
         * We sample i_size under a read level meta lock to see if our write
         * is extending the file, if it is we back off and get a write level
         * meta lock.
         */
-        meta_level = (filp->f_flags & O_APPEND) ? 1 : 0;
        for(;;) {
-                ret = ocfs2_meta_lock(inode, NULL, NULL, meta_level);
+                ret = ocfs2_meta_lock(inode, NULL, meta_level);
                if (ret < 0) {
                        meta_level = -1;
                        mlog_errno(ret);
@@ -1035,7 +1050,7 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
                 * inode. There's also the dinode i_size state which
                 * can be lost via setattr during extending writes (we
                 * set inode->i_size at the end of a write. */
-                if (ocfs2_write_should_remove_suid(inode)) {
+                if (should_remove_suid(dentry)) {
                        if (meta_level == 0) {
                                ocfs2_meta_unlock(inode, meta_level);
                                meta_level = 1;
@@ -1045,19 +1060,19 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
                        ret = ocfs2_write_remove_suid(inode);
                        if (ret < 0) {
                                mlog_errno(ret);
-                                goto out;
+                                goto out_unlock;
                        }
                }
                /* work on a copy of ppos until we're sure that we won't have
                 * to recalculate it due to relocking. */
-                if (filp->f_flags & O_APPEND) {
+                if (appending) {
                        saved_pos = i_size_read(inode);
                        mlog(0, "O_APPEND: inode->i_size=%llu\n", saved_pos);
                } else {
-                        saved_pos = iocb->ki_pos;
+                        saved_pos = *ppos;
                }
-                newsize = iocb->ki_left + saved_pos;
+                newsize = count + saved_pos;
                mlog(0, "pos=%lld newsize=%lld cursize=%lld\n",
                     (long long) saved_pos, (long long) newsize,
@@ -1090,19 +1105,66 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
                if (!clusters)
                        break;
-                ret = ocfs2_extend_file(inode, NULL, newsize, iocb->ki_left);
+                ret = ocfs2_extend_file(inode, NULL, newsize, count);
                if (ret < 0) {
                        if (ret != -ENOSPC)
                                mlog_errno(ret);
-                        goto out;
+                        goto out_unlock;
                }
                break;
        }
-        /* ok, we're done with i_size and alloc work */
+        if (appending)
-        iocb->ki_pos = saved_pos;
+                *ppos = saved_pos;
+out_unlock:
        ocfs2_meta_unlock(inode, meta_level);
-        meta_level = -1;
+out:
+        return ret;
+}
+static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
+                                    const struct iovec *iov,
+                                    unsigned long nr_segs,
+                                    loff_t pos)
+{
+        int ret, rw_level, have_alloc_sem = 0;
+        struct file *filp = iocb->ki_filp;
+        struct inode *inode = filp->f_dentry->d_inode;
+        int appending = filp->f_flags & O_APPEND ? 1 : 0;
+        mlog_entry("(0x%p, %u, '%.*s')\n", filp,
+                   (unsigned int)nr_segs,
+                   filp->f_dentry->d_name.len,
+                   filp->f_dentry->d_name.name);
+        /* happy write of zero bytes */
+        if (iocb->ki_left == 0)
+                return 0;
+        mutex_lock(&inode->i_mutex);
+        /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
+        if (filp->f_flags & O_DIRECT) {
+                have_alloc_sem = 1;
+                down_read(&inode->i_alloc_sem);
+        }
+        /* concurrent O_DIRECT writes are allowed */
+        rw_level = (filp->f_flags & O_DIRECT) ? 0 : 1;
+        ret = ocfs2_rw_lock(inode, rw_level);
+        if (ret < 0) {
+                rw_level = -1;
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_prepare_inode_for_write(filp->f_dentry, &iocb->ki_pos,
+                                            iocb->ki_left, appending);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
        /* communicate with ocfs2_dio_end_io */
        ocfs2_iocb_set_rw_locked(iocb);
@@ -1128,8 +1190,6 @@ static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
        }
 out:
-        if (meta_level != -1)
-                ocfs2_meta_unlock(inode, meta_level);
        if (have_alloc_sem)
                up_read(&inode->i_alloc_sem);
        if (rw_level != -1) 
@@ -1140,12 +1200,83 @@ out:
        return ret;
 }
+static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
+                                       struct file *out,
+                                       loff_t *ppos,
+                                       size_t len,
+                                       unsigned int flags)
+{
+        int ret;
+        struct inode *inode = out->f_dentry->d_inode;
+        mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
+                   (unsigned int)len,
+                   out->f_dentry->d_name.len,
+                   out->f_dentry->d_name.name);
+        inode_double_lock(inode, pipe->inode);
+        ret = ocfs2_rw_lock(inode, 1);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_prepare_inode_for_write(out->f_dentry, ppos, len, 0);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out_unlock;
+        }
+        /* ok, we're done with i_size and alloc work */
+        ret = generic_file_splice_write_nolock(pipe, out, ppos, len, flags);
+out_unlock:
+        ocfs2_rw_unlock(inode, 1);
+out:
+        inode_double_unlock(inode, pipe->inode);
+        mlog_exit(ret);
+        return ret;
+}
+static ssize_t ocfs2_file_splice_read(struct file *in,
+                                      loff_t *ppos,
+                                      struct pipe_inode_info *pipe,
+                                      size_t len,
+                                      unsigned int flags)
+{
+        int ret = 0;
+        struct inode *inode = in->f_dentry->d_inode;
+        mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
+                   (unsigned int)len,
+                   in->f_dentry->d_name.len,
+                   in->f_dentry->d_name.name);
+        /*
+         * See the comment in ocfs2_file_aio_read()
+         */
+        ret = ocfs2_meta_lock(inode, NULL, 0);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto bail;
+        }
+        ocfs2_meta_unlock(inode, 0);
+        ret = generic_file_splice_read(in, ppos, pipe, len, flags);
+bail:
+        mlog_exit(ret);
+        return ret;
+}
 static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
                                   const struct iovec *iov,
                                   unsigned long nr_segs,
                                   loff_t pos)
 {
-        int ret = 0, rw_level = -1, have_alloc_sem = 0;
+        int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
        struct file *filp = iocb->ki_filp;
        struct inode *inode = filp->f_dentry->d_inode;
@@ -1187,12 +1318,12 @@ static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
         * like i_size. This allows the checks down below
         * generic_file_aio_read() a chance of actually working. 
         */
-        ret = ocfs2_meta_lock(inode, NULL, NULL, 0);
+        ret = ocfs2_meta_lock_atime(inode, filp->f_vfsmnt, &lock_level);
        if (ret < 0) {
                mlog_errno(ret);
                goto bail;
        }
-        ocfs2_meta_unlock(inode, 0);
+        ocfs2_meta_unlock(inode, lock_level);
        ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos);
        if (ret == -EINVAL)
@@ -1220,11 +1351,13 @@ bail:
 struct inode_operations ocfs2_file_iops = {
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
+        .permission     = ocfs2_permission,
 };
 struct inode_operations ocfs2_special_file_iops = {
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
+        .permission     = ocfs2_permission,
 };
 const struct file_operations ocfs2_fops = {
@@ -1238,6 +1371,8 @@ const struct file_operations ocfs2_fops = {
        .aio_read       = ocfs2_file_aio_read,
        .aio_write      = ocfs2_file_aio_write,
        .ioctl          = ocfs2_ioctl,
+        .splice_read    = ocfs2_file_splice_read,
+        .splice_write   = ocfs2_file_splice_write,
 };
 const struct file_operations ocfs2_dops = {
diff --git a/fs/ocfs2/file.h b/fs/ocfs2/file.h
index 740c9e7ca599..601a453f18a8 100644
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -41,17 +41,24 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
                               struct inode *inode,
                               u32 clusters_to_add,
                               struct buffer_head *fe_bh,
-                               struct ocfs2_journal_handle *handle,
+                               handle_t *handle,
                               struct ocfs2_alloc_context *data_ac,
                               struct ocfs2_alloc_context *meta_ac,
                               enum ocfs2_alloc_restarted *reason);
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr);
 int ocfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat);
+int ocfs2_permission(struct inode *inode, int mask,
+                     struct nameidata *nd);
-int ocfs2_set_inode_size(struct ocfs2_journal_handle *handle,
+int ocfs2_set_inode_size(handle_t *handle,
                         struct inode *inode,
                         struct buffer_head *fe_bh,
                         u64 new_i_size);
+int ocfs2_should_update_atime(struct inode *inode,
+                              struct vfsmount *vfsmnt);
+int ocfs2_update_inode_atime(struct inode *inode,
+                             struct buffer_head *bh);
 #endif /* OCFS2_FILE_H */
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 16e8e74dc966..42e361f3054f 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -360,7 +360,6 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
                                  inode);
        ocfs2_set_inode_flags(inode);
-        inode->i_flags |= S_NOATIME;
        status = 0;
 bail:
@@ -441,7 +440,7 @@ static int ocfs2_read_locked_inode(struct inode *inode,
                                  generation, inode);
        if (can_lock) {
-                status = ocfs2_meta_lock(inode, NULL, NULL, 0);
+                status = ocfs2_meta_lock(inode, NULL, 0);
                if (status) {
                        make_bad_inode(inode);
                        mlog_errno(status);
@@ -512,7 +511,7 @@ static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
                                     struct buffer_head *fe_bh)
 {
        int status = 0;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_truncate_context *tc = NULL;
        struct ocfs2_dinode *fe;
@@ -524,7 +523,7 @@ static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
        if (!fe->i_clusters)
                goto bail;
-        handle = ocfs2_start_trans(osb, handle, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -538,7 +537,7 @@ static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
                goto bail;
        }
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
        handle = NULL;
        status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc);
@@ -554,7 +553,7 @@ static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
        }
 bail:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
        mlog_exit(status);
        return status;
@@ -568,7 +567,7 @@ static int ocfs2_remove_inode(struct inode *inode,
        int status;
        struct inode *inode_alloc_inode = NULL;
        struct buffer_head *inode_alloc_bh = NULL;
-        struct ocfs2_journal_handle *handle;
+        handle_t *handle;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
@@ -582,7 +581,7 @@ static int ocfs2_remove_inode(struct inode *inode,
        }
        mutex_lock(&inode_alloc_inode->i_mutex);
-        status = ocfs2_meta_lock(inode_alloc_inode, NULL, &inode_alloc_bh, 1);
+        status = ocfs2_meta_lock(inode_alloc_inode, &inode_alloc_bh, 1);
        if (status < 0) {
                mutex_unlock(&inode_alloc_inode->i_mutex);
@@ -590,7 +589,7 @@ static int ocfs2_remove_inode(struct inode *inode,
                goto bail;
        }
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_DELETE_INODE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_DELETE_INODE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                mlog_errno(status);
@@ -629,7 +628,7 @@ static int ocfs2_remove_inode(struct inode *inode,
                mlog_errno(status);
 bail_commit:
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 bail_unlock:
        ocfs2_meta_unlock(inode_alloc_inode, 1);
        mutex_unlock(&inode_alloc_inode->i_mutex);
@@ -705,7 +704,7 @@ static int ocfs2_wipe_inode(struct inode *inode,
         * delete_inode operation. We do this now to avoid races with
         * recovery completion on other nodes. */
        mutex_lock(&orphan_dir_inode->i_mutex);
-        status = ocfs2_meta_lock(orphan_dir_inode, NULL, &orphan_dir_bh, 1);
+        status = ocfs2_meta_lock(orphan_dir_inode, &orphan_dir_bh, 1);
        if (status < 0) {
                mutex_unlock(&orphan_dir_inode->i_mutex);
@@ -933,7 +932,7 @@ void ocfs2_delete_inode(struct inode *inode)
         * allocation lock here as it won't be needed - nobody will
         * have the file open.
         */
-        status = ocfs2_meta_lock(inode, NULL, &di_bh, 1);
+        status = ocfs2_meta_lock(inode, &di_bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
@@ -1067,12 +1066,6 @@ void ocfs2_clear_inode(struct inode *inode)
        mlog_bug_on_msg(oi->ip_open_count,
                        "Clear inode of %llu has open count %d\n",
                        (unsigned long long)oi->ip_blkno, oi->ip_open_count);
-        mlog_bug_on_msg(!list_empty(&oi->ip_handle_list),
-                        "Clear inode of %llu has non empty handle list\n",
-                        (unsigned long long)oi->ip_blkno);
-        mlog_bug_on_msg(oi->ip_handle,
-                        "Clear inode of %llu has non empty handle pointer\n",
-                        (unsigned long long)oi->ip_blkno);
        /* Clear all other flags. */
        oi->ip_flags = OCFS2_INODE_CACHE_INLINE;
@@ -1186,7 +1179,7 @@ int ocfs2_inode_revalidate(struct dentry *dentry)
        /* Let ocfs2_meta_lock do the work of updating our struct
         * inode for us. */
-        status = ocfs2_meta_lock(inode, NULL, NULL, 0);
+        status = ocfs2_meta_lock(inode, NULL, 0);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
@@ -1204,7 +1197,7 @@ bail:
 * struct inode.
 * Only takes ip_lock.
 */
-int ocfs2_mark_inode_dirty(struct ocfs2_journal_handle *handle,
+int ocfs2_mark_inode_dirty(handle_t *handle,
                           struct inode *inode,
                           struct buffer_head *bh)
 {
diff --git a/fs/ocfs2/inode.h b/fs/ocfs2/inode.h
index 9957810fdf85..1a7dd2945b34 100644
--- a/fs/ocfs2/inode.h
+++ b/fs/ocfs2/inode.h
@@ -48,13 +48,6 @@ struct ocfs2_inode_info
        struct mutex                    ip_io_mutex;
-        /* Used by the journalling code to attach an inode to a
-         * handle.  These are protected by ip_io_mutex in order to lock
-         * out other I/O to the inode until we either commit or
-         * abort. */
-        struct list_head                ip_handle_list;
-        struct ocfs2_journal_handle     *ip_handle;
        u32                             ip_flags; /* see below */
        u32                             ip_attr; /* inode attributes */
@@ -113,7 +106,7 @@ static inline struct ocfs2_inode_info *OCFS2_I(struct inode *inode)
 #define INODE_JOURNAL(i) (OCFS2_I(i)->ip_flags & OCFS2_INODE_JOURNAL)
 #define SET_INODE_JOURNAL(i) (OCFS2_I(i)->ip_flags |= OCFS2_INODE_JOURNAL)
-extern kmem_cache_t *ocfs2_inode_cache;
+extern struct kmem_cache *ocfs2_inode_cache;
 extern const struct address_space_operations ocfs2_aops;
@@ -143,7 +136,7 @@ ssize_t ocfs2_rw_direct(int rw, struct file *filp, char *buf,
 void ocfs2_sync_blockdev(struct super_block *sb);
 void ocfs2_refresh_inode(struct inode *inode,
                         struct ocfs2_dinode *fe);
-int ocfs2_mark_inode_dirty(struct ocfs2_journal_handle *handle,
+int ocfs2_mark_inode_dirty(handle_t *handle,
                           struct inode *inode,
                           struct buffer_head *bh);
 int ocfs2_aio_read(struct file *file, struct kiocb *req, struct iocb *iocb);
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index 3663cef80689..4768be5f3086 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -26,7 +26,7 @@ static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
 {
        int status;
-        status = ocfs2_meta_lock(inode, NULL, NULL, 0);
+        status = ocfs2_meta_lock(inode, NULL, 0);
        if (status < 0) {
                mlog_errno(status);
                return status;
@@ -43,14 +43,14 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
 {
        struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct buffer_head *bh = NULL;
        unsigned oldflags;
        int status;
        mutex_lock(&inode->i_mutex);
-        status = ocfs2_meta_lock(inode, NULL, &bh, 1);
+        status = ocfs2_meta_lock(inode, &bh, 1);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -67,7 +67,7 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
        if (!S_ISDIR(inode->i_mode))
                flags &= ~OCFS2_DIRSYNC_FL;
-        handle = ocfs2_start_trans(osb, NULL, OCFS2_INODE_UPDATE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                mlog_errno(status);
@@ -96,7 +96,7 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
        if (status < 0)
                mlog_errno(status);
-        ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
 bail_unlock:
        ocfs2_meta_unlock(inode, 1);
 bail:
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index fd9734def551..1d7f4ab1e5ed 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -57,9 +57,6 @@ static int ocfs2_recover_node(struct ocfs2_super *osb,
 static int __ocfs2_recovery_thread(void *arg);
 static int ocfs2_commit_cache(struct ocfs2_super *osb);
 static int ocfs2_wait_on_mount(struct ocfs2_super *osb);
-static void ocfs2_handle_cleanup_locks(struct ocfs2_journal *journal,
-                                       struct ocfs2_journal_handle *handle);
-static void ocfs2_commit_unstarted_handle(struct ocfs2_journal_handle *handle);
 static int ocfs2_journal_toggle_dirty(struct ocfs2_super *osb,
                                      int dirty);
 static int ocfs2_trylock_journal(struct ocfs2_super *osb,
@@ -113,46 +110,18 @@ finally:
        return status;
 }
-struct ocfs2_journal_handle *ocfs2_alloc_handle(struct ocfs2_super *osb)
-{
-        struct ocfs2_journal_handle *retval = NULL;
-        retval = kcalloc(1, sizeof(*retval), GFP_NOFS);
-        if (!retval) {
-                mlog(ML_ERROR, "Failed to allocate memory for journal "
-                     "handle!\n");
-                return NULL;
-        }
-        retval->max_buffs = 0;
-        retval->num_locks = 0;
-        retval->k_handle = NULL;
-        INIT_LIST_HEAD(&retval->locks);
-        INIT_LIST_HEAD(&retval->inode_list);
-        retval->journal = osb->journal;
-        return retval;
-}
 /* pass it NULL and it will allocate a new handle object for you.  If
 * you pass it a handle however, it may still return error, in which
 * case it has free'd the passed handle for you. */
-struct ocfs2_journal_handle *ocfs2_start_trans(struct ocfs2_super *osb,
+handle_t *ocfs2_start_trans(struct ocfs2_super *osb, int max_buffs)
-                                               struct ocfs2_journal_handle *handle,
-                                               int max_buffs)
 {
-        int ret;
        journal_t *journal = osb->journal->j_journal;
+        handle_t *handle;
-        mlog_entry("(max_buffs = %d)\n", max_buffs);
        BUG_ON(!osb || !osb->journal->j_journal);
-        if (ocfs2_is_hard_readonly(osb)) {
+        if (ocfs2_is_hard_readonly(osb))
-                ret = -EROFS;
+                return ERR_PTR(-EROFS);
-                goto done_free;
-        }
        BUG_ON(osb->journal->j_state == OCFS2_JOURNAL_FREE);
        BUG_ON(max_buffs <= 0);
@@ -163,154 +132,39 @@ struct ocfs2_journal_handle *ocfs2_start_trans(struct ocfs2_super *osb,
                BUG();
        }
-        if (!handle)
-                handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                ret = -ENOMEM;
-                mlog(ML_ERROR, "Failed to allocate memory for journal "
-                     "handle!\n");
-                goto done_free;
-        }
-        handle->max_buffs = max_buffs;
        down_read(&osb->journal->j_trans_barrier);
-        /* actually start the transaction now */
+        handle = journal_start(journal, max_buffs);
-        handle->k_handle = journal_start(journal, max_buffs);
+        if (IS_ERR(handle)) {
-        if (IS_ERR(handle->k_handle)) {
                up_read(&osb->journal->j_trans_barrier);
-                ret = PTR_ERR(handle->k_handle);
+                mlog_errno(PTR_ERR(handle));
-                handle->k_handle = NULL;
-                mlog_errno(ret);
                if (is_journal_aborted(journal)) {
                        ocfs2_abort(osb->sb, "Detected aborted journal");
-                        ret = -EROFS;
+                        handle = ERR_PTR(-EROFS);
                }
-                goto done_free;
+        } else
-        }
+                atomic_inc(&(osb->journal->j_num_trans));
-        atomic_inc(&(osb->journal->j_num_trans));
-        handle->flags |= OCFS2_HANDLE_STARTED;
-        mlog_exit_ptr(handle);
        return handle;
-done_free:
-        if (handle)
-                ocfs2_commit_unstarted_handle(handle); /* will kfree handle */
-        mlog_exit(ret);
-        return ERR_PTR(ret);
-}
-void ocfs2_handle_add_inode(struct ocfs2_journal_handle *handle,
-                            struct inode *inode)
-{
-        BUG_ON(!handle);
-        BUG_ON(!inode);
-        atomic_inc(&inode->i_count);
-        /* we're obviously changing it... */
-        mutex_lock(&inode->i_mutex);
-        /* sanity check */
-        BUG_ON(OCFS2_I(inode)->ip_handle);
-        BUG_ON(!list_empty(&OCFS2_I(inode)->ip_handle_list));
-        OCFS2_I(inode)->ip_handle = handle;
-        list_move_tail(&(OCFS2_I(inode)->ip_handle_list), &(handle->inode_list));
-}
-static void ocfs2_handle_unlock_inodes(struct ocfs2_journal_handle *handle)
-{
-        struct list_head *p, *n;
-        struct inode *inode;
-        struct ocfs2_inode_info *oi;
-        list_for_each_safe(p, n, &handle->inode_list) {
-                oi = list_entry(p, struct ocfs2_inode_info,
-                                ip_handle_list);
-                inode = &oi->vfs_inode;
-                OCFS2_I(inode)->ip_handle = NULL;
-                list_del_init(&OCFS2_I(inode)->ip_handle_list);
-                mutex_unlock(&inode->i_mutex);
-                iput(inode);
-        }
-}
-/* This is trivial so we do it out of the main commit
- * paths. Beware, it can be called from start_trans too! */
-static void ocfs2_commit_unstarted_handle(struct ocfs2_journal_handle *handle)
-{
-        mlog_entry_void();
-        BUG_ON(handle->flags & OCFS2_HANDLE_STARTED);
-        ocfs2_handle_unlock_inodes(handle);
-        /* You are allowed to add journal locks before the transaction
-         * has started. */
-        ocfs2_handle_cleanup_locks(handle->journal, handle);
-        kfree(handle);
-        mlog_exit_void();
 }
-void ocfs2_commit_trans(struct ocfs2_journal_handle *handle)
+int ocfs2_commit_trans(struct ocfs2_super *osb,
+                       handle_t *handle)
 {
-        handle_t *jbd_handle;
+        int ret;
-        int retval;
+        struct ocfs2_journal *journal = osb->journal;
-        struct ocfs2_journal *journal = handle->journal;
-        mlog_entry_void();
        BUG_ON(!handle);
-        if (!(handle->flags & OCFS2_HANDLE_STARTED)) {
+        ret = journal_stop(handle);
-                ocfs2_commit_unstarted_handle(handle);
+        if (ret < 0)
-                mlog_exit_void();
+                mlog_errno(ret);
-                return;
-        }
-        /* release inode semaphores we took during this transaction */
-        ocfs2_handle_unlock_inodes(handle);
-        /* ocfs2_extend_trans may have had to call journal_restart
-         * which will always commit the transaction, but may return
-         * error for any number of reasons. If this is the case, we
-         * clear k_handle as it's not valid any more. */
-        if (handle->k_handle) {
-                jbd_handle = handle->k_handle;
-                if (handle->flags & OCFS2_HANDLE_SYNC)
-                        jbd_handle->h_sync = 1;
-                else
-                        jbd_handle->h_sync = 0;
-                /* actually stop the transaction. if we've set h_sync,
-                 * it'll have been committed when we return */
-                retval = journal_stop(jbd_handle);
-                if (retval < 0) {
-                        mlog_errno(retval);
-                        mlog(ML_ERROR, "Could not commit transaction\n");
-                        BUG();
-                }
-                handle->k_handle = NULL; /* it's been free'd in journal_stop */
-        }
-        ocfs2_handle_cleanup_locks(journal, handle);
        up_read(&journal->j_trans_barrier);
-        kfree(handle);
+        return ret;
-        mlog_exit_void();
 }
 /*
@@ -326,20 +180,18 @@ void ocfs2_commit_trans(struct ocfs2_journal_handle *handle)
 * good because transaction ids haven't yet been recorded on the
 * cluster locks associated with this handle.
 */
-int ocfs2_extend_trans(struct ocfs2_journal_handle *handle,
+int ocfs2_extend_trans(handle_t *handle, int nblocks)
-                       int nblocks)
 {
        int status;
        BUG_ON(!handle);
-        BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED));
        BUG_ON(!nblocks);
        mlog_entry_void();
        mlog(0, "Trying to extend transaction by %d blocks\n", nblocks);
-        status = journal_extend(handle->k_handle, nblocks);
+        status = journal_extend(handle, nblocks);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -347,15 +199,12 @@ int ocfs2_extend_trans(struct ocfs2_journal_handle *handle,
        if (status > 0) {
                mlog(0, "journal_extend failed, trying journal_restart\n");
-                status = journal_restart(handle->k_handle, nblocks);
+                status = journal_restart(handle, nblocks);
                if (status < 0) {
-                        handle->k_handle = NULL;
                        mlog_errno(status);
                        goto bail;
                }
-                handle->max_buffs = nblocks;
+        }
-        } else
-                handle->max_buffs += nblocks;
        status = 0;
 bail:
@@ -364,7 +213,7 @@ bail:
        return status;
 }
-int ocfs2_journal_access(struct ocfs2_journal_handle *handle,
+int ocfs2_journal_access(handle_t *handle,
                         struct inode *inode,
                         struct buffer_head *bh,
                         int type)
@@ -374,7 +223,6 @@ int ocfs2_journal_access(struct ocfs2_journal_handle *handle,
        BUG_ON(!inode);
        BUG_ON(!handle);
        BUG_ON(!bh);
-        BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED));
        mlog_entry("bh->b_blocknr=%llu, type=%d (\"%s\"), bh->b_size = %zu\n",
                   (unsigned long long)bh->b_blocknr, type,
@@ -403,11 +251,11 @@ int ocfs2_journal_access(struct ocfs2_journal_handle *handle,
        switch (type) {
        case OCFS2_JOURNAL_ACCESS_CREATE:
        case OCFS2_JOURNAL_ACCESS_WRITE:
-                status = journal_get_write_access(handle->k_handle, bh);
+                status = journal_get_write_access(handle, bh);
                break;
        case OCFS2_JOURNAL_ACCESS_UNDO:
-                status = journal_get_undo_access(handle->k_handle, bh);
+                status = journal_get_undo_access(handle, bh);
                break;
        default:
@@ -424,17 +272,15 @@ int ocfs2_journal_access(struct ocfs2_journal_handle *handle,
        return status;
 }
-int ocfs2_journal_dirty(struct ocfs2_journal_handle *handle,
+int ocfs2_journal_dirty(handle_t *handle,
                        struct buffer_head *bh)
 {
        int status;
-        BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED));
        mlog_entry("(bh->b_blocknr=%llu)\n",
                   (unsigned long long)bh->b_blocknr);
-        status = journal_dirty_metadata(handle->k_handle, bh);
+        status = journal_dirty_metadata(handle, bh);
        if (status < 0)
                mlog(ML_ERROR, "Could not dirty metadata buffer. "
                     "(bh->b_blocknr=%llu)\n",
@@ -456,59 +302,6 @@ int ocfs2_journal_dirty_data(handle_t *handle,
        return err;
 }
-/* We always assume you're adding a metadata lock at level 'ex' */
-int ocfs2_handle_add_lock(struct ocfs2_journal_handle *handle,
-                          struct inode *inode)
-{
-        int status;
-        struct ocfs2_journal_lock *lock;
-        BUG_ON(!inode);
-        lock = kmem_cache_alloc(ocfs2_lock_cache, GFP_NOFS);
-        if (!lock) {
-                status = -ENOMEM;
-                mlog_errno(-ENOMEM);
-                goto bail;
-        }
-        if (!igrab(inode))
-                BUG();
-        lock->jl_inode = inode;
-        list_add_tail(&(lock->jl_lock_list), &(handle->locks));
-        handle->num_locks++;
-        status = 0;
-bail:
-        mlog_exit(status);
-        return status;
-}
-static void ocfs2_handle_cleanup_locks(struct ocfs2_journal *journal,
-                                       struct ocfs2_journal_handle *handle)
-{
-        struct list_head *p, *n;
-        struct ocfs2_journal_lock *lock;
-        struct inode *inode;
-        list_for_each_safe(p, n, &(handle->locks)) {
-                lock = list_entry(p, struct ocfs2_journal_lock,
-                                  jl_lock_list);
-                list_del(&lock->jl_lock_list);
-                handle->num_locks--;
-                inode = lock->jl_inode;
-                ocfs2_meta_unlock(inode, 1);
-                if (atomic_read(&inode->i_count) == 1)
-                        mlog(ML_ERROR,
-                             "Inode %llu, I'm doing a last iput for!",
-                             (unsigned long long)OCFS2_I(inode)->ip_blkno);
-                iput(inode);
-                kmem_cache_free(ocfs2_lock_cache, lock);
-        }
-}
 #define OCFS2_DEFAULT_COMMIT_INTERVAL   (HZ * 5)
 void ocfs2_set_journal_params(struct ocfs2_super *osb)
@@ -562,8 +355,7 @@ int ocfs2_journal_init(struct ocfs2_journal *journal, int *dirty)
        /* Skip recovery waits here - journal inode metadata never
         * changes in a live cluster so it can be considered an
         * exception to the rule. */
-        status = ocfs2_meta_lock_full(inode, NULL, &bh, 1,
+        status = ocfs2_meta_lock_full(inode, &bh, 1, OCFS2_META_LOCK_RECOVERY);
-                                      OCFS2_META_LOCK_RECOVERY);
        if (status < 0) {
                if (status != -ERESTARTSYS)
                        mlog(ML_ERROR, "Could not get lock on journal!\n");
@@ -911,11 +703,12 @@ struct ocfs2_la_recovery_item {
 * NOTE: This function can and will sleep on recovery of other nodes
 * during cluster locking, just like any other ocfs2 process.
 */
-void ocfs2_complete_recovery(void *data)
+void ocfs2_complete_recovery(struct work_struct *work)
 {
        int ret;
-        struct ocfs2_super *osb = data;
+        struct ocfs2_journal *journal =
-        struct ocfs2_journal *journal = osb->journal;
+                container_of(work, struct ocfs2_journal, j_recovery_work);
+        struct ocfs2_super *osb = journal->j_osb;
        struct ocfs2_dinode *la_dinode, *tl_dinode;
        struct ocfs2_la_recovery_item *item;
        struct list_head *p, *n;
@@ -1160,8 +953,7 @@ static int ocfs2_replay_journal(struct ocfs2_super *osb,
        }
        SET_INODE_JOURNAL(inode);
-        status = ocfs2_meta_lock_full(inode, NULL, &bh, 1,
+        status = ocfs2_meta_lock_full(inode, &bh, 1, OCFS2_META_LOCK_RECOVERY);
-                                      OCFS2_META_LOCK_RECOVERY);
        if (status < 0) {
                mlog(0, "status returned from ocfs2_meta_lock=%d\n", status);
                if (status != -ERESTARTSYS)
@@ -1350,7 +1142,7 @@ static int ocfs2_trylock_journal(struct ocfs2_super *osb,
        SET_INODE_JOURNAL(inode);
        flags = OCFS2_META_LOCK_RECOVERY | OCFS2_META_LOCK_NOQUEUE;
-        status = ocfs2_meta_lock_full(inode, NULL, NULL, 1, flags);
+        status = ocfs2_meta_lock_full(inode, NULL, 1, flags);
        if (status < 0) {
                if (status != -EAGAIN)
                        mlog_errno(status);
@@ -1433,7 +1225,7 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb,
        }       
        mutex_lock(&orphan_dir_inode->i_mutex);
-        status = ocfs2_meta_lock(orphan_dir_inode, NULL, NULL, 0);
+        status = ocfs2_meta_lock(orphan_dir_inode, NULL, 0);
        if (status < 0) {
                mlog_errno(status);
                goto out;
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 2f3a6acdac45..899112ad8136 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -37,7 +37,6 @@ enum ocfs2_journal_state {
 struct ocfs2_super;
 struct ocfs2_dinode;
-struct ocfs2_journal_handle;
 struct ocfs2_journal {
        enum ocfs2_journal_state   j_state;    /* Journals current state   */
@@ -133,46 +132,8 @@ static inline void ocfs2_inode_set_new(struct ocfs2_super *osb,
        spin_unlock(&trans_inc_lock);
 }
-extern kmem_cache_t *ocfs2_lock_cache;
-struct ocfs2_journal_lock {
-        struct inode     *jl_inode;
-        struct list_head  jl_lock_list;
-};
-struct ocfs2_journal_handle {
-        handle_t            *k_handle; /* kernel handle.                */
-        struct ocfs2_journal        *journal;
-        u32                 flags;     /* see flags below.              */
-        int                 max_buffs; /* Buffs reserved by this handle */
-        /* The following two fields are for ocfs2_handle_add_lock */
-        int                 num_locks;
-        struct list_head    locks;     /* A bunch of locks to
-                                        * release on commit. This
-                                        * should be a list_head */
-        struct list_head     inode_list;
-};
-#define OCFS2_HANDLE_STARTED                    1
-/* should we sync-commit this handle? */
-#define OCFS2_HANDLE_SYNC                       2
-static inline int ocfs2_handle_started(struct ocfs2_journal_handle *handle)
-{
-        return handle->flags & OCFS2_HANDLE_STARTED;
-}
-static inline void ocfs2_handle_set_sync(struct ocfs2_journal_handle *handle, int sync)
-{
-        if (sync)
-                handle->flags |= OCFS2_HANDLE_SYNC;
-        else
-                handle->flags &= ~OCFS2_HANDLE_SYNC;
-}
 /* Exported only for the journal struct init code in super.c. Do not call. */
-void ocfs2_complete_recovery(void *data);
+void ocfs2_complete_recovery(struct work_struct *work);
 /*
 *  Journal Control:
@@ -231,15 +192,14 @@ static inline void ocfs2_checkpoint_inode(struct inode *inode)
 *  Transaction Handling:
 *  Manage the lifetime of a transaction handle.
 *
- *  ocfs2_alloc_handle     - Only allocate a handle so we can start putting
- *                          cluster locks on it. To actually change blocks,
- *                          call ocfs2_start_trans with the handle returned
- *                          from this function. You may call ocfs2_commit_trans
- *                           at any time in the lifetime of a handle.
 *  ocfs2_start_trans      - Begin a transaction. Give it an upper estimate of
 *                          the number of blocks that will be changed during
 *                          this handle.
- *  ocfs2_commit_trans     - Complete a handle.
+ *  ocfs2_commit_trans - Complete a handle. It might return -EIO if
+ *                       the journal was aborted. The majority of paths don't
+ *                       check the return value as an error there comes too
+ *                       late to do anything (and will be picked up in a
+ *                       later transaction).
 *  ocfs2_extend_trans     - Extend a handle by nblocks credits. This may
 *                          commit the handle to disk in the process, but will
 *                          not release any locks taken during the transaction.
@@ -249,24 +209,16 @@ static inline void ocfs2_checkpoint_inode(struct inode *inode)
 *  ocfs2_journal_dirty    - Mark a journalled buffer as having dirty data.
 *  ocfs2_journal_dirty_data - Indicate that a data buffer should go out before
 *                             the current handle commits.
- *  ocfs2_handle_add_lock  - Sometimes we need to delay lock release
- *                          until after a transaction has been completed. Use
- *                          ocfs2_handle_add_lock to indicate that a lock needs
- *                          to be released at the end of that handle. Locks
- *                          will be released in the order that they are added.
- *  ocfs2_handle_add_inode - Add a locked inode to a transaction.
 */
 /* You must always start_trans with a number of buffs > 0, but it's
 * perfectly legal to go through an entire transaction without having
 * dirtied any buffers. */
-struct ocfs2_journal_handle *ocfs2_alloc_handle(struct ocfs2_super *osb);
+handle_t                    *ocfs2_start_trans(struct ocfs2_super *osb,
-struct ocfs2_journal_handle *ocfs2_start_trans(struct ocfs2_super *osb,
-                                               struct ocfs2_journal_handle *handle,
                                               int max_buffs);
-void                         ocfs2_commit_trans(struct ocfs2_journal_handle *handle);
+int                          ocfs2_commit_trans(struct ocfs2_super *osb,
-int                          ocfs2_extend_trans(struct ocfs2_journal_handle *handle,
+                                                handle_t *handle);
-                                                int nblocks);
+int                          ocfs2_extend_trans(handle_t *handle, int nblocks);
 /*
 * Create access is for when we get a newly created buffer and we're
@@ -283,7 +235,7 @@ int			     ocfs2_extend_trans(struct ocfs2_journal_handle *handle,
 #define OCFS2_JOURNAL_ACCESS_WRITE  1
 #define OCFS2_JOURNAL_ACCESS_UNDO   2
-int                  ocfs2_journal_access(struct ocfs2_journal_handle *handle,
+int                  ocfs2_journal_access(handle_t *handle,
                                          struct inode *inode,
                                          struct buffer_head *bh,
                                          int type);
@@ -306,18 +258,10 @@ int                  ocfs2_journal_access(struct ocfs2_journal_handle *handle,
 *      <modify the bh>
 *      ocfs2_journal_dirty(handle, bh);
 */
-int                  ocfs2_journal_dirty(struct ocfs2_journal_handle *handle,
+int                  ocfs2_journal_dirty(handle_t *handle,
                                         struct buffer_head *bh);
 int                  ocfs2_journal_dirty_data(handle_t *handle,
                                              struct buffer_head *bh);
-int                  ocfs2_handle_add_lock(struct ocfs2_journal_handle *handle,
-                                           struct inode *inode);
-/*
- * Use this to protect from other processes reading buffer state while
- * it's in flight.
- */
-void                 ocfs2_handle_add_inode(struct ocfs2_journal_handle *handle,
-                                            struct inode *inode);
 /*
 *  Credit Macros:
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index 1f17a4d08287..698d79a74ef8 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -58,19 +58,18 @@ static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc);
 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
-                                    struct ocfs2_journal_handle *handle,
+                                    handle_t *handle,
                                    struct ocfs2_dinode *alloc,
                                    struct inode *main_bm_inode,
                                    struct buffer_head *main_bm_bh);
 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
-                                                struct ocfs2_journal_handle *handle,
                                                struct ocfs2_alloc_context **ac,
                                                struct inode **bitmap_inode,
                                                struct buffer_head **bitmap_bh);
 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
-                                        struct ocfs2_journal_handle *handle,
+                                        handle_t *handle,
                                        struct ocfs2_alloc_context *ac);
 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
@@ -196,7 +195,7 @@ bail:
 void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
 {
        int status;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle;
        struct inode *local_alloc_inode = NULL;
        struct buffer_head *bh = NULL;
        struct buffer_head *main_bm_bh = NULL;
@@ -207,7 +206,7 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        mlog_entry_void();
        if (osb->local_alloc_state == OCFS2_LA_UNUSED)
-                goto bail;
+                goto out;
        local_alloc_inode =
                ocfs2_get_system_file_inode(osb,
@@ -216,40 +215,34 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        if (!local_alloc_inode) {
                status = -ENOENT;
                mlog_errno(status);
-                goto bail;
+                goto out;
        }
        osb->local_alloc_state = OCFS2_LA_DISABLED;
-        handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        main_bm_inode = ocfs2_get_system_file_inode(osb,
                                                    GLOBAL_BITMAP_SYSTEM_INODE,
                                                    OCFS2_INVALID_SLOT);
        if (!main_bm_inode) {
                status = -EINVAL;
                mlog_errno(status);
-                goto bail;
+                goto out;
        }
-        ocfs2_handle_add_inode(handle, main_bm_inode);
+        mutex_lock(&main_bm_inode->i_mutex);
-        status = ocfs2_meta_lock(main_bm_inode, handle, &main_bm_bh, 1);
+        status = ocfs2_meta_lock(main_bm_inode, &main_bm_bh, 1);
        if (status < 0) {
                mlog_errno(status);
-                goto bail;
+                goto out_mutex;
        }
        /* WINDOW_MOVE_CREDITS is a bit heavy... */
-        handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
        if (IS_ERR(handle)) {
                mlog_errno(PTR_ERR(handle));
                handle = NULL;
-                goto bail;
+                goto out_unlock;
        }
        bh = osb->local_alloc_bh;
@@ -258,7 +251,7 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        alloc_copy = kmalloc(bh->b_size, GFP_KERNEL);
        if (!alloc_copy) {
                status = -ENOMEM;
-                goto bail;
+                goto out_commit;
        }
        memcpy(alloc_copy, alloc, bh->b_size);
@@ -266,7 +259,7 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
                                      OCFS2_JOURNAL_ACCESS_WRITE);
        if (status < 0) {
                mlog_errno(status);
-                goto bail;
+                goto out_commit;
        }
        ocfs2_clear_local_alloc(alloc);
@@ -274,7 +267,7 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        status = ocfs2_journal_dirty(handle, bh);
        if (status < 0) {
                mlog_errno(status);
-                goto bail;
+                goto out_commit;
        }
        brelse(bh);
@@ -286,16 +279,20 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        if (status < 0)
                mlog_errno(status);
-bail:
+out_commit:
-        if (handle)
+        ocfs2_commit_trans(osb, handle);
-                ocfs2_commit_trans(handle);
+out_unlock:
        if (main_bm_bh)
                brelse(main_bm_bh);
-        if (main_bm_inode)
+        ocfs2_meta_unlock(main_bm_inode, 1);
-                iput(main_bm_inode);
+out_mutex:
+        mutex_unlock(&main_bm_inode->i_mutex);
+        iput(main_bm_inode);
+out:
        if (local_alloc_inode)
                iput(local_alloc_inode);
@@ -385,61 +382,59 @@ int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
                                        struct ocfs2_dinode *alloc)
 {
        int status;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle;
        struct buffer_head *main_bm_bh = NULL;
-        struct inode *main_bm_inode = NULL;
+        struct inode *main_bm_inode;
        mlog_entry_void();
-        handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        main_bm_inode = ocfs2_get_system_file_inode(osb,
                                                    GLOBAL_BITMAP_SYSTEM_INODE,
                                                    OCFS2_INVALID_SLOT);
        if (!main_bm_inode) {
                status = -EINVAL;
                mlog_errno(status);
-                goto bail;
+                goto out;
        }
-        ocfs2_handle_add_inode(handle, main_bm_inode);
+        mutex_lock(&main_bm_inode->i_mutex);
-        status = ocfs2_meta_lock(main_bm_inode, handle, &main_bm_bh, 1);
+        status = ocfs2_meta_lock(main_bm_inode, &main_bm_bh, 1);
        if (status < 0) {
                mlog_errno(status);
-                goto bail;
+                goto out_mutex;
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
                mlog_errno(status);
-                goto bail;
+                goto out_unlock;
        }
        /* we want the bitmap change to be recorded on disk asap */
-        ocfs2_handle_set_sync(handle, 1);
+        handle->h_sync = 1;
        status = ocfs2_sync_local_to_main(osb, handle, alloc,
                                          main_bm_inode, main_bm_bh);
        if (status < 0)
                mlog_errno(status);
-bail:
+        ocfs2_commit_trans(osb, handle);
-        if (handle)
-                ocfs2_commit_trans(handle);
+out_unlock:
+        ocfs2_meta_unlock(main_bm_inode, 1);
+out_mutex:
+        mutex_unlock(&main_bm_inode->i_mutex);
        if (main_bm_bh)
                brelse(main_bm_bh);
-        if (main_bm_inode)
+        iput(main_bm_inode);
-                iput(main_bm_inode);
+out:
        mlog_exit(status);
        return status;
 }
@@ -452,7 +447,6 @@ bail:
 * our own in order to shift windows.
 */
 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
-                                   struct ocfs2_journal_handle *passed_handle,
                                   u32 bits_wanted,
                                   struct ocfs2_alloc_context *ac)
 {
@@ -463,9 +457,7 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
        mlog_entry_void();
-        BUG_ON(!passed_handle);
        BUG_ON(!ac);
-        BUG_ON(passed_handle->flags & OCFS2_HANDLE_STARTED);
        local_alloc_inode =
                ocfs2_get_system_file_inode(osb,
@@ -476,7 +468,11 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
                mlog_errno(status);
                goto bail;
        }
-        ocfs2_handle_add_inode(passed_handle, local_alloc_inode);
+        mutex_lock(&local_alloc_inode->i_mutex);
+        ac->ac_inode = local_alloc_inode;
+        ac->ac_which = OCFS2_AC_USE_LOCAL;
        if (osb->local_alloc_state != OCFS2_LA_ENABLED) {
                status = -ENOSPC;
@@ -515,21 +511,17 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
                }
        }
-        ac->ac_inode = igrab(local_alloc_inode);
        get_bh(osb->local_alloc_bh);
        ac->ac_bh = osb->local_alloc_bh;
-        ac->ac_which = OCFS2_AC_USE_LOCAL;
        status = 0;
 bail:
-        if (local_alloc_inode)
-                iput(local_alloc_inode);
        mlog_exit(status);
        return status;
 }
 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
-                                 struct ocfs2_journal_handle *handle,
+                                 handle_t *handle,
                                 struct ocfs2_alloc_context *ac,
                                 u32 min_bits,
                                 u32 *bit_off,
@@ -707,7 +699,7 @@ static void ocfs2_verify_zero_bits(unsigned long *bitmap,
 * passed is used for caching.
 */
 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
-                                    struct ocfs2_journal_handle *handle,
+                                    handle_t *handle,
                                    struct ocfs2_dinode *alloc,
                                    struct inode *main_bm_inode,
                                    struct buffer_head *main_bm_bh)
@@ -778,7 +770,6 @@ bail:
 }
 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
-                                                struct ocfs2_journal_handle *handle,
                                                struct ocfs2_alloc_context **ac,
                                                struct inode **bitmap_inode,
                                                struct buffer_head **bitmap_bh)
@@ -792,7 +783,6 @@ static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
                goto bail;
        }
-        (*ac)->ac_handle = handle;
        (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb);
        status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
@@ -821,7 +811,7 @@ bail:
 * pass it the bitmap lock in lock_bh if you have it.
 */
 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
-                                        struct ocfs2_journal_handle *handle,
+                                        handle_t *handle,
                                        struct ocfs2_alloc_context *ac)
 {
        int status = 0;
@@ -888,23 +878,15 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
        int status = 0;
        struct buffer_head *main_bm_bh = NULL;
        struct inode *main_bm_inode = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_dinode *alloc;
        struct ocfs2_dinode *alloc_copy = NULL;
        struct ocfs2_alloc_context *ac = NULL;
        mlog_entry_void();
-        handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        /* This will lock the main bitmap for us. */
        status = ocfs2_local_alloc_reserve_for_window(osb,
-                                                      handle,
                                                      &ac,
                                                      &main_bm_inode,
                                                      &main_bm_bh);
@@ -914,7 +896,7 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
                goto bail;
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -972,7 +954,7 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
        status = 0;
 bail:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
        if (main_bm_bh)
                brelse(main_bm_bh);
diff --git a/fs/ocfs2/localalloc.h b/fs/ocfs2/localalloc.h
index 30f88ce14e46..385a10152f9c 100644
--- a/fs/ocfs2/localalloc.h
+++ b/fs/ocfs2/localalloc.h
@@ -42,12 +42,11 @@ int ocfs2_alloc_should_use_local(struct ocfs2_super *osb,
 struct ocfs2_alloc_context;
 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
-                                   struct ocfs2_journal_handle *passed_handle,
                                   u32 bits_wanted,
                                   struct ocfs2_alloc_context *ac);
 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
-                                 struct ocfs2_journal_handle *handle,
+                                 handle_t *handle,
                                 struct ocfs2_alloc_context *ac,
                                 u32 min_bits,
                                 u32 *bit_off,
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index 83934e33e5b0..69f85ae392dc 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -82,6 +82,8 @@ static struct vm_operations_struct ocfs2_file_vm_ops = {
 int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
 {
+        int ret = 0, lock_level = 0;
        /* We don't want to support shared writable mappings yet. */
        if (((vma->vm_flags & VM_SHARED) || (vma->vm_flags & VM_MAYSHARE))
            && ((vma->vm_flags & VM_WRITE) || (vma->vm_flags & VM_MAYWRITE))) {
@@ -91,7 +93,14 @@ int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
                return -EINVAL;
        }
-        file_accessed(file);
+        ret = ocfs2_meta_lock_atime(file->f_dentry->d_inode,
+                                    file->f_vfsmnt, &lock_level);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ocfs2_meta_unlock(file->f_dentry->d_inode, lock_level);
+out:
        vma->vm_ops = &ocfs2_file_vm_ops;
        return 0;
 }
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index a57b751d4f40..21db45ddf144 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -75,12 +75,12 @@ static int inline ocfs2_search_dirblock(struct buffer_head *bh,
                                        unsigned long offset,
                                        struct ocfs2_dir_entry **res_dir);
-static int ocfs2_delete_entry(struct ocfs2_journal_handle *handle,
+static int ocfs2_delete_entry(handle_t *handle,
                              struct inode *dir,
                              struct ocfs2_dir_entry *de_del,
                              struct buffer_head *bh);
-static int __ocfs2_add_entry(struct ocfs2_journal_handle *handle,
+static int __ocfs2_add_entry(handle_t *handle,
                             struct inode *dir,
                             const char *name, int namelen,
                             struct inode *inode, u64 blkno,
@@ -93,43 +93,37 @@ static int ocfs2_mknod_locked(struct ocfs2_super *osb,
                              dev_t dev,
                              struct buffer_head **new_fe_bh,
                              struct buffer_head *parent_fe_bh,
-                              struct ocfs2_journal_handle *handle,
+                              handle_t *handle,
                              struct inode **ret_inode,
                              struct ocfs2_alloc_context *inode_ac);
 static int ocfs2_fill_new_dir(struct ocfs2_super *osb,
-                              struct ocfs2_journal_handle *handle,
+                              handle_t *handle,
                              struct inode *parent,
                              struct inode *inode,
                              struct buffer_head *fe_bh,
                              struct ocfs2_alloc_context *data_ac);
-static int ocfs2_double_lock(struct ocfs2_super *osb,
-                             struct ocfs2_journal_handle *handle,
-                             struct buffer_head **bh1,
-                             struct inode *inode1,
-                             struct buffer_head **bh2,
-                             struct inode *inode2);
 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
-                                    struct ocfs2_journal_handle *handle,
+                                    struct inode **ret_orphan_dir,
                                    struct inode *inode,
                                    char *name,
                                    struct buffer_head **de_bh);
 static int ocfs2_orphan_add(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
+                            handle_t *handle,
                            struct inode *inode,
                            struct ocfs2_dinode *fe,
                            char *name,
-                            struct buffer_head *de_bh);
+                            struct buffer_head *de_bh,
+                            struct inode *orphan_dir_inode);
 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
-                                     struct ocfs2_journal_handle *handle,
+                                     handle_t *handle,
                                     struct inode *inode,
                                     const char *symname);
-static inline int ocfs2_add_entry(struct ocfs2_journal_handle *handle,
+static inline int ocfs2_add_entry(handle_t *handle,
                                  struct dentry *dentry,
                                  struct inode *inode, u64 blkno,
                                  struct buffer_head *parent_fe_bh,
@@ -165,7 +159,7 @@ static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
        mlog(0, "find name %.*s in directory %llu\n", dentry->d_name.len,
             dentry->d_name.name, (unsigned long long)OCFS2_I(dir)->ip_blkno);
-        status = ocfs2_meta_lock(dir, NULL, NULL, 0);
+        status = ocfs2_meta_lock(dir, NULL, 0);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
@@ -242,7 +236,7 @@ bail:
 }
 static int ocfs2_fill_new_dir(struct ocfs2_super *osb,
-                              struct ocfs2_journal_handle *handle,
+                              handle_t *handle,
                              struct inode *parent,
                              struct inode *inode,
                              struct buffer_head *fe_bh,
@@ -317,7 +311,7 @@ static int ocfs2_mknod(struct inode *dir,
 {
        int status = 0;
        struct buffer_head *parent_fe_bh = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_super *osb;
        struct ocfs2_dinode *dirfe;
        struct buffer_head *new_fe_bh = NULL;
@@ -333,18 +327,11 @@ static int ocfs2_mknod(struct inode *dir,
        /* get our super block */
        osb = OCFS2_SB(dir->i_sb);
-        handle = ocfs2_alloc_handle(osb);
+        status = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto leave;
-        }
-        status = ocfs2_meta_lock(dir, handle, &parent_fe_bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
-                goto leave;
+                return status;
        }
        if (S_ISDIR(mode) && (dir->i_nlink >= OCFS2_LINK_MAX)) {
@@ -374,7 +361,7 @@ static int ocfs2_mknod(struct inode *dir,
        }
        /* reserve an inode spot */
-        status = ocfs2_reserve_new_inode(osb, handle, &inode_ac);
+        status = ocfs2_reserve_new_inode(osb, &inode_ac);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -384,7 +371,7 @@ static int ocfs2_mknod(struct inode *dir,
        /* are we making a directory? If so, reserve a cluster for his
         * 1st extent. */
        if (S_ISDIR(mode)) {
-                status = ocfs2_reserve_clusters(osb, handle, 1, &data_ac);
+                status = ocfs2_reserve_clusters(osb, 1, &data_ac);
                if (status < 0) {
                        if (status != -ENOSPC)
                                mlog_errno(status);
@@ -392,7 +379,7 @@ static int ocfs2_mknod(struct inode *dir,
                }
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_MKNOD_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_MKNOD_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -453,7 +440,9 @@ static int ocfs2_mknod(struct inode *dir,
        status = 0;
 leave:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
+        ocfs2_meta_unlock(dir, 1);
        if (status == -ENOSPC)
                mlog(0, "Disk is full\n");
@@ -487,7 +476,7 @@ static int ocfs2_mknod_locked(struct ocfs2_super *osb,
                              dev_t dev,
                              struct buffer_head **new_fe_bh,
                              struct buffer_head *parent_fe_bh,
-                              struct ocfs2_journal_handle *handle,
+                              handle_t *handle,
                              struct inode **ret_inode,
                              struct ocfs2_alloc_context *inode_ac)
 {
@@ -653,7 +642,7 @@ static int ocfs2_link(struct dentry *old_dentry,
                      struct inode *dir,
                      struct dentry *dentry)
 {
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle;
        struct inode *inode = old_dentry->d_inode;
        int err;
        struct buffer_head *fe_bh = NULL;
@@ -666,68 +655,60 @@ static int ocfs2_link(struct dentry *old_dentry,
                   old_dentry->d_name.len, old_dentry->d_name.name,
                   dentry->d_name.len, dentry->d_name.name);
-        if (S_ISDIR(inode->i_mode)) {
+        if (S_ISDIR(inode->i_mode))
-                err = -EPERM;
+                return -EPERM;
-                goto bail;
-        }
-        handle = ocfs2_alloc_handle(osb);
-        if (handle == NULL) {
-                err = -ENOMEM;
-                goto bail;
-        }
-        err = ocfs2_meta_lock(dir, handle, &parent_fe_bh, 1);
+        err = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
        if (err < 0) {
                if (err != -ENOENT)
                        mlog_errno(err);
-                goto bail;
+                return err;
        }
        if (!dir->i_nlink) {
                err = -ENOENT;
-                goto bail;
+                goto out;
        }
        err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
                                        dentry->d_name.len);
        if (err)
-                goto bail;
+                goto out;
        err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
                                           dentry->d_name.name,
                                           dentry->d_name.len, &de_bh);
        if (err < 0) {
                mlog_errno(err);
-                goto bail;
+                goto out;
        }
-        err = ocfs2_meta_lock(inode, handle, &fe_bh, 1);
+        err = ocfs2_meta_lock(inode, &fe_bh, 1);
        if (err < 0) {
                if (err != -ENOENT)
                        mlog_errno(err);
-                goto bail;
+                goto out;
        }
        fe = (struct ocfs2_dinode *) fe_bh->b_data;
        if (le16_to_cpu(fe->i_links_count) >= OCFS2_LINK_MAX) {
                err = -EMLINK;
-                goto bail;
+                goto out_unlock_inode;
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_LINK_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_LINK_CREDITS);
        if (IS_ERR(handle)) {
                err = PTR_ERR(handle);
                handle = NULL;
                mlog_errno(err);
-                goto bail;
+                goto out_unlock_inode;
        }
        err = ocfs2_journal_access(handle, inode, fe_bh,
                                   OCFS2_JOURNAL_ACCESS_WRITE);
        if (err < 0) {
                mlog_errno(err);
-                goto bail;
+                goto out_commit;
        }
        inc_nlink(inode);
@@ -741,7 +722,7 @@ static int ocfs2_link(struct dentry *old_dentry,
                le16_add_cpu(&fe->i_links_count, -1);
                drop_nlink(inode);
                mlog_errno(err);
-                goto bail;
+                goto out_commit;
        }
        err = ocfs2_add_entry(handle, dentry, inode,
@@ -751,21 +732,27 @@ static int ocfs2_link(struct dentry *old_dentry,
                le16_add_cpu(&fe->i_links_count, -1);
                drop_nlink(inode);
                mlog_errno(err);
-                goto bail;
+                goto out_commit;
        }
        err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
        if (err) {
                mlog_errno(err);
-                goto bail;
+                goto out_commit;
        }
        atomic_inc(&inode->i_count);
        dentry->d_op = &ocfs2_dentry_ops;
        d_instantiate(dentry, inode);
-bail:
-        if (handle)
+out_commit:
-                ocfs2_commit_trans(handle);
+        ocfs2_commit_trans(osb, handle);
+out_unlock_inode:
+        ocfs2_meta_unlock(inode, 1);
+out:
+        ocfs2_meta_unlock(dir, 1);
        if (de_bh)
                brelse(de_bh);
        if (fe_bh)
@@ -812,13 +799,15 @@ static int ocfs2_unlink(struct inode *dir,
                        struct dentry *dentry)
 {
        int status;
+        int child_locked = 0;
        struct inode *inode = dentry->d_inode;
+        struct inode *orphan_dir = NULL;
        struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
        u64 blkno;
        struct ocfs2_dinode *fe = NULL;
        struct buffer_head *fe_bh = NULL;
        struct buffer_head *parent_node_bh = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_dir_entry *dirent = NULL;
        struct buffer_head *dirent_bh = NULL;
        char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
@@ -833,22 +822,14 @@ static int ocfs2_unlink(struct inode *dir,
        if (inode == osb->root_inode) {
                mlog(0, "Cannot delete the root directory\n");
-                status = -EPERM;
+                return -EPERM;
-                goto leave;
        }
-        handle = ocfs2_alloc_handle(osb);
+        status = ocfs2_meta_lock(dir, &parent_node_bh, 1);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto leave;
-        }
-        status = ocfs2_meta_lock(dir, handle, &parent_node_bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
-                goto leave;
+                return status;
        }
        status = ocfs2_find_files_on_disk(dentry->d_name.name,
@@ -869,12 +850,13 @@ static int ocfs2_unlink(struct inode *dir,
                goto leave;
        }
-        status = ocfs2_meta_lock(inode, handle, &fe_bh, 1);
+        status = ocfs2_meta_lock(inode, &fe_bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
                goto leave;
        }
+        child_locked = 1;
        if (S_ISDIR(inode->i_mode)) {
                if (!ocfs2_empty_dir(inode)) {
@@ -895,7 +877,7 @@ static int ocfs2_unlink(struct inode *dir,
        }
        if (inode_is_unlinkable(inode)) {
-                status = ocfs2_prepare_orphan_dir(osb, handle, inode,
+                status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, inode,
                                                  orphan_name,
                                                  &orphan_entry_bh);
                if (status < 0) {
@@ -904,7 +886,7 @@ static int ocfs2_unlink(struct inode *dir,
                }
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_UNLINK_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_UNLINK_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -923,7 +905,7 @@ static int ocfs2_unlink(struct inode *dir,
        if (inode_is_unlinkable(inode)) {
                status = ocfs2_orphan_add(osb, handle, inode, fe, orphan_name,
-                                          orphan_entry_bh);
+                                          orphan_entry_bh, orphan_dir);
                if (status < 0) {
                        mlog_errno(status);
                        goto leave;
@@ -960,7 +942,19 @@ static int ocfs2_unlink(struct inode *dir,
 leave:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
+        if (child_locked)
+                ocfs2_meta_unlock(inode, 1);
+        ocfs2_meta_unlock(dir, 1);
+        if (orphan_dir) {
+                /* This was locked for us in ocfs2_prepare_orphan_dir() */
+                ocfs2_meta_unlock(orphan_dir, 1);
+                mutex_unlock(&orphan_dir->i_mutex);
+                iput(orphan_dir);
+        }
        if (fe_bh)
                brelse(fe_bh);
@@ -984,7 +978,6 @@ leave:
 * if they have the same id, then the 1st one is the only one locked.
 */
 static int ocfs2_double_lock(struct ocfs2_super *osb,
-                             struct ocfs2_journal_handle *handle,
                             struct buffer_head **bh1,
                             struct inode *inode1,
                             struct buffer_head **bh2,
@@ -1000,8 +993,6 @@ static int ocfs2_double_lock(struct ocfs2_super *osb,
                   (unsigned long long)oi1->ip_blkno,
                   (unsigned long long)oi2->ip_blkno);
-        BUG_ON(!handle);
        if (*bh1)
                *bh1 = NULL;
        if (*bh2)
@@ -1021,25 +1012,41 @@ static int ocfs2_double_lock(struct ocfs2_super *osb,
                        inode1 = tmpinode;
                }
                /* lock id2 */
-                status = ocfs2_meta_lock(inode2, handle, bh2, 1);
+                status = ocfs2_meta_lock(inode2, bh2, 1);
                if (status < 0) {
                        if (status != -ENOENT)
                                mlog_errno(status);
                        goto bail;
                }
        }
        /* lock id1 */
-        status = ocfs2_meta_lock(inode1, handle, bh1, 1);
+        status = ocfs2_meta_lock(inode1, bh1, 1);
        if (status < 0) {
+                /*
+                 * An error return must mean that no cluster locks
+                 * were held on function exit.
+                 */
+                if (oi1->ip_blkno != oi2->ip_blkno)
+                        ocfs2_meta_unlock(inode2, 1);
                if (status != -ENOENT)
                        mlog_errno(status);
-                goto bail;
        }
 bail:
        mlog_exit(status);
        return status;
 }
+static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
+{
+        ocfs2_meta_unlock(inode1, 1);
+        if (inode1 != inode2)
+                ocfs2_meta_unlock(inode2, 1);
+}
 #define PARENT_INO(buffer) \
        ((struct ocfs2_dir_entry *) \
         ((char *)buffer + \
@@ -1050,9 +1057,11 @@ static int ocfs2_rename(struct inode *old_dir,
                        struct inode *new_dir,
                        struct dentry *new_dentry)
 {
-        int status = 0, rename_lock = 0;
+        int status = 0, rename_lock = 0, parents_locked = 0;
+        int old_child_locked = 0, new_child_locked = 0;
        struct inode *old_inode = old_dentry->d_inode;
        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *orphan_dir = NULL;
        struct ocfs2_dinode *newfe = NULL;
        char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
        struct buffer_head *orphan_entry_bh = NULL;
@@ -1060,7 +1069,7 @@ static int ocfs2_rename(struct inode *old_dir,
        struct buffer_head *insert_entry_bh = NULL;
        struct ocfs2_super *osb = NULL;
        u64 newfe_blkno;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct buffer_head *old_dir_bh = NULL;
        struct buffer_head *new_dir_bh = NULL;
        struct ocfs2_dir_entry *old_de = NULL, *new_de = NULL; // dirent for old_dentry
@@ -1105,21 +1114,14 @@ static int ocfs2_rename(struct inode *old_dir,
                rename_lock = 1;
        }
-        handle = ocfs2_alloc_handle(osb);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        /* if old and new are the same, this'll just do one lock. */
-        status = ocfs2_double_lock(osb, handle,
+        status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
-                                  &old_dir_bh, old_dir,
+                                   &new_dir_bh, new_dir);
-                                  &new_dir_bh, new_dir);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
        }
+        parents_locked = 1;
        /* make sure both dirs have bhs
         * get an extra ref on old_dir_bh if old==new */
@@ -1140,12 +1142,13 @@ static int ocfs2_rename(struct inode *old_dir,
         * the vote thread on other nodes won't have to concurrently
         * downconvert the inode and the dentry locks.
         */
-        status = ocfs2_meta_lock(old_inode, handle, NULL, 1);
+        status = ocfs2_meta_lock(old_inode, NULL, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
                goto bail;
        }
+        old_child_locked = 1;
        status = ocfs2_remote_dentry_delete(old_dentry);
        if (status < 0) {
@@ -1231,12 +1234,13 @@ static int ocfs2_rename(struct inode *old_dir,
                        goto bail;
                }
-                status = ocfs2_meta_lock(new_inode, handle, &newfe_bh, 1);
+                status = ocfs2_meta_lock(new_inode, &newfe_bh, 1);
                if (status < 0) {
                        if (status != -ENOENT)
                                mlog_errno(status);
                        goto bail;
                }
+                new_child_locked = 1;
                status = ocfs2_remote_dentry_delete(new_dentry);
                if (status < 0) {
@@ -1252,7 +1256,7 @@ static int ocfs2_rename(struct inode *old_dir,
                     (unsigned long long)newfe_bh->b_blocknr : 0ULL);
                if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
-                        status = ocfs2_prepare_orphan_dir(osb, handle,
+                        status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
                                                          new_inode,
                                                          orphan_name,
                                                          &orphan_entry_bh);
@@ -1280,7 +1284,7 @@ static int ocfs2_rename(struct inode *old_dir,
                }
        }
-        handle = ocfs2_start_trans(osb, handle, OCFS2_RENAME_CREDITS);
+        handle = ocfs2_start_trans(osb, OCFS2_RENAME_CREDITS);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -1307,7 +1311,7 @@ static int ocfs2_rename(struct inode *old_dir,
                    (newfe->i_links_count == cpu_to_le16(1))){
                        status = ocfs2_orphan_add(osb, handle, new_inode,
                                                  newfe, orphan_name,
-                                                  orphan_entry_bh);
+                                                  orphan_entry_bh, orphan_dir);
                        if (status < 0) {
                                mlog_errno(status);
                                goto bail;
@@ -1424,7 +1428,23 @@ bail:
                ocfs2_rename_unlock(osb);
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
+        if (parents_locked)
+                ocfs2_double_unlock(old_dir, new_dir);
+        if (old_child_locked)
+                ocfs2_meta_unlock(old_inode, 1);
+        if (new_child_locked)
+                ocfs2_meta_unlock(new_inode, 1);
+        if (orphan_dir) {
+                /* This was locked for us in ocfs2_prepare_orphan_dir() */
+                ocfs2_meta_unlock(orphan_dir, 1);
+                mutex_unlock(&orphan_dir->i_mutex);
+                iput(orphan_dir);
+        }
        if (new_inode)
                sync_mapping_buffers(old_inode->i_mapping);
@@ -1458,7 +1478,7 @@ bail:
 * data, including the null terminator.
 */
 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
-                                     struct ocfs2_journal_handle *handle,
+                                     handle_t *handle,
                                     struct inode *inode,
                                     const char *symname)
 {
@@ -1573,7 +1593,7 @@ static int ocfs2_symlink(struct inode *dir,
        struct buffer_head *parent_fe_bh = NULL;
        struct ocfs2_dinode *fe = NULL;
        struct ocfs2_dinode *dirfe;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        struct ocfs2_alloc_context *inode_ac = NULL;
        struct ocfs2_alloc_context *data_ac = NULL;
@@ -1587,19 +1607,12 @@ static int ocfs2_symlink(struct inode *dir,
        credits = ocfs2_calc_symlink_credits(sb);
-        handle = ocfs2_alloc_handle(osb);
-        if (handle == NULL) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        /* lock the parent directory */
-        status = ocfs2_meta_lock(dir, handle, &parent_fe_bh, 1);
+        status = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
        if (status < 0) {
                if (status != -ENOENT)
                        mlog_errno(status);
-                goto bail;
+                return status;
        }
        dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
@@ -1622,7 +1635,7 @@ static int ocfs2_symlink(struct inode *dir,
                goto bail;
        }
-        status = ocfs2_reserve_new_inode(osb, handle, &inode_ac);
+        status = ocfs2_reserve_new_inode(osb, &inode_ac);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -1631,7 +1644,7 @@ static int ocfs2_symlink(struct inode *dir,
        /* don't reserve bitmap space for fast symlinks. */
        if (l > ocfs2_fast_symlink_chars(sb)) {
-                status = ocfs2_reserve_clusters(osb, handle, 1, &data_ac);
+                status = ocfs2_reserve_clusters(osb, 1, &data_ac);
                if (status < 0) {
                        if (status != -ENOSPC)
                                mlog_errno(status);
@@ -1639,7 +1652,7 @@ static int ocfs2_symlink(struct inode *dir,
                }
        }
-        handle = ocfs2_start_trans(osb, handle, credits);
+        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -1717,7 +1730,10 @@ static int ocfs2_symlink(struct inode *dir,
        d_instantiate(dentry, inode);
 bail:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
+        ocfs2_meta_unlock(dir, 1);
        if (new_fe_bh)
                brelse(new_fe_bh);
        if (parent_fe_bh)
@@ -1768,7 +1784,7 @@ int ocfs2_check_dir_entry(struct inode * dir,
 * If you pass me insert_bh, I'll skip the search of the other dir
 * blocks and put the record in there.
 */
-static int __ocfs2_add_entry(struct ocfs2_journal_handle *handle,
+static int __ocfs2_add_entry(handle_t *handle,
                             struct inode *dir,
                             const char *name, int namelen,
                             struct inode *inode, u64 blkno,
@@ -1854,7 +1870,7 @@ bail:
 * ocfs2_delete_entry deletes a directory entry by merging it with the
 * previous entry
 */
-static int ocfs2_delete_entry(struct ocfs2_journal_handle *handle,
+static int ocfs2_delete_entry(handle_t *handle,
                              struct inode *dir,
                              struct ocfs2_dir_entry *de_del,
                              struct buffer_head *bh)
@@ -2085,19 +2101,19 @@ bail:
 }
 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
-                                    struct ocfs2_journal_handle *handle,
+                                    struct inode **ret_orphan_dir,
                                    struct inode *inode,
                                    char *name,
                                    struct buffer_head **de_bh)
 {
-        struct inode *orphan_dir_inode = NULL;
+        struct inode *orphan_dir_inode;
        struct buffer_head *orphan_dir_bh = NULL;
        int status = 0;
        status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
        if (status < 0) {
                mlog_errno(status);
-                goto leave;
+                return status;
        }
        orphan_dir_inode = ocfs2_get_system_file_inode(osb,
@@ -2106,11 +2122,12 @@ static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
        if (!orphan_dir_inode) {
                status = -ENOENT;
                mlog_errno(status);
-                goto leave;
+                return status;
        }
-        ocfs2_handle_add_inode(handle, orphan_dir_inode);
+        mutex_lock(&orphan_dir_inode->i_mutex);
-        status = ocfs2_meta_lock(orphan_dir_inode, handle, &orphan_dir_bh, 1);
+        status = ocfs2_meta_lock(orphan_dir_inode, &orphan_dir_bh, 1);
        if (status < 0) {
                mlog_errno(status);
                goto leave;
@@ -2120,13 +2137,19 @@ static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
                                              orphan_dir_bh, name,
                                              OCFS2_ORPHAN_NAMELEN, de_bh);
        if (status < 0) {
+                ocfs2_meta_unlock(orphan_dir_inode, 1);
                mlog_errno(status);
                goto leave;
        }
+        *ret_orphan_dir = orphan_dir_inode;
 leave:
-        if (orphan_dir_inode)
+        if (status) {
+                mutex_unlock(&orphan_dir_inode->i_mutex);
                iput(orphan_dir_inode);
+        }
        if (orphan_dir_bh)
                brelse(orphan_dir_bh);
@@ -2136,28 +2159,19 @@ leave:
 }
 static int ocfs2_orphan_add(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
+                            handle_t *handle,
                            struct inode *inode,
                            struct ocfs2_dinode *fe,
                            char *name,
-                            struct buffer_head *de_bh)
+                            struct buffer_head *de_bh,
+                            struct inode *orphan_dir_inode)
 {
-        struct inode *orphan_dir_inode = NULL;
        struct buffer_head *orphan_dir_bh = NULL;
        int status = 0;
        struct ocfs2_dinode *orphan_fe;
        mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
-        orphan_dir_inode = ocfs2_get_system_file_inode(osb,
-                                                       ORPHAN_DIR_SYSTEM_INODE,
-                                                       osb->slot_num);
-        if (!orphan_dir_inode) {
-                status = -ENOENT;
-                mlog_errno(status);
-                goto leave;
-        }
        status = ocfs2_read_block(osb,
                                  OCFS2_I(orphan_dir_inode)->ip_blkno,
                                  &orphan_dir_bh, OCFS2_BH_CACHED,
@@ -2209,9 +2223,6 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
             (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
 leave:
-        if (orphan_dir_inode)
-                iput(orphan_dir_inode);
        if (orphan_dir_bh)
                brelse(orphan_dir_bh);
@@ -2221,7 +2232,7 @@ leave:
 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
 int ocfs2_orphan_del(struct ocfs2_super *osb,
-                     struct ocfs2_journal_handle *handle,
+                     handle_t *handle,
                     struct inode *orphan_dir_inode,
                     struct inode *inode,
                     struct buffer_head *orphan_dir_bh)
@@ -2300,4 +2311,5 @@ struct inode_operations ocfs2_dir_iops = {
        .rename         = ocfs2_rename,
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
+        .permission     = ocfs2_permission,
 };
diff --git a/fs/ocfs2/namei.h b/fs/ocfs2/namei.h
index deaaa97dbf0b..8425944fcccd 100644
--- a/fs/ocfs2/namei.h
+++ b/fs/ocfs2/namei.h
@@ -39,7 +39,7 @@ struct buffer_head *ocfs2_find_entry(const char *name,
                                     struct inode *dir,
                                     struct ocfs2_dir_entry **res_dir);
 int ocfs2_orphan_del(struct ocfs2_super *osb,
-                     struct ocfs2_journal_handle *handle,
+                     handle_t *handle,
                     struct inode *orphan_dir_inode,
                     struct inode *inode,
                     struct buffer_head *orphan_dir_bh);
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index 0462a7f4e21b..b767fd7da6eb 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -34,6 +34,7 @@
 #include <linux/workqueue.h>
 #include <linux/kref.h>
 #include <linux/mutex.h>
+#include <linux/jbd.h>
 #include "cluster/nodemanager.h"
 #include "cluster/heartbeat.h"
@@ -179,9 +180,9 @@ enum ocfs2_mount_options
 #define OCFS2_OSB_SOFT_RO       0x0001
 #define OCFS2_OSB_HARD_RO       0x0002
 #define OCFS2_OSB_ERROR_FS      0x0004
+#define OCFS2_DEFAULT_ATIME_QUANTUM     60
 struct ocfs2_journal;
-struct ocfs2_journal_handle;
 struct ocfs2_super
 {
        struct task_struct *commit_task;
@@ -218,6 +219,7 @@ struct ocfs2_super
        unsigned long osb_flags;
        unsigned long s_mount_opt;
+        unsigned int s_atime_quantum;
        u16 max_slots;
        s16 node_num;
@@ -283,7 +285,7 @@ struct ocfs2_super
        /* Truncate log info */
        struct inode                    *osb_tl_inode;
        struct buffer_head              *osb_tl_bh;
-        struct work_struct              osb_truncate_log_wq;
+        struct delayed_work             osb_truncate_log_wq;
        struct ocfs2_node_map           osb_recovering_orphan_dirs;
        unsigned int                    *osb_orphan_wipes;
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index 9d91e66f51a9..000d71cca6c5 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -49,7 +49,7 @@
 static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg);
 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe);
 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl);
-static int ocfs2_block_group_fill(struct ocfs2_journal_handle *handle,
+static int ocfs2_block_group_fill(handle_t *handle,
                                  struct inode *alloc_inode,
                                  struct buffer_head *bg_bh,
                                  u64 group_blkno,
@@ -59,9 +59,6 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
                                   struct inode *alloc_inode,
                                   struct buffer_head *bh);
-static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
-                                       struct ocfs2_alloc_context *ac);
 static int ocfs2_cluster_group_search(struct inode *inode,
                                      struct buffer_head *group_bh,
                                      u32 bits_wanted, u32 min_bits,
@@ -72,6 +69,7 @@ static int ocfs2_block_group_search(struct inode *inode,
                                    u16 *bit_off, u16 *bits_found);
 static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                                     struct ocfs2_alloc_context *ac,
+                                     handle_t *handle,
                                     u32 bits_wanted,
                                     u32 min_bits,
                                     u16 *bit_off,
@@ -79,20 +77,20 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                                     u64 *bg_blkno);
 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh,
                                         int nr);
-static inline int ocfs2_block_group_set_bits(struct ocfs2_journal_handle *handle,
+static inline int ocfs2_block_group_set_bits(handle_t *handle,
                                             struct inode *alloc_inode,
                                             struct ocfs2_group_desc *bg,
                                             struct buffer_head *group_bh,
                                             unsigned int bit_off,
                                             unsigned int num_bits);
-static inline int ocfs2_block_group_clear_bits(struct ocfs2_journal_handle *handle,
+static inline int ocfs2_block_group_clear_bits(handle_t *handle,
                                               struct inode *alloc_inode,
                                               struct ocfs2_group_desc *bg,
                                               struct buffer_head *group_bh,
                                               unsigned int bit_off,
                                               unsigned int num_bits);
-static int ocfs2_relink_block_group(struct ocfs2_journal_handle *handle,
+static int ocfs2_relink_block_group(handle_t *handle,
                                    struct inode *alloc_inode,
                                    struct buffer_head *fe_bh,
                                    struct buffer_head *bg_bh,
@@ -100,7 +98,7 @@ static int ocfs2_relink_block_group(struct ocfs2_journal_handle *handle,
                                    u16 chain);
 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
                                                     u32 wanted);
-static int ocfs2_free_suballoc_bits(struct ocfs2_journal_handle *handle,
+static int ocfs2_free_suballoc_bits(handle_t *handle,
                                    struct inode *alloc_inode,
                                    struct buffer_head *alloc_bh,
                                    unsigned int start_bit,
@@ -120,8 +118,16 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
 void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
 {
-        if (ac->ac_inode)
+        struct inode *inode = ac->ac_inode;
-                iput(ac->ac_inode);
+        if (inode) {
+                if (ac->ac_which != OCFS2_AC_USE_LOCAL)
+                        ocfs2_meta_unlock(inode, 1);
+                mutex_unlock(&inode->i_mutex);
+                iput(inode);
+        }
        if (ac->ac_bh)
                brelse(ac->ac_bh);
        kfree(ac);
@@ -190,7 +196,7 @@ static int ocfs2_check_group_descriptor(struct super_block *sb,
        return 0;
 }
-static int ocfs2_block_group_fill(struct ocfs2_journal_handle *handle,
+static int ocfs2_block_group_fill(handle_t *handle,
                                  struct inode *alloc_inode,
                                  struct buffer_head *bg_bh,
                                  u64 group_blkno,
@@ -273,7 +279,7 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
        struct ocfs2_chain_list *cl;
        struct ocfs2_alloc_context *ac = NULL;
-        struct ocfs2_journal_handle *handle = NULL;
+        handle_t *handle = NULL;
        u32 bit_off, num_bits;
        u16 alloc_rec;
        u64 bg_blkno;
@@ -284,16 +290,8 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
        mlog_entry_void();
-        handle = ocfs2_alloc_handle(osb);
-        if (!handle) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
        cl = &fe->id2.i_chain;
        status = ocfs2_reserve_clusters(osb,
-                                        handle,
                                        le16_to_cpu(cl->cl_cpg),
                                        &ac);
        if (status < 0) {
@@ -304,7 +302,7 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
        credits = ocfs2_calc_group_alloc_credits(osb->sb,
                                                 le16_to_cpu(cl->cl_cpg));
-        handle = ocfs2_start_trans(osb, handle, credits);
+        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
                handle = NULL;
@@ -389,7 +387,7 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
        status = 0;
 bail:
        if (handle)
-                ocfs2_commit_trans(handle);
+                ocfs2_commit_trans(osb, handle);
        if (ac)
                ocfs2_free_alloc_context(ac);
@@ -402,27 +400,38 @@ bail:
 }
 static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
-                                       struct ocfs2_alloc_context *ac)
+                                       struct ocfs2_alloc_context *ac,
+                                       int type,
+                                       u32 slot)
 {
        int status;
        u32 bits_wanted = ac->ac_bits_wanted;
-        struct inode *alloc_inode = ac->ac_inode;
+        struct inode *alloc_inode;
        struct buffer_head *bh = NULL;
-        struct ocfs2_journal_handle *handle = ac->ac_handle;
        struct ocfs2_dinode *fe;
        u32 free_bits;
        mlog_entry_void();
-        BUG_ON(handle->flags & OCFS2_HANDLE_STARTED);
+        alloc_inode = ocfs2_get_system_file_inode(osb, type, slot);
+        if (!alloc_inode) {
+                mlog_errno(-EINVAL);
+                return -EINVAL;
+        }
-        ocfs2_handle_add_inode(handle, alloc_inode);
+        mutex_lock(&alloc_inode->i_mutex);
-        status = ocfs2_meta_lock(alloc_inode, handle, &bh, 1);
+        status = ocfs2_meta_lock(alloc_inode, &bh, 1);
        if (status < 0) {
+                mutex_unlock(&alloc_inode->i_mutex);
+                iput(alloc_inode);
                mlog_errno(status);
-                goto bail;
+                return status;
        }
+        ac->ac_inode = alloc_inode;
        fe = (struct ocfs2_dinode *) bh->b_data;
        if (!OCFS2_IS_VALID_DINODE(fe)) {
                OCFS2_RO_ON_INVALID_DINODE(alloc_inode->i_sb, fe);
@@ -473,12 +482,11 @@ bail:
 }
 int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
-                               struct ocfs2_journal_handle *handle,
                               struct ocfs2_dinode *fe,
                               struct ocfs2_alloc_context **ac)
 {
        int status;
-        struct inode *alloc_inode = NULL;
+        u32 slot;
        *ac = kcalloc(1, sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
        if (!(*ac)) {
@@ -488,28 +496,18 @@ int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
        }
        (*ac)->ac_bits_wanted = ocfs2_extend_meta_needed(fe);
-        (*ac)->ac_handle = handle;
        (*ac)->ac_which = OCFS2_AC_USE_META;
 #ifndef OCFS2_USE_ALL_METADATA_SUBALLOCATORS
-        alloc_inode = ocfs2_get_system_file_inode(osb,
+        slot = 0;
-                                                  EXTENT_ALLOC_SYSTEM_INODE,
-                                                  0);
 #else
-        alloc_inode = ocfs2_get_system_file_inode(osb,
+        slot = osb->slot_num;
-                                                  EXTENT_ALLOC_SYSTEM_INODE,
-                                                  osb->slot_num);
 #endif
-        if (!alloc_inode) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
-        (*ac)->ac_inode = igrab(alloc_inode);
        (*ac)->ac_group_search = ocfs2_block_group_search;
-        status = ocfs2_reserve_suballoc_bits(osb, (*ac));
+        status = ocfs2_reserve_suballoc_bits(osb, (*ac),
+                                             EXTENT_ALLOC_SYSTEM_INODE, slot);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -523,19 +521,14 @@ bail:
                *ac = NULL;
        }
-        if (alloc_inode)
-                iput(alloc_inode);
        mlog_exit(status);
        return status;
 }
 int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
                            struct ocfs2_alloc_context **ac)
 {
        int status;
-        struct inode *alloc_inode = NULL;
        *ac = kcalloc(1, sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
        if (!(*ac)) {
@@ -545,22 +538,13 @@ int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
        }
        (*ac)->ac_bits_wanted = 1;
-        (*ac)->ac_handle = handle;
        (*ac)->ac_which = OCFS2_AC_USE_INODE;
-        alloc_inode = ocfs2_get_system_file_inode(osb,
-                                                  INODE_ALLOC_SYSTEM_INODE,
-                                                  osb->slot_num);
-        if (!alloc_inode) {
-                status = -ENOMEM;
-                mlog_errno(status);
-                goto bail;
-        }
-        (*ac)->ac_inode = igrab(alloc_inode);
        (*ac)->ac_group_search = ocfs2_block_group_search;
-        status = ocfs2_reserve_suballoc_bits(osb, *ac);
+        status = ocfs2_reserve_suballoc_bits(osb, *ac,
+                                             INODE_ALLOC_SYSTEM_INODE,
+                                             osb->slot_num);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -574,9 +558,6 @@ bail:
                *ac = NULL;
        }
-        if (alloc_inode)
-                iput(alloc_inode);
        mlog_exit(status);
        return status;
 }
@@ -588,20 +569,17 @@ int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
 {
        int status;
-        ac->ac_inode = ocfs2_get_system_file_inode(osb,
-                                                   GLOBAL_BITMAP_SYSTEM_INODE,
-                                                   OCFS2_INVALID_SLOT);
-        if (!ac->ac_inode) {
-                status = -EINVAL;
-                mlog(ML_ERROR, "Could not get bitmap inode!\n");
-                goto bail;
-        }
        ac->ac_which = OCFS2_AC_USE_MAIN;
        ac->ac_group_search = ocfs2_cluster_group_search;
-        status = ocfs2_reserve_suballoc_bits(osb, ac);
+        status = ocfs2_reserve_suballoc_bits(osb, ac,
-        if (status < 0 && status != -ENOSPC)
+                                             GLOBAL_BITMAP_SYSTEM_INODE,
+                                             OCFS2_INVALID_SLOT);
+        if (status < 0 && status != -ENOSPC) {
                mlog_errno(status);
+                goto bail;
+        }
 bail:
        return status;
 }
@@ -610,7 +588,6 @@ bail:
 * use so we figure it out for them, but unfortunately this clutters
 * things a bit. */
 int ocfs2_reserve_clusters(struct ocfs2_super *osb,
-                           struct ocfs2_journal_handle *handle,
                           u32 bits_wanted,
                           struct ocfs2_alloc_context **ac)
 {
@@ -618,8 +595,6 @@ int ocfs2_reserve_clusters(struct ocfs2_super *osb,
        mlog_entry_void();
-        BUG_ON(!handle);
        *ac = kcalloc(1, sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
        if (!(*ac)) {
                status = -ENOMEM;
@@ -628,12 +603,10 @@ int ocfs2_reserve_clusters(struct ocfs2_super *osb,
        }
        (*ac)->ac_bits_wanted = bits_wanted;
-        (*ac)->ac_handle = handle;
        status = -ENOSPC;
        if (ocfs2_alloc_should_use_local(osb, bits_wanted)) {
                status = ocfs2_reserve_local_alloc_bits(osb,
-                                                        handle,
                                                        bits_wanted,
                                                        *ac);
                if ((status < 0) && (status != -ENOSPC)) {
@@ -774,7 +747,7 @@ static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb,
        return status;
 }
-static inline int ocfs2_block_group_set_bits(struct ocfs2_journal_handle *handle,
+static inline int ocfs2_block_group_set_bits(handle_t *handle,
                                             struct inode *alloc_inode,
                                             struct ocfs2_group_desc *bg,
                                             struct buffer_head *group_bh,
@@ -845,7 +818,7 @@ static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl)
        return best;
 }
-static int ocfs2_relink_block_group(struct ocfs2_journal_handle *handle,
+static int ocfs2_relink_block_group(handle_t *handle,
                                    struct inode *alloc_inode,
                                    struct buffer_head *fe_bh,
                                    struct buffer_head *bg_bh,
@@ -1025,7 +998,7 @@ static int ocfs2_block_group_search(struct inode *inode,
 }
 static int ocfs2_alloc_dinode_update_counts(struct inode *inode,
-                                       struct ocfs2_journal_handle *handle,
+                                       handle_t *handle,
                                       struct buffer_head *di_bh,
                                       u32 num_bits,
                                       u16 chain)
@@ -1055,6 +1028,7 @@ out:
 }
 static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
+                                  handle_t *handle,
                                  u32 bits_wanted,
                                  u32 min_bits,
                                  u16 *bit_off,
@@ -1067,7 +1041,6 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
        struct buffer_head *group_bh = NULL;
        struct ocfs2_group_desc *gd;
        struct inode *alloc_inode = ac->ac_inode;
-        struct ocfs2_journal_handle *handle = ac->ac_handle;
        ret = ocfs2_read_block(OCFS2_SB(alloc_inode->i_sb), gd_blkno,
                               &group_bh, OCFS2_BH_CACHED, alloc_inode);
@@ -1115,6 +1088,7 @@ out:
 }
 static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
+                              handle_t *handle,
                              u32 bits_wanted,
                              u32 min_bits,
                              u16 *bit_off,
@@ -1126,7 +1100,6 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
        u16 chain, tmp_bits;
        u32 tmp_used;
        u64 next_group;
-        struct ocfs2_journal_handle *handle = ac->ac_handle;
        struct inode *alloc_inode = ac->ac_inode;
        struct buffer_head *group_bh = NULL;
        struct buffer_head *prev_group_bh = NULL;
@@ -1272,6 +1245,7 @@ bail:
 /* will give out up to bits_wanted contiguous bits. */
 static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                                     struct ocfs2_alloc_context *ac,
+                                     handle_t *handle,
                                     u32 bits_wanted,
                                     u32 min_bits,
                                     u16 *bit_off,
@@ -1313,8 +1287,8 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                 * by jumping straight to the most recently used
                 * allocation group. This helps us mantain some
                 * contiguousness across allocations. */
-                status = ocfs2_search_one_group(ac, bits_wanted, min_bits,
+                status = ocfs2_search_one_group(ac, handle, bits_wanted,
-                                                bit_off, num_bits,
+                                                min_bits, bit_off, num_bits,
                                                hint_blkno, &bits_left);
                if (!status) {
                        /* Be careful to update *bg_blkno here as the
@@ -1336,7 +1310,7 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
        ac->ac_chain = victim;
        ac->ac_allow_chain_relink = 1;
-        status = ocfs2_search_chain(ac, bits_wanted, min_bits, bit_off,
+        status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, bit_off,
                                    num_bits, bg_blkno, &bits_left);
        if (!status)
                goto set_hint;
@@ -1360,7 +1334,7 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                        continue;
                ac->ac_chain = i;
-                status = ocfs2_search_chain(ac, bits_wanted, min_bits,
+                status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
                                            bit_off, num_bits, bg_blkno,
                                            &bits_left);
                if (!status)
@@ -1388,7 +1362,7 @@ bail:
 }
 int ocfs2_claim_metadata(struct ocfs2_super *osb,
-                         struct ocfs2_journal_handle *handle,
+                         handle_t *handle,
                         struct ocfs2_alloc_context *ac,
                         u32 bits_wanted,
                         u16 *suballoc_bit_start,
@@ -1401,10 +1375,10 @@ int ocfs2_claim_metadata(struct ocfs2_super *osb,
        BUG_ON(!ac);
        BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted));
        BUG_ON(ac->ac_which != OCFS2_AC_USE_META);
-        BUG_ON(ac->ac_handle != handle);
        status = ocfs2_claim_suballoc_bits(osb,
                                           ac,
+                                           handle,
                                           bits_wanted,
                                           1,
                                           suballoc_bit_start,
@@ -1425,7 +1399,7 @@ bail:
 }
 int ocfs2_claim_new_inode(struct ocfs2_super *osb,
-                          struct ocfs2_journal_handle *handle,
+                          handle_t *handle,
                          struct ocfs2_alloc_context *ac,
                          u16 *suballoc_bit,
                          u64 *fe_blkno)
@@ -1440,10 +1414,10 @@ int ocfs2_claim_new_inode(struct ocfs2_super *osb,
        BUG_ON(ac->ac_bits_given != 0);
        BUG_ON(ac->ac_bits_wanted != 1);
        BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
-        BUG_ON(ac->ac_handle != handle);
        status = ocfs2_claim_suballoc_bits(osb,
                                           ac,
+                                           handle,
                                           1,
                                           1,
                                           suballoc_bit,
@@ -1528,7 +1502,7 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
 * of any size.
 */
 int ocfs2_claim_clusters(struct ocfs2_super *osb,
-                         struct ocfs2_journal_handle *handle,
+                         handle_t *handle,
                         struct ocfs2_alloc_context *ac,
                         u32 min_clusters,
                         u32 *cluster_start,
@@ -1546,7 +1520,6 @@ int ocfs2_claim_clusters(struct ocfs2_super *osb,
        BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL
               && ac->ac_which != OCFS2_AC_USE_MAIN);
-        BUG_ON(ac->ac_handle != handle);
        if (ac->ac_which == OCFS2_AC_USE_LOCAL) {
                status = ocfs2_claim_local_alloc_bits(osb,
@@ -1572,6 +1545,7 @@ int ocfs2_claim_clusters(struct ocfs2_super *osb,
                status = ocfs2_claim_suballoc_bits(osb,
                                                   ac,
+                                                   handle,
                                                   bits_wanted,
                                                   min_clusters,
                                                   &bg_bit_off,
@@ -1598,7 +1572,7 @@ bail:
        return status;
 }
-static inline int ocfs2_block_group_clear_bits(struct ocfs2_journal_handle *handle,
+static inline int ocfs2_block_group_clear_bits(handle_t *handle,
                                               struct inode *alloc_inode,
                                               struct ocfs2_group_desc *bg,
                                               struct buffer_head *group_bh,
@@ -1653,7 +1627,7 @@ bail:
 /*
 * expects the suballoc inode to already be locked.
 */
-static int ocfs2_free_suballoc_bits(struct ocfs2_journal_handle *handle,
+static int ocfs2_free_suballoc_bits(handle_t *handle,
                                    struct inode *alloc_inode,
                                    struct buffer_head *alloc_bh,
                                    unsigned int start_bit,
@@ -1737,7 +1711,7 @@ static inline u64 ocfs2_which_suballoc_group(u64 block, unsigned int bit)
        return group;
 }
-int ocfs2_free_dinode(struct ocfs2_journal_handle *handle,
+int ocfs2_free_dinode(handle_t *handle,
                      struct inode *inode_alloc_inode,
                      struct buffer_head *inode_alloc_bh,
                      struct ocfs2_dinode *di)
@@ -1750,7 +1724,7 @@ int ocfs2_free_dinode(struct ocfs2_journal_handle *handle,
                                        inode_alloc_bh, bit, bg_blkno, 1);
 }
-int ocfs2_free_extent_block(struct ocfs2_journal_handle *handle,
+int ocfs2_free_extent_block(handle_t *handle,
                            struct inode *eb_alloc_inode,
                            struct buffer_head *eb_alloc_bh,
                            struct ocfs2_extent_block *eb)
@@ -1763,7 +1737,7 @@ int ocfs2_free_extent_block(struct ocfs2_journal_handle *handle,
                                        bit, bg_blkno, 1);
 }
-int ocfs2_free_clusters(struct ocfs2_journal_handle *handle,
+int ocfs2_free_clusters(handle_t *handle,
                       struct inode *bitmap_inode,
                       struct buffer_head *bitmap_bh,
                       u64 start_blk,
diff --git a/fs/ocfs2/suballoc.h b/fs/ocfs2/suballoc.h
index c787838d1052..1a3c94cb9250 100644
--- a/fs/ocfs2/suballoc.h
+++ b/fs/ocfs2/suballoc.h
@@ -43,7 +43,6 @@ struct ocfs2_alloc_context {
 #define OCFS2_AC_USE_INODE 3
 #define OCFS2_AC_USE_META  4
        u32    ac_which;
-        struct ocfs2_journal_handle *ac_handle;
        /* these are used by the chain search */
        u16    ac_chain;
@@ -60,45 +59,42 @@ static inline int ocfs2_alloc_context_bits_left(struct ocfs2_alloc_context *ac)
 }
 int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
-                               struct ocfs2_journal_handle *handle,
                               struct ocfs2_dinode *fe,
                               struct ocfs2_alloc_context **ac);
 int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
-                            struct ocfs2_journal_handle *handle,
                            struct ocfs2_alloc_context **ac);
 int ocfs2_reserve_clusters(struct ocfs2_super *osb,
-                           struct ocfs2_journal_handle *handle,
                           u32 bits_wanted,
                           struct ocfs2_alloc_context **ac);
 int ocfs2_claim_metadata(struct ocfs2_super *osb,
-                         struct ocfs2_journal_handle *handle,
+                         handle_t *handle,
                         struct ocfs2_alloc_context *ac,
                         u32 bits_wanted,
                         u16 *suballoc_bit_start,
                         u32 *num_bits,
                         u64 *blkno_start);
 int ocfs2_claim_new_inode(struct ocfs2_super *osb,
-                          struct ocfs2_journal_handle *handle,
+                          handle_t *handle,
                          struct ocfs2_alloc_context *ac,
                          u16 *suballoc_bit,
                          u64 *fe_blkno);
 int ocfs2_claim_clusters(struct ocfs2_super *osb,
-                         struct ocfs2_journal_handle *handle,
+                         handle_t *handle,
                         struct ocfs2_alloc_context *ac,
                         u32 min_clusters,
                         u32 *cluster_start,
                         u32 *num_clusters);
-int ocfs2_free_dinode(struct ocfs2_journal_handle *handle,
+int ocfs2_free_dinode(handle_t *handle,
                      struct inode *inode_alloc_inode,
                      struct buffer_head *inode_alloc_bh,
                      struct ocfs2_dinode *di);
-int ocfs2_free_extent_block(struct ocfs2_journal_handle *handle,
+int ocfs2_free_extent_block(handle_t *handle,
                            struct inode *eb_alloc_inode,
                            struct buffer_head *eb_alloc_bh,
                            struct ocfs2_extent_block *eb);
-int ocfs2_free_clusters(struct ocfs2_journal_handle *handle,
+int ocfs2_free_clusters(handle_t *handle,
                        struct inode *bitmap_inode,
                        struct buffer_head *bitmap_bh,
                        u64 start_blk,
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 76b46ebbb10c..4bf39540e652 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -68,9 +68,7 @@
 #include "buffer_head_io.h"
-static kmem_cache_t *ocfs2_inode_cachep = NULL;
+static struct kmem_cache *ocfs2_inode_cachep = NULL;
-kmem_cache_t *ocfs2_lock_cache = NULL;
 /* OCFS2 needs to schedule several differnt types of work which
 * require cluster locking, disk I/O, recovery waits, etc. Since these
@@ -141,6 +139,7 @@ enum {
        Opt_hb_local,
        Opt_data_ordered,
        Opt_data_writeback,
+        Opt_atime_quantum,
        Opt_err,
 };
@@ -154,6 +153,7 @@ static match_table_t tokens = {
        {Opt_hb_local, OCFS2_HB_LOCAL},
        {Opt_data_ordered, "data=ordered"},
        {Opt_data_writeback, "data=writeback"},
+        {Opt_atime_quantum, "atime_quantum=%u"},
        {Opt_err, NULL}
 };
@@ -303,7 +303,7 @@ static struct inode *ocfs2_alloc_inode(struct super_block *sb)
 {
        struct ocfs2_inode_info *oi;
-        oi = kmem_cache_alloc(ocfs2_inode_cachep, SLAB_NOFS);
+        oi = kmem_cache_alloc(ocfs2_inode_cachep, GFP_NOFS);
        if (!oi)
                return NULL;
@@ -707,6 +707,7 @@ static int ocfs2_parse_options(struct super_block *sb,
        while ((p = strsep(&options, ",")) != NULL) {
                int token, option;
                substring_t args[MAX_OPT_ARGS];
+                struct ocfs2_super * osb = OCFS2_SB(sb);
                if (!*p)
                        continue;
@@ -747,6 +748,16 @@ static int ocfs2_parse_options(struct super_block *sb,
                case Opt_data_writeback:
                        *mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
                        break;
+                case Opt_atime_quantum:
+                        if (match_int(&args[0], &option)) {
+                                status = 0;
+                                goto bail;
+                        }
+                        if (option >= 0)
+                                osb->s_atime_quantum = option;
+                        else
+                                osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
+                        break;
                default:
                        mlog(ML_ERROR,
                             "Unrecognized mount option \"%s\" "
@@ -867,7 +878,7 @@ static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
                goto bail;
        }
-        status = ocfs2_meta_lock(inode, NULL, &bh, 0);
+        status = ocfs2_meta_lock(inode, &bh, 0);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -903,7 +914,7 @@ bail:
 }
 static void ocfs2_inode_init_once(void *data,
-                                  kmem_cache_t *cachep,
+                                  struct kmem_cache *cachep,
                                  unsigned long flags)
 {
        struct ocfs2_inode_info *oi = data;
@@ -914,9 +925,7 @@ static void ocfs2_inode_init_once(void *data,
                oi->ip_open_count = 0;
                spin_lock_init(&oi->ip_lock);
                ocfs2_extent_map_init(&oi->vfs_inode);
-                INIT_LIST_HEAD(&oi->ip_handle_list);
                INIT_LIST_HEAD(&oi->ip_io_markers);
-                oi->ip_handle = NULL;
                oi->ip_created_trans = 0;
                oi->ip_last_trans = 0;
                oi->ip_dir_start_lookup = 0;
@@ -948,14 +957,6 @@ static int ocfs2_initialize_mem_caches(void)
        if (!ocfs2_inode_cachep)
                return -ENOMEM;
-        ocfs2_lock_cache = kmem_cache_create("ocfs2_lock",
-                                             sizeof(struct ocfs2_journal_lock),
-                                             0,
-                                             SLAB_HWCACHE_ALIGN,
-                                             NULL, NULL);
-        if (!ocfs2_lock_cache)
-                return -ENOMEM;
        return 0;
 }
@@ -963,11 +964,8 @@ static void ocfs2_free_mem_caches(void)
 {
        if (ocfs2_inode_cachep)
                kmem_cache_destroy(ocfs2_inode_cachep);
-        if (ocfs2_lock_cache)
-                kmem_cache_destroy(ocfs2_lock_cache);
        ocfs2_inode_cachep = NULL;
-        ocfs2_lock_cache = NULL;
 }
 static int ocfs2_get_sector(struct super_block *sb,
@@ -1280,6 +1278,8 @@ static int ocfs2_initialize_super(struct super_block *sb,
        init_waitqueue_head(&osb->checkpoint_event);
        atomic_set(&osb->needs_checkpoint, 0);
+        osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
        osb->node_num = O2NM_INVALID_NODE_NUM;
        osb->slot_num = OCFS2_INVALID_SLOT;
@@ -1365,7 +1365,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
        spin_lock_init(&journal->j_lock);
        journal->j_trans_id = (unsigned long) 1;
        INIT_LIST_HEAD(&journal->j_la_cleanups);
-        INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery, osb);
+        INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);
        journal->j_state = OCFS2_JOURNAL_FREE;
        /* get some pseudo constants for clustersize bits */
@@ -1674,7 +1674,7 @@ void __ocfs2_error(struct super_block *sb,
        va_list args;
        va_start(args, fmt);
-        vsprintf(error_buf, fmt, args);
+        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
        va_end(args);
        /* Not using mlog here because we want to show the actual
@@ -1695,7 +1695,7 @@ void __ocfs2_abort(struct super_block* sb,
        va_list args;
        va_start(args, fmt);
-        vsprintf(error_buf, fmt, args);
+        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
        va_end(args);
        printk(KERN_CRIT "OCFS2: abort (device %s): %s: %s\n",
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c
index c0f68aa6c175..957d6878b03e 100644
--- a/fs/ocfs2/symlink.c
+++ b/fs/ocfs2/symlink.c
@@ -126,6 +126,10 @@ static int ocfs2_readlink(struct dentry *dentry,
                goto out;
        }
+        /*
+         * Without vfsmount we can't update atime now,
+         * but we will update atime here ultimately.
+         */
        ret = vfs_readlink(dentry, buffer, buflen, link);
        brelse(bh);
diff --git a/fs/ocfs2/uptodate.c b/fs/ocfs2/uptodate.c
index 9707ed7a3206..39814b900fc0 100644
--- a/fs/ocfs2/uptodate.c
+++ b/fs/ocfs2/uptodate.c
@@ -69,7 +69,7 @@ struct ocfs2_meta_cache_item {
        sector_t        c_block;
 };
-static kmem_cache_t *ocfs2_uptodate_cachep = NULL;
+static struct kmem_cache *ocfs2_uptodate_cachep = NULL;
 void ocfs2_metadata_cache_init(struct inode *inode)
 {
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 592a6402e851..26f44e0074ec 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -330,13 +330,13 @@ out:
        return 0;
 }
-static kmem_cache_t *op_inode_cachep;
+static struct kmem_cache *op_inode_cachep;
 static struct inode *openprom_alloc_inode(struct super_block *sb)
 {
        struct op_inode_info *oi;
-        oi = kmem_cache_alloc(op_inode_cachep, SLAB_KERNEL);
+        oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL);
        if (!oi)
                return NULL;
@@ -415,7 +415,7 @@ static struct file_system_type openprom_fs_type = {
        .kill_sb        = kill_anon_super,
 };
-static void op_inode_init_once(void *data, kmem_cache_t * cachep, unsigned long flags)
+static void op_inode_init_once(void *data, struct kmem_cache * cachep, unsigned long flags)
 {
        struct op_inode_info *oi = (struct op_inode_info *) data;
diff --git a/fs/partitions/amiga.c b/fs/partitions/amiga.c
index 3068528890a6..9917a8c360f2 100644
--- a/fs/partitions/amiga.c
+++ b/fs/partitions/amiga.c
@@ -43,6 +43,7 @@ amiga_partition(struct parsed_partitions *state, struct block_device *bdev)
                        if (warn_no_part)
                                printk("Dev %s: unable to read RDB block %d\n",
                                       bdevname(bdev, b), blk);
+                        res = -1;
                        goto rdb_done;
                }
                if (*(__be32 *)data != cpu_to_be32(IDNAME_RIGIDDISK))
@@ -79,6 +80,7 @@ amiga_partition(struct parsed_partitions *state, struct block_device *bdev)
                        if (warn_no_part)
                                printk("Dev %s: unable to read partition block %d\n",
                                       bdevname(bdev, b), blk);
+                        res = -1;
                        goto rdb_done;
                }
                pb  = (struct PartitionBlock *)data;
diff --git a/fs/partitions/atari.c b/fs/partitions/atari.c
index 192a6adfdefd..1f3572d5b755 100644
--- a/fs/partitions/atari.c
+++ b/fs/partitions/atari.c
@@ -88,7 +88,7 @@ int atari_partition(struct parsed_partitions *state, struct block_device *bdev)
                        if (!xrs) {
                                printk (" block %ld read failed\n", partsect);
                                put_dev_sector(sect);
-                                return 0;
+                                return -1;
                        }
                        /* ++roman: sanity check: bit 0 of flg field must be set */
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 6fb4b6150d77..1901137f4eca 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -153,7 +153,7 @@ static struct parsed_partitions *
 check_partition(struct gendisk *hd, struct block_device *bdev)
 {
        struct parsed_partitions *state;
-        int i, res;
+        int i, res, err;
        state = kmalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
        if (!state)
@@ -165,19 +165,30 @@ check_partition(struct gendisk *hd, struct block_device *bdev)
                sprintf(state->name, "p");
        state->limit = hd->minors;
-        i = res = 0;
+        i = res = err = 0;
        while (!res && check_part[i]) {
                memset(&state->parts, 0, sizeof(state->parts));
                res = check_part[i++](state, bdev);
+                if (res < 0) {
+                        /* We have hit an I/O error which we don't report now.
+                        * But record it, and let the others do their job.
+                        */
+                        err = res;
+                        res = 0;
+                }
        }
        if (res > 0)
                return state;
+        if (!err)
+        /* The partition is unrecognized. So report I/O errors if there were any */
+                res = err;
        if (!res)
                printk(" unknown partition table\n");
        else if (warn_no_part)
                printk(" unable to read partition table\n");
        kfree(state);
-        return NULL;
+        return ERR_PTR(res);
 }
 /*
@@ -494,6 +505,8 @@ int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
                disk->fops->revalidate_disk(disk);
        if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
                return 0;
+        if (IS_ERR(state))      /* I/O error reading the partition table */
+                return PTR_ERR(state);
        for (p = 1; p < state->limit; p++) {
                sector_t size = state->parts[p].size;
                sector_t from = state->parts[p].from;
diff --git a/fs/partitions/ibm.c b/fs/partitions/ibm.c
index d352a7381fed..9f7ad4244f63 100644
--- a/fs/partitions/ibm.c
+++ b/fs/partitions/ibm.c
@@ -43,7 +43,7 @@ cchhb2blk (struct vtoc_cchhb *ptr, struct hd_geometry *geo) {
 int
 ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
 {
-        int blocksize, offset, size;
+        int blocksize, offset, size,res;
        loff_t i_size;
        dasd_information_t *info;
        struct hd_geometry *geo;
@@ -56,15 +56,16 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
        unsigned char *data;
        Sector sect;
+        res = 0;
        blocksize = bdev_hardsect_size(bdev);
        if (blocksize <= 0)
-                return 0;
+                goto out_exit;
        i_size = i_size_read(bdev->bd_inode);
        if (i_size == 0)
-                return 0;
+                goto out_exit;
        if ((info = kmalloc(sizeof(dasd_information_t), GFP_KERNEL)) == NULL)
-                goto out_noinfo;
+                goto out_exit;
        if ((geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL)) == NULL)
                goto out_nogeo;
        if ((label = kmalloc(sizeof(union label_t), GFP_KERNEL)) == NULL)
@@ -72,7 +73,7 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
        if (ioctl_by_bdev(bdev, BIODASDINFO, (unsigned long)info) != 0 ||
            ioctl_by_bdev(bdev, HDIO_GETGEO, (unsigned long)geo) != 0)
-                goto out_noioctl;
+                goto out_freeall;
        /*
         * Get volume label, extract name and type.
@@ -92,6 +93,8 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
        EBCASC(type, 4);
        EBCASC(name, 6);
+        res = 1;
        /*
         * Three different types: CMS1, VOL1 and LNX1/unlabeled
         */
@@ -156,6 +159,9 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
                        counter++;
                        blk++;
                }
+                if (!data)
+                /* Are we not supposed to report this ? */
+                        goto out_readerr;
        } else {
                /*
                 * Old style LNX1 or unlabeled disk
@@ -171,18 +177,17 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
        }
        printk("\n");
-        kfree(label);
+        goto out_freeall;
-        kfree(geo);
-        kfree(info);
-        return 1;
 out_readerr:
-out_noioctl:
+        res = -1;
+out_freeall:
        kfree(label);
 out_nolab:
        kfree(geo);
 out_nogeo:
        kfree(info);
-out_noinfo:
+out_exit:
-        return 0;
+        return res;
 }
diff --git a/fs/partitions/mac.c b/fs/partitions/mac.c
index c0871002d00d..d4a0fad3563b 100644
--- a/fs/partitions/mac.c
+++ b/fs/partitions/mac.c
@@ -74,6 +74,8 @@ int mac_partition(struct parsed_partitions *state, struct block_device *bdev)
                        be32_to_cpu(part->start_block) * (secsize/512),
                        be32_to_cpu(part->block_count) * (secsize/512));
+                if (!strnicmp(part->type, "Linux_RAID", 10))
+                        state->parts[slot].flags = 1;
 #ifdef CONFIG_PPC_PMAC
                /*
                 * If this is the first bootable partition, tell the
diff --git a/fs/pipe.c b/fs/pipe.c
index b1626f269a34..ae36b89b1a37 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -830,7 +830,14 @@ void free_pipe_info(struct inode *inode)
 static struct vfsmount *pipe_mnt __read_mostly;
 static int pipefs_delete_dentry(struct dentry *dentry)
 {
-        return 1;
+        /*
+         * At creation time, we pretended this dentry was hashed
+         * (by clearing DCACHE_UNHASHED bit in d_flags)
+         * At delete time, we restore the truth : not hashed.
+         * (so that dput() can proceed correctly)
+         */
+        dentry->d_flags |= DCACHE_UNHASHED;
+        return 0;
 }
 static struct dentry_operations pipefs_dentry_operations = {
@@ -891,17 +898,22 @@ struct file *create_write_pipe(void)
        if (!inode)
                goto err_file;
-        sprintf(name, "[%lu]", inode->i_ino);
+        this.len = sprintf(name, "[%lu]", inode->i_ino);
        this.name = name;
-        this.len = strlen(name);
+        this.hash = 0;
-        this.hash = inode->i_ino; /* will go */
        err = -ENOMEM;
        dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
        if (!dentry)
                goto err_inode;
        dentry->d_op = &pipefs_dentry_operations;
-        d_add(dentry, inode);
+        /*
+         * We dont want to publish this dentry into global dentry hash table.
+         * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
+         * This permits a working /proc/$pid/fd/XXX on pipes
+         */
+        dentry->d_flags &= ~DCACHE_UNHASHED;
+        d_instantiate(dentry, inode);
        f->f_vfsmnt = mntget(pipe_mnt);
        f->f_dentry = dentry;
        f->f_mapping = inode->i_mapping;
diff --git a/fs/proc/Makefile b/fs/proc/Makefile
index 7431d7ba2d09..f6c776272572 100644
--- a/fs/proc/Makefile
+++ b/fs/proc/Makefile
@@ -8,8 +8,9 @@ proc-y			:= nommu.o task_nommu.o
 proc-$(CONFIG_MMU)      := mmu.o task_mmu.o
 proc-y       += inode.o root.o base.o generic.o array.o \
-                kmsg.o proc_tty.o proc_misc.o
+                proc_tty.o proc_misc.o
 proc-$(CONFIG_PROC_KCORE)       += kcore.o
 proc-$(CONFIG_PROC_VMCORE)      += vmcore.o
 proc-$(CONFIG_PROC_DEVICETREE)  += proc_devtree.o
+proc-$(CONFIG_PRINTK)   += kmsg.o
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 795319c54f72..b859fc749c07 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -683,8 +683,6 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
        char buffer[PROC_NUMBUF], *end;
        int oom_adjust;
-        if (!capable(CAP_SYS_RESOURCE))
-                return -EPERM;
        memset(buffer, 0, sizeof(buffer));
        if (count > sizeof(buffer) - 1)
                count = sizeof(buffer) - 1;
@@ -699,6 +697,10 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
        task = get_proc_task(file->f_dentry->d_inode);
        if (!task)
                return -ESRCH;
+        if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) {
+                put_task_struct(task);
+                return -EACCES;
+        }
        task->oomkilladj = oom_adjust;
        put_task_struct(task);
        if (end - buffer == 0)
@@ -1883,8 +1885,9 @@ out:
        return;
 }
-struct dentry *proc_pid_instantiate(struct inode *dir,
+static struct dentry *proc_pid_instantiate(struct inode *dir,
-        struct dentry * dentry, struct task_struct *task, void *ptr)
+                                           struct dentry * dentry,
+                                           struct task_struct *task, void *ptr)
 {
        struct dentry *error = ERR_PTR(-ENOENT);
        struct inode *inode;
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 49dfb2ab783e..e26945ba685b 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -81,14 +81,14 @@ static void proc_read_inode(struct inode * inode)
        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 }
-static kmem_cache_t * proc_inode_cachep;
+static struct kmem_cache * proc_inode_cachep;
 static struct inode *proc_alloc_inode(struct super_block *sb)
 {
        struct proc_inode *ei;
        struct inode *inode;
-        ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, SLAB_KERNEL);
+        ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        ei->pid = NULL;
@@ -105,7 +105,7 @@ static void proc_destroy_inode(struct inode *inode)
        kmem_cache_free(proc_inode_cachep, PROC_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct proc_inode *ei = (struct proc_inode *) foo;
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 1294eda4acae..1be73082edd3 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -22,6 +22,7 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
+#define CORE_STR "CORE"
 static int open_kcore(struct inode * inode, struct file * filp)
 {
@@ -82,10 +83,11 @@ static size_t get_kcore_size(int *nphdr, size_t *elf_buflen)
        }
        *elf_buflen =   sizeof(struct elfhdr) + 
                        (*nphdr + 2)*sizeof(struct elf_phdr) + 
-                        3 * (sizeof(struct elf_note) + 4) +
+                        3 * ((sizeof(struct elf_note)) +
-                        sizeof(struct elf_prstatus) +
+                             roundup(sizeof(CORE_STR), 4)) +
-                        sizeof(struct elf_prpsinfo) +
+                        roundup(sizeof(struct elf_prstatus), 4) +
-                        sizeof(struct task_struct);
+                        roundup(sizeof(struct elf_prpsinfo), 4) +
+                        roundup(sizeof(struct task_struct), 4);
        *elf_buflen = PAGE_ALIGN(*elf_buflen);
        return size + *elf_buflen;
 }
@@ -210,7 +212,7 @@ static void elf_kcore_store_hdr(char *bufp, int nphdr, int dataoff)
        nhdr->p_offset  = offset;
        /* set up the process status */
-        notes[0].name = "CORE";
+        notes[0].name = CORE_STR;
        notes[0].type = NT_PRSTATUS;
        notes[0].datasz = sizeof(struct elf_prstatus);
        notes[0].data = &prstatus;
@@ -221,7 +223,7 @@ static void elf_kcore_store_hdr(char *bufp, int nphdr, int dataoff)
        bufp = storenote(&notes[0], bufp);
        /* set up the process info */
-        notes[1].name   = "CORE";
+        notes[1].name   = CORE_STR;
        notes[1].type   = NT_PRPSINFO;
        notes[1].datasz = sizeof(struct elf_prpsinfo);
        notes[1].data   = &prpsinfo;
@@ -238,7 +240,7 @@ static void elf_kcore_store_hdr(char *bufp, int nphdr, int dataoff)
        bufp = storenote(&notes[1], bufp);
        /* set up the task structure */
-        notes[2].name   = "CORE";
+        notes[2].name   = CORE_STR;
        notes[2].type   = NT_TASKSTRUCT;
        notes[2].datasz = sizeof(struct task_struct);
        notes[2].data   = current;
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 93c43b676e59..51815cece6f3 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -696,9 +696,11 @@ void __init proc_misc_init(void)
        proc_symlink("mounts", NULL, "self/mounts");
        /* And now for trickier ones */
+#ifdef CONFIG_PRINTK
        entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
        if (entry)
                entry->proc_fops = &proc_kmsg_operations;
+#endif
        create_seq_entry("devices", 0, &proc_devinfo_operations);
        create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
 #ifdef CONFIG_BLOCK
diff --git a/fs/proc/root.c b/fs/proc/root.c
index ffe66c38488b..64d242b6dcfa 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -13,6 +13,7 @@
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
 #include <linux/init.h>
+#include <linux/sched.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
 #include <linux/smp_lock.h>
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 5a41db2a218d..c047dc654d5c 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -515,12 +515,12 @@ static void qnx4_read_inode(struct inode *inode)
        brelse(bh);
 }
-static kmem_cache_t *qnx4_inode_cachep;
+static struct kmem_cache *qnx4_inode_cachep;
 static struct inode *qnx4_alloc_inode(struct super_block *sb)
 {
        struct qnx4_inode_info *ei;
-        ei = kmem_cache_alloc(qnx4_inode_cachep, SLAB_KERNEL);
+        ei = kmem_cache_alloc(qnx4_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -531,7 +531,7 @@ static void qnx4_destroy_inode(struct inode *inode)
        kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode));
 }
-static void init_once(void *foo, kmem_cache_t * cachep,
+static void init_once(void *foo, struct kmem_cache * cachep,
                      unsigned long flags)
 {
        struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo;
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index ac14318c81ba..373d862c3f87 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -317,12 +317,11 @@ static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handl
                        /* area filled with zeroes, to supply as list of zero blocknumbers
                           We allocate it outside of loop just in case loop would spin for
                           several iterations. */
-                        char *zeros = kmalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC);      // We cannot insert more than MAX_ITEM_LEN bytes anyway.
+                        char *zeros = kzalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC);      // We cannot insert more than MAX_ITEM_LEN bytes anyway.
                        if (!zeros) {
                                res = -ENOMEM;
                                goto error_exit_free_blocks;
                        }
-                        memset(zeros, 0, to_paste * UNFM_P_SIZE);
                        do {
                                to_paste =
                                    min_t(__u64, hole_size,
@@ -407,6 +406,8 @@ static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handl
                                   we restart it. This will also free the path. */
                                if (journal_transaction_should_end
                                    (th, th->t_blocks_allocated)) {
+                                        inode->i_size = cpu_key_k_offset(&key) +
+                                                (to_paste << inode->i_blkbits);
                                        res =
                                            restart_transaction(th, inode,
                                                                &path);
@@ -1045,6 +1046,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                        char *kaddr = kmap_atomic(prepared_pages[0], KM_USER0);
                        memset(kaddr, 0, from);
                        kunmap_atomic(kaddr, KM_USER0);
+                        flush_dcache_page(prepared_pages[0]);
                }
                if (to != PAGE_CACHE_SIZE) {    /* Last page needs to be partially zeroed */
                        char *kaddr =
@@ -1052,6 +1054,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                        KM_USER0);
                        memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
                        kunmap_atomic(kaddr, KM_USER0);
+                        flush_dcache_page(prepared_pages[num_pages - 1]);
                }
                /* Since all blocks are new - use already calculated value */
@@ -1185,6 +1188,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                        memset(kaddr + block_start, 0,
                                               from - block_start);
                                        kunmap_atomic(kaddr, KM_USER0);
+                                        flush_dcache_page(prepared_pages[0]);
                                        set_buffer_uptodate(bh);
                                }
                        }
@@ -1222,6 +1226,7 @@ static int reiserfs_prepare_file_region_for_write(struct inode *inode
                                                        KM_USER0);
                                        memset(kaddr + to, 0, block_end - to);
                                        kunmap_atomic(kaddr, KM_USER0);
+                                        flush_dcache_page(prepared_pages[num_pages - 1]);
                                        set_buffer_uptodate(bh);
                                }
                        }
@@ -1307,56 +1312,8 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
                        count = MAX_NON_LFS - (unsigned long)*ppos;
        }
-        if (file->f_flags & O_DIRECT) { // Direct IO needs treatment
+        if (file->f_flags & O_DIRECT)
-                ssize_t result, after_file_end = 0;
+                return do_sync_write(file, buf, count, ppos);
-                if ((*ppos + count >= inode->i_size)
-                    || (file->f_flags & O_APPEND)) {
-                        /* If we are appending a file, we need to put this savelink in here.
-                           If we will crash while doing direct io, finish_unfinished will
-                           cut the garbage from the file end. */
-                        reiserfs_write_lock(inode->i_sb);
-                        err =
-                            journal_begin(&th, inode->i_sb,
-                                          JOURNAL_PER_BALANCE_CNT);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        reiserfs_update_inode_transaction(inode);
-                        add_save_link(&th, inode, 1 /* Truncate */ );
-                        after_file_end = 1;
-                        err =
-                            journal_end(&th, inode->i_sb,
-                                        JOURNAL_PER_BALANCE_CNT);
-                        reiserfs_write_unlock(inode->i_sb);
-                        if (err)
-                                return err;
-                }
-                result = do_sync_write(file, buf, count, ppos);
-                if (after_file_end) {   /* Now update i_size and remove the savelink */
-                        struct reiserfs_transaction_handle th;
-                        reiserfs_write_lock(inode->i_sb);
-                        err = journal_begin(&th, inode->i_sb, 1);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        reiserfs_update_inode_transaction(inode);
-                        mark_inode_dirty(inode);
-                        err = journal_end(&th, inode->i_sb, 1);
-                        if (err) {
-                                reiserfs_write_unlock(inode->i_sb);
-                                return err;
-                        }
-                        err = remove_save_link(inode, 1 /* truncate */ );
-                        reiserfs_write_unlock(inode->i_sb);
-                        if (err)
-                                return err;
-                }
-                return result;
-        }
        if (unlikely((ssize_t) count < 0))
                return -EINVAL;
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 9c69bcacad22..254239e6f9e3 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -216,11 +216,12 @@ static int file_capable(struct inode *inode, long block)
        BUG_ON(!th->t_trans_id);
        BUG_ON(!th->t_refcount);
+        pathrelse(path);
        /* we cannot restart while nested */
        if (th->t_refcount > 1) {
                return 0;
        }
-        pathrelse(path);
        reiserfs_update_sd(th, inode);
        err = journal_end(th, s, len);
        if (!err) {
@@ -928,15 +929,12 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
                        if (blocks_needed == 1) {
                                un = &unf_single;
                        } else {
-                                un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC);      // We need to avoid scheduling.
+                                un = kzalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC);      // We need to avoid scheduling.
                                if (!un) {
                                        un = &unf_single;
                                        blocks_needed = 1;
                                        max_to_insert = 0;
-                                } else
+                                }
-                                        memset(un, 0,
-                                               UNFM_P_SIZE * min(blocks_needed,
-                                                                 max_to_insert));
                        }
                        if (blocks_needed <= max_to_insert) {
                                /* we are going to add target block to the file. Use allocated
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 85ce23268302..7280a23ef344 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -104,7 +104,7 @@ static int release_journal_dev(struct super_block *super,
                               struct reiserfs_journal *journal);
 static int dirty_one_transaction(struct super_block *s,
                                 struct reiserfs_journal_list *jl);
-static void flush_async_commits(void *p);
+static void flush_async_commits(struct work_struct *work);
 static void queue_log_writer(struct super_block *s);
 /* values for join in do_journal_begin_r */
@@ -1464,7 +1464,7 @@ static int flush_journal_list(struct super_block *s,
                }
                /* if someone has this block in a newer transaction, just make
-                 ** sure they are commited, and don't try writing it to disk
+                 ** sure they are committed, and don't try writing it to disk
                 */
                if (pjl) {
                        if (atomic_read(&pjl->j_commit_left))
@@ -2836,7 +2836,8 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
        if (reiserfs_mounted_fs_count <= 1)
                commit_wq = create_workqueue("reiserfs");
-        INIT_WORK(&journal->j_work, flush_async_commits, p_s_sb);
+        INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
+        journal->j_work_sb = p_s_sb;
        return 0;
      free_and_return:
        free_journal_ram(p_s_sb);
@@ -3384,7 +3385,7 @@ static int remove_from_transaction(struct super_block *p_s_sb,
 /*
 ** for any cnode in a journal list, it can only be dirtied of all the
-** transactions that include it are commited to disk.
+** transactions that include it are committed to disk.
 ** this checks through each transaction, and returns 1 if you are allowed to dirty,
 ** and 0 if you aren't
 **
@@ -3426,7 +3427,7 @@ static int can_dirty(struct reiserfs_journal_cnode *cn)
 }
 /* syncs the commit blocks, but does not force the real buffers to disk
-** will wait until the current transaction is done/commited before returning 
+** will wait until the current transaction is done/committed before returning 
 */
 int journal_end_sync(struct reiserfs_transaction_handle *th,
                     struct super_block *p_s_sb, unsigned long nblocks)
@@ -3447,10 +3448,11 @@ int journal_end_sync(struct reiserfs_transaction_handle *th,
 /*
 ** writeback the pending async commits to disk
 */
-static void flush_async_commits(void *p)
+static void flush_async_commits(struct work_struct *work)
 {
-        struct super_block *p_s_sb = p;
+        struct reiserfs_journal *journal =
-        struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb);
+                container_of(work, struct reiserfs_journal, j_work.work);
+        struct super_block *p_s_sb = journal->j_work_sb;
        struct reiserfs_journal_list *jl;
        struct list_head *entry;
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 17249994110f..7fb5fb036f90 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -490,13 +490,13 @@ static void reiserfs_put_super(struct super_block *s)
        return;
 }
-static kmem_cache_t *reiserfs_inode_cachep;
+static struct kmem_cache *reiserfs_inode_cachep;
 static struct inode *reiserfs_alloc_inode(struct super_block *sb)
 {
        struct reiserfs_inode_info *ei;
        ei = (struct reiserfs_inode_info *)
-            kmem_cache_alloc(reiserfs_inode_cachep, SLAB_KERNEL);
+            kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -507,7 +507,7 @@ static void reiserfs_destroy_inode(struct inode *inode)
        kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 }
-static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
@@ -1549,13 +1549,12 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        struct reiserfs_sb_info *sbi;
        int errval = -EINVAL;
-        sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
+        sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
        if (!sbi) {
                errval = -ENOMEM;
                goto error;
        }
        s->s_fs_info = sbi;
-        memset(sbi, 0, sizeof(struct reiserfs_sb_info));
        /* Set default values for options: non-aggressive tails, RO on errors */
        REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
        REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 7bdb0ed443e1..1e4d68590178 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -41,7 +41,7 @@
 #include <linux/reiserfs_xattr.h>
 #include <linux/reiserfs_acl.h>
 #include <asm/uaccess.h>
-#include <asm/checksum.h>
+#include <net/checksum.h>
 #include <linux/smp_lock.h>
 #include <linux/stat.h>
 #include <asm/semaphore.h>
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index ddcd9e1ef282..c5af088d4a4c 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -550,12 +550,12 @@ romfs_read_inode(struct inode *i)
        }
 }
-static kmem_cache_t * romfs_inode_cachep;
+static struct kmem_cache * romfs_inode_cachep;
 static struct inode *romfs_alloc_inode(struct super_block *sb)
 {
        struct romfs_inode_info *ei;
-        ei = (struct romfs_inode_info *)kmem_cache_alloc(romfs_inode_cachep, SLAB_KERNEL);
+        ei = (struct romfs_inode_info *)kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -566,7 +566,7 @@ static void romfs_destroy_inode(struct inode *inode)
        kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct romfs_inode_info *ei = (struct romfs_inode_info *) foo;
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 555b9ac04c25..10690aa401c7 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -26,7 +26,7 @@
 *      ERR_PTR(error).  In the end of sequence they return %NULL. ->show()
 *      returns 0 in case of success and negative number in case of error.
 */
-int seq_open(struct file *file, struct seq_operations *op)
+int seq_open(struct file *file, const struct seq_operations *op)
 {
        struct seq_file *p = file->private_data;
@@ -408,7 +408,7 @@ EXPORT_SYMBOL(single_open);
 int single_release(struct inode *inode, struct file *file)
 {
-        struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
+        const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
        int res = seq_release(inode, file);
        kfree(op);
        return res;
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 2c122ee83adb..4af4cd729a5a 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -50,12 +50,12 @@ static void smb_put_super(struct super_block *);
 static int  smb_statfs(struct dentry *, struct kstatfs *);
 static int  smb_show_options(struct seq_file *, struct vfsmount *);
-static kmem_cache_t *smb_inode_cachep;
+static struct kmem_cache *smb_inode_cachep;
 static struct inode *smb_alloc_inode(struct super_block *sb)
 {
        struct smb_inode_info *ei;
-        ei = (struct smb_inode_info *)kmem_cache_alloc(smb_inode_cachep, SLAB_KERNEL);
+        ei = (struct smb_inode_info *)kmem_cache_alloc(smb_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        return &ei->vfs_inode;
@@ -66,7 +66,7 @@ static void smb_destroy_inode(struct inode *inode)
        kmem_cache_free(smb_inode_cachep, SMB_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct smb_inode_info *ei = (struct smb_inode_info *) foo;
        unsigned long flagmask = SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR;
diff --git a/fs/smbfs/request.c b/fs/smbfs/request.c
index 0fb74697abc4..a4bcae8a9aff 100644
--- a/fs/smbfs/request.c
+++ b/fs/smbfs/request.c
@@ -25,7 +25,7 @@
 #define ROUND_UP(x) (((x)+3) & ~3)
 /* cache for request structures */
-static kmem_cache_t *req_cachep;
+static struct kmem_cache *req_cachep;
 static int smb_request_send_req(struct smb_request *req);
@@ -61,7 +61,7 @@ static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
        struct smb_request *req;
        unsigned char *buf = NULL;
-        req = kmem_cache_alloc(req_cachep, SLAB_KERNEL);
+        req = kmem_cache_alloc(req_cachep, GFP_KERNEL);
        VERBOSE("allocating request: %p\n", req);
        if (!req)
                goto out;
diff --git a/fs/stat.c b/fs/stat.c
index bca07eb2003c..a0ebfc7f8a64 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -51,13 +51,6 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
                return inode->i_op->getattr(mnt, dentry, stat);
        generic_fillattr(inode, stat);
-        if (!stat->blksize) {
-                struct super_block *s = inode->i_sb;
-                unsigned blocks;
-                blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
-                stat->blocks = (s->s_blocksize / 512) * blocks;
-                stat->blksize = s->s_blocksize;
-        }
        return 0;
 }
diff --git a/fs/super.c b/fs/super.c
index 47e554c12e76..84c320f6ad7e 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -221,6 +221,24 @@ static int grab_super(struct super_block *s) __releases(sb_lock)
 }
 /*
+ * Superblock locking.  We really ought to get rid of these two.
+ */
+void lock_super(struct super_block * sb)
+{
+        get_fs_excl();
+        mutex_lock(&sb->s_lock);
+}
+void unlock_super(struct super_block * sb)
+{
+        put_fs_excl();
+        mutex_unlock(&sb->s_lock);
+}
+EXPORT_SYMBOL(lock_super);
+EXPORT_SYMBOL(unlock_super);
+/*
 * Write out and wait upon all dirty data associated with this
 * superblock.  Filesystem data as well as the underlying block
 * device.  Takes the superblock lock.  Requires a second blkdev
diff --git a/fs/sync.c b/fs/sync.c
index 1de747b5ddb9..865f32be386e 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -6,6 +6,7 @@
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/writeback.h>
 #include <linux/syscalls.h>
 #include <linux/linkage.h>
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 3aa3434621ca..a5782e8c7f07 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -372,6 +372,51 @@ int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
        return error;
 }
+int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
+{
+        struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
+        struct sysfs_dirent *new_parent_sd, *sd;
+        int error;
+        if (!new_parent)
+                return -EINVAL;
+        old_parent_dentry = kobj->parent ?
+                kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
+        new_parent_dentry = new_parent->dentry;
+again:
+        mutex_lock(&old_parent_dentry->d_inode->i_mutex);
+        if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
+                mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
+                goto again;
+        }
+        new_parent_sd = new_parent_dentry->d_fsdata;
+        sd = kobj->dentry->d_fsdata;
+        new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
+                                    strlen(kobj->name));
+        if (IS_ERR(new_dentry)) {
+                error = PTR_ERR(new_dentry);
+                goto out;
+        } else
+                error = 0;
+        d_add(new_dentry, NULL);
+        d_move(kobj->dentry, new_dentry);
+        dput(new_dentry);
+        /* Remove from old parent's list and insert into new parent's list. */
+        list_del_init(&sd->s_sibling);
+        list_add(&sd->s_sibling, &new_parent_sd->s_children);
+out:
+        mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
+        mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
+        return error;
+}
 static int sysfs_dir_open(struct inode *inode, struct file *file)
 {
        struct dentry * dentry = file->f_dentry;
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index 298303b5a716..95c165101c98 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -190,6 +190,9 @@ fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t
                count = PAGE_SIZE - 1;
        error = copy_from_user(buffer->page,buf,count);
        buffer->needs_read_fill = 1;
+        /* if buf is assumed to contain a string, terminate it by \0,
+           so e.g. sscanf() can scan the string easily */
+        buffer->page[count] = 0;
        return error ? -EFAULT : count;
 }
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 20551a1b8a56..e503f858fba8 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -16,7 +16,7 @@
 struct vfsmount *sysfs_mount;
 struct super_block * sysfs_sb = NULL;
-kmem_cache_t *sysfs_dir_cachep;
+struct kmem_cache *sysfs_dir_cachep;
 static struct super_operations sysfs_ops = {
        .statfs         = simple_statfs,
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 6f3d6bd52887..bd7cec295dab 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -1,6 +1,6 @@
 extern struct vfsmount * sysfs_mount;
-extern kmem_cache_t *sysfs_dir_cachep;
+extern struct kmem_cache *sysfs_dir_cachep;
 extern struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent *);
 extern int sysfs_create(struct dentry *, int mode, int (*init)(struct inode *));
diff --git a/fs/sysv/CHANGES b/fs/sysv/CHANGES
deleted file mode 100644
index 66ea6e92be66..000000000000
--- a/fs/sysv/CHANGES
+++ /dev/null
@@ -1,60 +0,0 @@
-Mon, 15 Dec 1997          Krzysztof G. Baranowski <kgb@manjak.knm.org.pl>
-        *    namei.c: struct sysv_dir_inode_operations updated to use dentries.
-Fri, 23 Jan 1998   Krzysztof G. Baranowski <kgb@manjak.knm.org.pl>
-        *    inode.c: corrected 1 track offset setting (in sb->sv_block_base).
-                      Originally it was overridden (by setting to zero)
-                      in detected_[xenix,sysv4,sysv2,coherent]. Thanks
-                      to Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
-                      for identifying the problem.
-Tue, 27 Jan 1998   Krzysztof G. Baranowski <kgb@manjak.knm.org.pl>
-        *    inode.c: added 2048-byte block support to SystemV FS.
-                      Merged detected_bs[512,1024,2048]() into one function:
-                      void detected_bs (u_char type, struct super_block *sb).
-                      Thanks to Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
-                      for the patch.
-Wed, 4 Feb 1998   Krzysztof G. Baranowski <kgb@manjak.knm.org.pl>
-        *    namei.c: removed static subdir(); is_subdir() from dcache.c
-                      is used instead. Cosmetic changes.
-Thu, 3 Dec 1998   Al Viro (viro@parcelfarce.linux.theplanet.co.uk)
-        *    namei.c (sysv_rmdir):
-                      Bugectomy: old check for victim being busy
-                      (inode->i_count) wasn't replaced (with checking
-                      dentry->d_count) and escaped Linus in the last round
-                      of changes. Shot and buried.
-Wed, 9 Dec 1998   AV
-        *    namei.c (do_sysv_rename):
-                       Fixed incorrect check for other owners + race.
-                       Removed checks that went to VFS.
-        *    namei.c (sysv_unlink):
-                       Removed checks that went to VFS.
-Thu, 10 Dec 1998   AV
-        *    namei.c (do_mknod):
-                        Removed dead code - mknod is never asked to
-                        create a symlink or directory. Incidentially,
-                        it wouldn't do it right if it would be called.
-Sat, 26 Dec 1998   KGB
-        *    inode.c (detect_sysv4):
-                        Added detection of expanded s_type field (0x10,
-                        0x20 and 0x30).  Forced read-only access in this case.
-Sun, 21 Mar 1999   AV
-        *    namei.c (sysv_link):
-                        Fixed i_count usage that resulted in dcache corruption.
-        *    inode.c:
-                        Filled ->delete_inode() method with sysv_delete_inode().
-                        sysv_put_inode() is gone, as it tried to do ->delete_
-                        _inode()'s job.
-        *    ialloc.c: (sysv_free_inode):
-                        Fixed race.
-Sun, 30 Apr 1999   AV
-        *    namei.c (sysv_mknod):
-                        Removed dead code (S_IFREG case is now passed to
-                        ->create() by VFS).
diff --git a/fs/sysv/ChangeLog b/fs/sysv/ChangeLog
deleted file mode 100644
index f403f8b91b80..000000000000
--- a/fs/sysv/ChangeLog
+++ /dev/null
@@ -1,106 +0,0 @@
-Thu Feb 14 2002  Andrew Morton  <akpm@zip.com.au>
-        * dir_commit_chunk(): call writeout_one_page() as well as
-          waitfor_one_page() for IS_SYNC directories, so that we
-          actually do sync the directory. (forward-port from 2.4).
-Thu Feb  7 2002  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * super.c: switched to ->get_sb()
-        * ChangeLog: fixed dates ;-)
-2002-01-24  David S. Miller  <davem@redhat.com>
-        * inode.c: Include linux/init.h
-Mon Jan 21 2002  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * ialloc.c (sysv_new_inode): zero SYSV_I(inode)->i_data out.
-        * i_vnode renamed to vfs_inode.  Sorry, but let's keep that
-          consistent.
-Sat Jan 19 2002  Christoph Hellwig  <hch@infradead.org>
-        * include/linux/sysv_fs.h (SYSV_I): Get fs-private inode data using
-                list_entry() instead of inode->u.
-        * include/linux/sysv_fs_i.h: Add 'struct inode  i_vnode' field to
-                sysv_inode_info structure.
-        * inode.c: Include <linux/slab.h>, implement alloc_inode/destroy_inode
-                sop methods, add infrastructure for per-fs inode slab cache.
-        * super.c (init_sysv_fs): Initialize inode cache, recover properly
-                in the case of failed register_filesystem for V7.
-        (exit_sysv_fs): Destroy inode cache.
-Sat Jan 19 2002  Christoph Hellwig  <hch@infradead.org>
-        * include/linux/sysv_fs.h: Include <linux/sysv_fs_i.h>, declare SYSV_I().
-        * dir.c (sysv_find_entry): Use SYSV_I() instead of ->u.sysv_i to
-                access fs-private inode data.
-        * ialloc.c (sysv_new_inode): Likewise.
-        * inode.c (sysv_read_inode): Likewise.
-        (sysv_update_inode): Likewise.
-        * itree.c (get_branch): Likewise.
-        (sysv_truncate): Likewise.
-        * symlink.c (sysv_readlink): Likewise.
-        (sysv_follow_link): Likewise.
-Fri Jan  4 2002  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * ialloc.c (sysv_free_inode): Use sb->s_id instead of bdevname().
-        * inode.c (sysv_read_inode): Likewise.
-          (sysv_update_inode): Likewise.
-          (sysv_sync_inode): Likewise.
-        * super.c (detect_sysv): Likewise.
-          (complete_read_super): Likewise.
-          (sysv_read_super): Likewise.
-          (v7_read_super): Likewise.
-Sun Dec 30 2001  Manfred Spraul  <manfred@colorfullife.com>
-        * dir.c (dir_commit_chunk): Do not set dir->i_version.
-        (sysv_readdir): Likewise.
-Thu Dec 27 2001  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * itree.c (get_block): Use map_bh() to fill out bh_result.
-Tue Dec 25 2001  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * super.c (sysv_read_super): Use sb_set_blocksize() to set blocksize.
-          (v7_read_super): Likewise.
-Tue Nov 27 2001  Alexander Viro  <viro@parcelfarce.linux.theplanet.co.uk>
-        * itree.c (get_block): Change type for iblock argument to sector_t.
-        * super.c (sysv_read_super): Set s_blocksize early.
-          (v7_read_super): Likewise.
-        * balloc.c (sysv_new_block): Use sb_bread(). instead of bread().
-          (sysv_count_free_blocks): Likewise.
-        * ialloc.c (sysv_raw_inode): Likewise.
-        * itree.c (get_branch): Likewise.
-          (free_branches): Likewise.
-        * super.c (sysv_read_super): Likewise.
-          (v7_read_super): Likewise.
-Sat Dec 15 2001  Christoph Hellwig  <hch@infradead.org>
-        * inode.c (sysv_read_inode): Mark inode as bad in case of failure.
-        * super.c (complete_read_super): Check for bad root inode.
-Wed Nov 21 2001  Andrew Morton  <andrewm@uow.edu.au>
-        * file.c (sysv_sync_file): Call fsync_inode_data_buffers.
-Fri Oct 26 2001  Christoph Hellwig  <hch@infradead.org>
-        * dir.c, ialloc.c, namei.c, include/linux/sysv_fs_i.h:
-        Implement per-Inode lookup offset cache.
-        Modelled after Ted's ext2 patch.
-Fri Oct 26 2001  Christoph Hellwig  <hch@infradead.org>
-        * inode.c, super.c, include/linux/sysv_fs.h,
-          include/linux/sysv_fs_sb.h:
-        Remove symlink faking.  Noone really wants to use these as
-        linux filesystems and native OSes don't support it anyway.
diff --git a/fs/sysv/INTRO b/fs/sysv/INTRO
deleted file mode 100644
index de4e4d17cac6..000000000000
--- a/fs/sysv/INTRO
+++ /dev/null
@@ -1,182 +0,0 @@
-This is the implementation of the SystemV/Coherent filesystem for Linux.
-It grew out of separate filesystem implementations
-    Xenix FS      Doug Evans <dje@cygnus.com>  June 1992
-    SystemV FS    Paul B. Monday <pmonday@eecs.wsu.edu> March-June 1993
-    Coherent FS   B. Haible <haible@ma2s2.mathematik.uni-karlsruhe.de> June 1993
-and was merged together in July 1993.
-These filesystems are rather similar. Here is a comparison with Minix FS:
-* Linux fdisk reports on partitions
-  - Minix FS     0x81 Linux/Minix
-  - Xenix FS     ??
-  - SystemV FS   ??
-  - Coherent FS  0x08 AIX bootable
-* Size of a block or zone (data allocation unit on disk)
-  - Minix FS     1024
-  - Xenix FS     1024 (also 512 ??)
-  - SystemV FS   1024 (also 512 and 2048)
-  - Coherent FS   512
-* General layout: all have one boot block, one super block and
-  separate areas for inodes and for directories/data.
-  On SystemV Release 2 FS (e.g. Microport) the first track is reserved and
-  all the block numbers (including the super block) are offset by one track.
-* Byte ordering of "short" (16 bit entities) on disk:
-  - Minix FS     little endian  0 1
-  - Xenix FS     little endian  0 1
-  - SystemV FS   little endian  0 1
-  - Coherent FS  little endian  0 1
-  Of course, this affects only the file system, not the data of files on it!
-* Byte ordering of "long" (32 bit entities) on disk:
-  - Minix FS     little endian  0 1 2 3
-  - Xenix FS     little endian  0 1 2 3
-  - SystemV FS   little endian  0 1 2 3
-  - Coherent FS  PDP-11         2 3 0 1
-  Of course, this affects only the file system, not the data of files on it!
-* Inode on disk: "short", 0 means non-existent, the root dir ino is:
-  - Minix FS                            1
-  - Xenix FS, SystemV FS, Coherent FS   2
-* Maximum number of hard links to a file:
-  - Minix FS     250
-  - Xenix FS     ??
-  - SystemV FS   ??
-  - Coherent FS  >=10000
-* Free inode management:
-  - Minix FS                             a bitmap
-  - Xenix FS, SystemV FS, Coherent FS
-      There is a cache of a certain number of free inodes in the super-block.
-      When it is exhausted, new free inodes are found using a linear search.
-* Free block management:
-  - Minix FS                             a bitmap
-  - Xenix FS, SystemV FS, Coherent FS
-      Free blocks are organized in a "free list". Maybe a misleading term,
-      since it is not true that every free block contains a pointer to
-      the next free block. Rather, the free blocks are organized in chunks
-      of limited size, and every now and then a free block contains pointers
-      to the free blocks pertaining to the next chunk; the first of these
-      contains pointers and so on. The list terminates with a "block number"
-      0 on Xenix FS and SystemV FS, with a block zeroed out on Coherent FS.
-* Super-block location:
-  - Minix FS     block 1 = bytes 1024..2047
-  - Xenix FS     block 1 = bytes 1024..2047
-  - SystemV FS   bytes 512..1023
-  - Coherent FS  block 1 = bytes 512..1023
-* Super-block layout:
-  - Minix FS
-                    unsigned short s_ninodes;
-                    unsigned short s_nzones;
-                    unsigned short s_imap_blocks;
-                    unsigned short s_zmap_blocks;
-                    unsigned short s_firstdatazone;
-                    unsigned short s_log_zone_size;
-                    unsigned long s_max_size;
-                    unsigned short s_magic;
-  - Xenix FS, SystemV FS, Coherent FS
-                    unsigned short s_firstdatazone;
-                    unsigned long  s_nzones;
-                    unsigned short s_fzone_count;
-                    unsigned long  s_fzones[NICFREE];
-                    unsigned short s_finode_count;
-                    unsigned short s_finodes[NICINOD];
-                    char           s_flock;
-                    char           s_ilock;
-                    char           s_modified;
-                    char           s_rdonly;
-                    unsigned long  s_time;
-                    short          s_dinfo[4]; -- SystemV FS only
-                    unsigned long  s_free_zones;
-                    unsigned short s_free_inodes;
-                    short          s_dinfo[4]; -- Xenix FS only
-                    unsigned short s_interleave_m,s_interleave_n; -- Coherent FS only
-                    char           s_fname[6];
-                    char           s_fpack[6];
-    then they differ considerably:
-        Xenix FS
-                    char           s_clean;
-                    char           s_fill[371];
-                    long           s_magic;
-                    long           s_type;
-        SystemV FS
-                    long           s_fill[12 or 14];
-                    long           s_state;
-                    long           s_magic;
-                    long           s_type;
-        Coherent FS
-                    unsigned long  s_unique;
-    Note that Coherent FS has no magic.
-* Inode layout:
-  - Minix FS
-                    unsigned short i_mode;
-                    unsigned short i_uid;
-                    unsigned long  i_size;
-                    unsigned long  i_time;
-                    unsigned char  i_gid;
-                    unsigned char  i_nlinks;
-                    unsigned short i_zone[7+1+1];
-  - Xenix FS, SystemV FS, Coherent FS
-                    unsigned short i_mode;
-                    unsigned short i_nlink;
-                    unsigned short i_uid;
-                    unsigned short i_gid;
-                    unsigned long  i_size;
-                    unsigned char  i_zone[3*(10+1+1+1)];
-                    unsigned long  i_atime;
-                    unsigned long  i_mtime;
-                    unsigned long  i_ctime;
-* Regular file data blocks are organized as
-  - Minix FS
-               7 direct blocks
-               1 indirect block (pointers to blocks)
-               1 double-indirect block (pointer to pointers to blocks)
-  - Xenix FS, SystemV FS, Coherent FS
-              10 direct blocks
-               1 indirect block (pointers to blocks)
-               1 double-indirect block (pointer to pointers to blocks)
-               1 triple-indirect block (pointer to pointers to pointers to blocks)
-* Inode size, inodes per block
-  - Minix FS        32   32
-  - Xenix FS        64   16
-  - SystemV FS      64   16
-  - Coherent FS     64    8
-* Directory entry on disk
-  - Minix FS
-                    unsigned short inode;
-                    char name[14/30];
-  - Xenix FS, SystemV FS, Coherent FS
-                    unsigned short inode;
-                    char name[14];
-* Dir entry size, dir entries per block
-  - Minix FS     16/32    64/32
-  - Xenix FS     16       64
-  - SystemV FS   16       64
-  - Coherent FS  16       32
-* How to implement symbolic links such that the host fsck doesn't scream:
-  - Minix FS     normal
-  - Xenix FS     kludge: as regular files with  chmod 1000
-  - SystemV FS   ??
-  - Coherent FS  kludge: as regular files with  chmod 1000
-Notation: We often speak of a "block" but mean a zone (the allocation unit)
-and not the disk driver's notion of "block".
-Bruno Haible  <haible@ma2s2.mathematik.uni-karlsruhe.de>
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index d63c5e48b050..ead9864567e3 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -301,13 +301,13 @@ static void sysv_delete_inode(struct inode *inode)
        unlock_kernel();
 }
-static kmem_cache_t *sysv_inode_cachep;
+static struct kmem_cache *sysv_inode_cachep;
 static struct inode *sysv_alloc_inode(struct super_block *sb)
 {
        struct sysv_inode_info *si;
-        si = kmem_cache_alloc(sysv_inode_cachep, SLAB_KERNEL);
+        si = kmem_cache_alloc(sysv_inode_cachep, GFP_KERNEL);
        if (!si)
                return NULL;
        return &si->vfs_inode;
@@ -318,7 +318,7 @@ static void sysv_destroy_inode(struct inode *inode)
        kmem_cache_free(sysv_inode_cachep, SYSV_I(inode));
 }
-static void init_once(void *p, kmem_cache_t *cachep, unsigned long flags)
+static void init_once(void *p, struct kmem_cache *cachep, unsigned long flags)
 {
        struct sysv_inode_info *si = (struct sysv_inode_info *)p;
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 1aea6a4f9a4a..1dbc2955f02e 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -107,12 +107,12 @@ static struct file_system_type udf_fstype = {
        .fs_flags       = FS_REQUIRES_DEV,
 };
-static kmem_cache_t * udf_inode_cachep;
+static struct kmem_cache * udf_inode_cachep;
 static struct inode *udf_alloc_inode(struct super_block *sb)
 {
        struct udf_inode_info *ei;
-        ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, SLAB_KERNEL);
+        ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
@@ -130,7 +130,7 @@ static void udf_destroy_inode(struct inode *inode)
        kmem_cache_free(udf_inode_cachep, UDF_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct udf_inode_info *ei = (struct udf_inode_info *) foo;
@@ -1709,7 +1709,7 @@ void udf_error(struct super_block *sb, const char *function,
                sb->s_dirt = 1;
        }
        va_start(args, fmt);
-        vsprintf(error_buf, fmt, args);
+        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
        va_end(args);
        printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
                sb->s_id, function, error_buf);
@@ -1721,7 +1721,7 @@ void udf_warning(struct super_block *sb, const char *function,
        va_list args;
        va_start (args, fmt);
-        vsprintf(error_buf, fmt, args);
+        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
        va_end(args);
        printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
                sb->s_id, function, error_buf);
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index ec79e3091d1b..8a8e9382ec09 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -224,7 +224,7 @@ void ufs_error (struct super_block * sb, const char * function,
                sb->s_flags |= MS_RDONLY;
        }
        va_start (args, fmt);
-        vsprintf (error_buf, fmt, args);
+        vsnprintf (error_buf, sizeof(error_buf), fmt, args);
        va_end (args);
        switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) {
        case UFS_MOUNT_ONERROR_PANIC:
@@ -255,7 +255,7 @@ void ufs_panic (struct super_block * sb, const char * function,
                sb->s_dirt = 1;
        }
        va_start (args, fmt);
-        vsprintf (error_buf, fmt, args);
+        vsnprintf (error_buf, sizeof(error_buf), fmt, args);
        va_end (args);
        sb->s_flags |= MS_RDONLY;
        printk (KERN_CRIT "UFS-fs panic (device %s): %s: %s\n",
@@ -268,7 +268,7 @@ void ufs_warning (struct super_block * sb, const char * function,
        va_list args;
        va_start (args, fmt);
-        vsprintf (error_buf, fmt, args);
+        vsnprintf (error_buf, sizeof(error_buf), fmt, args);
        va_end (args);
        printk (KERN_WARNING "UFS-fs warning (device %s): %s: %s\n",
                sb->s_id, function, error_buf);
@@ -1204,12 +1204,12 @@ static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
        return 0;
 }
-static kmem_cache_t * ufs_inode_cachep;
+static struct kmem_cache * ufs_inode_cachep;
 static struct inode *ufs_alloc_inode(struct super_block *sb)
 {
        struct ufs_inode_info *ei;
-        ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, SLAB_KERNEL);
+        ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        ei->vfs_inode.i_version = 1;
@@ -1221,7 +1221,7 @@ static void ufs_destroy_inode(struct inode *inode)
        kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
 }
-static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
+static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 {
        struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index 28fce6c239b5..7dd12bb1d62b 100644
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -299,7 +299,7 @@ static inline void *get_usb_offset(struct ufs_sb_private_info *uspi,
 #define ubh_get_addr16(ubh,begin) \
        (((__fs16*)((ubh)->bh[(begin) >> (uspi->s_fshift-1)]->b_data)) + \
-        ((begin) & (uspi->fsize>>1) - 1)))
+        ((begin) & ((uspi->fsize>>1) - 1)))
 #define ubh_get_addr32(ubh,begin) \
        (((__fs32*)((ubh)->bh[(begin) >> (uspi->s_fshift-2)]->b_data)) + \
diff --git a/fs/utimes.c b/fs/utimes.c
index 1bcd852fc4a9..99cf2cb11fec 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -2,6 +2,7 @@
 #include <linux/fs.h>
 #include <linux/linkage.h>
 #include <linux/namei.h>
+#include <linux/sched.h>
 #include <linux/utime.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 09360cf1e1f2..8e6b56fc1cad 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -149,9 +149,10 @@ xfs_destroy_ioend(
 */
 STATIC void
 xfs_end_bio_delalloc(
-        void                    *data)
+        struct work_struct      *work)
 {
-        xfs_ioend_t             *ioend = data;
+        xfs_ioend_t             *ioend =
+                container_of(work, xfs_ioend_t, io_work);
        xfs_destroy_ioend(ioend);
 }
@@ -161,9 +162,10 @@ xfs_end_bio_delalloc(
 */
 STATIC void
 xfs_end_bio_written(
-        void                    *data)
+        struct work_struct      *work)
 {
-        xfs_ioend_t             *ioend = data;
+        xfs_ioend_t             *ioend =
+                container_of(work, xfs_ioend_t, io_work);
        xfs_destroy_ioend(ioend);
 }
@@ -176,9 +178,10 @@ xfs_end_bio_written(
 */
 STATIC void
 xfs_end_bio_unwritten(
-        void                    *data)
+        struct work_struct      *work)
 {
-        xfs_ioend_t             *ioend = data;
+        xfs_ioend_t             *ioend =
+                container_of(work, xfs_ioend_t, io_work);
        bhv_vnode_t             *vp = ioend->io_vnode;
        xfs_off_t               offset = ioend->io_offset;
        size_t                  size = ioend->io_size;
@@ -220,11 +223,11 @@ xfs_alloc_ioend(
        ioend->io_size = 0;
        if (type == IOMAP_UNWRITTEN)
-                INIT_WORK(&ioend->io_work, xfs_end_bio_unwritten, ioend);
+                INIT_WORK(&ioend->io_work, xfs_end_bio_unwritten);
        else if (type == IOMAP_DELAY)
-                INIT_WORK(&ioend->io_work, xfs_end_bio_delalloc, ioend);
+                INIT_WORK(&ioend->io_work, xfs_end_bio_delalloc);
        else
-                INIT_WORK(&ioend->io_work, xfs_end_bio_written, ioend);
+                INIT_WORK(&ioend->io_work, xfs_end_bio_written);
        return ioend;
 }
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index d3382843698e..4fb01ffdfd1a 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -32,6 +32,7 @@
 #include <linux/kthread.h>
 #include <linux/migrate.h>
 #include <linux/backing-dev.h>
+#include <linux/freezer.h>
 STATIC kmem_zone_t *xfs_buf_zone;
 STATIC kmem_shaker_t xfs_buf_shake;
@@ -994,9 +995,10 @@ xfs_buf_wait_unpin(
 STATIC void
 xfs_buf_iodone_work(
-        void                    *v)
+        struct work_struct      *work)
 {
-        xfs_buf_t               *bp = (xfs_buf_t *)v;
+        xfs_buf_t               *bp =
+                container_of(work, xfs_buf_t, b_iodone_work);
        if (bp->b_iodone)
                (*(bp->b_iodone))(bp);
@@ -1017,10 +1019,10 @@ xfs_buf_ioend(
        if ((bp->b_iodone) || (bp->b_flags & XBF_ASYNC)) {
                if (schedule) {
-                        INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work, bp);
+                        INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work);
                        queue_work(xfslogd_workqueue, &bp->b_iodone_work);
                } else {
-                        xfs_buf_iodone_work(bp);
+                        xfs_buf_iodone_work(&bp->b_iodone_work);
                }
        } else {
                up(&bp->b_iodonesema);
@@ -1825,11 +1827,11 @@ xfs_buf_init(void)
        if (!xfs_buf_zone)
                goto out_free_trace_buf;
-        xfslogd_workqueue = create_workqueue("xfslogd");
+        xfslogd_workqueue = create_freezeable_workqueue("xfslogd");
        if (!xfslogd_workqueue)
                goto out_free_buf_zone;
-        xfsdatad_workqueue = create_workqueue("xfsdatad");
+        xfsdatad_workqueue = create_freezeable_workqueue("xfsdatad");
        if (!xfsdatad_workqueue)
                goto out_destroy_xfslogd_workqueue;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index de05abbbe7fd..b93265b7c79c 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -56,6 +56,7 @@
 #include <linux/mempool.h>
 #include <linux/writeback.h>
 #include <linux/kthread.h>
+#include <linux/freezer.h>
 STATIC struct quotactl_ops xfs_quotactl_operations;
 STATIC struct super_operations xfs_super_operations;